@ai-matrx/desktop-protocol 0.21.29 → 0.21.31

package/dist/index.js

@@ -2,7 +2,7 @@
 import { z } from "zod";
 import { UUID_SHAPE_PATTERN } from "@ai-matrx/kit/uuid";
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 37;
+var PROTOCOL_MINOR = 41;
 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_-]+$/);
@@ -394,8 +394,17 @@ var OsPermissionName = z5.enum([
   "location",
   "local_network",
   "bluetooth",
-  "notifications"
+  "notifications",
+  // (1.41) Matrx Local's remaining kinds, checked on every OS (its permissions checker): a peer
+  // older than 1.41 is never sent these rows (versioning.ts PERMISSIONS_SINCE).
+  "reminders",
+  "speech_recognition",
+  "messages",
+  "mail",
+  "wifi"
 ]);
+var OsGrantState = z5.enum(["granted", "denied", "not_determined", "not_applicable"]);
+var OsRequirementName = z5.enum(["secret_storage", "tray", "display_server", "helper_programs", "smart_app_control", "path_length"]);
 var SysinfoGetParams = z5.strictObject({});
 var SysinfoGetResult = z5.strictObject({
   device_id: DeviceId,
@@ -425,9 +434,20 @@ var SysinfoGetResult = z5.strictObject({
     z5.strictObject({
       name: OsPermissionName,
       state: z5.enum(["granted", "denied", "not_determined", "not_applicable"]),
-      settings_url: z5.string().max(512).nullable()
+      settings_url: z5.string().max(512).nullable(),
+      /** (1.41) One short fact when the state alone does not say it ("No camera", "Bluetooth is off"); absent when there is none. */
+      detail: z5.string().max(256).optional()
     })
-  )
+  ),
+  /** (1.41) The requirements beyond the grants (OsRequirementName), each read when asked. */
+  requirements: z5.array(
+    z5.strictObject({
+      name: OsRequirementName,
+      state: OsGrantState,
+      settings_url: z5.string().max(512).nullable(),
+      detail: z5.string().max(256).nullable()
+    })
+  ).optional()
 });
 var SysinfoHardwareParams = z5.strictObject({});
 var SysinfoHardwareResult = z5.strictObject({
@@ -926,7 +946,22 @@ var AccountAgent = z11.strictObject({
   shared_by: z11.string().max(320).nullable(),
   /** The organization it belongs to. */
   organization: z11.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: z11.array(z11.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: z11.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: z11.enum(["mine", "shared", "system"]).optional(),
+  /** Archived (the catalogue's archive filter decides whether the library lists it). */
+  is_archived: z11.boolean().optional(),
+  /** An orchestra: it conducts other agents. */
+  orchestra: z11.boolean().optional()
 });
 var AccountAgentsListParams = z11.strictObject({});
 var AccountAgentsListResult = z11.strictObject({
@@ -935,6 +970,70 @@ var AccountAgentsListResult = z11.strictObject({
   problem: z11.string().max(300).nullable(),
   agents: z11.array(AccountAgent).max(2e3)
 });
+var AccountAgentVariable = z11.strictObject({
+  name: z11.string().min(1).max(200),
+  /** The default value as text ("" when it has none). */
+  default_value: z11.string().max(4e3),
+  required: z11.boolean(),
+  help: z11.string().max(1e3)
+});
+var AccountAgentDetail = z11.strictObject({
+  agent: AccountAgent,
+  /** The inputs a run asks for (the agent's variables). */
+  variables: z11.array(AccountAgentVariable).max(100),
+  /** How many tools, custom tools, skills and connections it may use. */
+  tool_count: z11.int().min(0),
+  custom_tool_count: z11.int().min(0),
+  skill_count: z11.int().min(0),
+  connection_count: z11.int().min(0),
+  /** The model's display name when the catalogue knows it. */
+  model_name: z11.string().max(200).nullable()
+});
+var AccountAgentsGetParams = z11.strictObject({ agent_id: AccountRowId });
+var AccountAgentsGetResult = z11.strictObject({
+  state: AccountReadState,
+  problem: z11.string().max(300).nullable(),
+  /** Null when the person cannot open it (not theirs, not shared with them, or gone). */
+  detail: AccountAgentDetail.nullable()
+});
+var AccountAgentRunStatus = z11.enum(["succeeded", "warned", "failed", "stopped", "waiting", "running"]);
+var AccountAgentRun = z11.strictObject({
+  run_id: AccountRowId,
+  status: AccountAgentRunStatus,
+  started_at_ms: epochMs,
+  completed_at_ms: epochMs.nullable(),
+  duration_ms: z11.int().min(0).nullable(),
+  cost: z11.number().min(0).nullable(),
+  tokens: z11.int().min(0).nullable(),
+  /** One line of the answer (at most 240 characters), when the run kept one. */
+  output_preview: z11.string().max(240).nullable(),
+  /** The run's error, one line. */
+  error: z11.string().max(300).nullable(),
+  /** The mandate it served, when one named it. */
+  mandate_key: z11.string().max(200).nullable(),
+  organization: z11.string().max(200).nullable(),
+  /** The conversation that holds its transcript, when it kept one. */
+  conversation_id: AccountRowId.nullable(),
+  has_transcript: z11.boolean()
+});
+var AccountAgentRunSort = z11.enum(["started_at", "duration", "cost", "status"]);
+var AccountAgentsRunsParams = z11.strictObject({
+  agent_id: AccountRowId,
+  status: AccountAgentRunStatus.optional(),
+  sort: AccountAgentRunSort.optional(),
+  descending: z11.boolean().optional(),
+  offset: z11.int().min(0).max(1e5).optional(),
+  limit: z11.int().min(1).max(100).optional()
+});
+var AccountAgentsRunsResult = z11.strictObject({
+  state: AccountReadState,
+  problem: z11.string().max(300).nullable(),
+  /** Every run of this agent the person may see (rows is one page of it). */
+  total: z11.int().min(0),
+  rows: z11.array(AccountAgentRun).max(100)
+});
+var AccountAgentsFavoriteParams = z11.strictObject({ agent_id: AccountRowId, favorite: z11.boolean() });
+var AccountAgentsFavoriteResult = z11.strictObject({ favorite: z11.boolean() });
 var VaultItemKind = z11.enum(["login", "passkey", "key", "other"]);
 var VaultFieldSummary = z11.strictObject({
   key: z11.string().min(1).max(120),
@@ -1787,10 +1886,12 @@ var GitCloneParams = z19.strictObject({
 });
 
 // src/schema/web.ts
+import { UUID_SHAPE_PATTERN as UUID_SHAPE_PATTERN4 } from "@ai-matrx/kit/uuid";
 import { z as z20 } from "zod";
 var WEB_MAX_TEXT_CHARS = 524288;
 var WebUrl = z20.string().min(1).max(8192).regex(/^https?:\/\//);
 var WebText = z20.string().max(WEB_MAX_TEXT_CHARS);
+var OrgId = z20.string().regex(UUID_SHAPE_PATTERN4);
 var WebHeader = z20.strictObject({ name: z20.string().min(1).max(256), value: z20.string().max(8192) });
 var WebFetchParams = z20.strictObject({
   url: WebUrl,
@@ -1812,10 +1913,65 @@ var WebFetchResult = z20.strictObject({
   bytes: nonNegInt,
   elapsed_ms: nonNegInt
 });
+var WebAttachTarget = z20.strictObject({
+  entity_type: z20.string().min(1).max(64),
+  entity_id: z20.string().min(1).max(128),
+  label: z20.string().max(200).optional()
+});
+var WebLand = z20.strictObject({
+  /** The organization the page is saved in; absent: this computer's active organization. */
+  organization_id: OrgId.optional(),
+  /** Keep it: AI processing starts (chunks, search). Unkept pages are saved and wait. */
+  keep: z20.boolean().default(false),
+  attach_to: z20.array(WebAttachTarget).max(8).default([])
+});
+var WebNotSavedReason = z20.enum([
+  /** Nobody is signed in on this computer. Saved on sign-in. */
+  "signed_out",
+  /** AI Matrx could not be reached. Retried on its own. */
+  "offline",
+  /** AI Matrx refused it (the message says why). Kept until the person retries or discards it. */
+  "rejected",
+  /** Waiting its turn behind other pages (retried on its own). */
+  "queued"
+]);
+var WebSourceNotice = z20.strictObject({ code: z20.string().max(120), message: z20.string().max(2e3), remedy: z20.string().max(120) });
+var WebSourceState = z20.discriminatedUnion("state", [
+  z20.strictObject({
+    state: z20.literal("saved"),
+    processed_document_id: z20.string().min(1).max(64),
+    source_id: z20.string().min(1).max(128),
+    /** The page was already saved and nothing changed ("Already saved, no change"). */
+    reused_existing: z20.boolean(),
+    /** The page changed: this is a new version of that Source. */
+    new_version_of: z20.string().max(64).nullable(),
+    kept: z20.boolean(),
+    intelligence: z20.enum(["queued", "deferred", "never"]),
+    /** The original page as captured, kept by AI Matrx (null: the organization keeps none). */
+    original_file_id: z20.string().max(128).nullable(),
+    /** The organization it was saved in. */
+    organization_id: OrgId,
+    notices: z20.array(WebSourceNotice).max(20)
+  }),
+  z20.strictObject({
+    state: z20.literal("not_saved"),
+    outbox_id: z20.string().min(1).max(64),
+    reason: WebNotSavedReason,
+    message: z20.string().max(2e3)
+  })
+]);
 var WebScrapeParams = z20.strictObject({
   urls: z20.array(WebUrl).min(1).max(20),
   use_cache: z20.boolean().default(true),
-  get_links: z20.boolean().default(false)
+  get_links: z20.boolean().default(false),
+  /**
+   * Since 1.38. `auto` (absent): this computer's scraper (HTTP, its browser only when a page needs
+   * it). `browser`: this computer's own browser renders every page. `server`: AI Matrx's servers
+   * read it (their connection, not this computer's; saved there as a web capture).
+   */
+  engine: z20.enum(["auto", "browser", "server"]).optional(),
+  /** Since 1.38: where the pages are saved (see WebLand). */
+  land: WebLand.optional()
 });
 var WebScrapePage = z20.strictObject({
   url: z20.string(),
@@ -1830,7 +1986,9 @@ var WebScrapePage = z20.strictObject({
   /** Why the page failed (blocked, timeout, not found…), in the scraper's words; null when ok. */
   error: z20.string().nullable(),
   /** How the page was fetched (http, browser, cache). */
-  via: z20.string().nullable()
+  via: z20.string().nullable(),
+  /** Since 1.38: the page's Source (absent from a 1.37 core, and for a page that failed). */
+  source: WebSourceState.optional()
 });
 var WebScrapeResult = z20.strictObject({ pages: z20.array(WebScrapePage), elapsed_ms: nonNegInt });
 var WebSearchParams = z20.strictObject({
@@ -1854,7 +2012,9 @@ var WebBrowserFetchParams = z20.strictObject({
   wait_for: z20.string().max(1024).optional(),
   wait_timeout_ms: z20.int().min(100).max(12e4).default(3e4),
   /** true: readable text; false: the rendered HTML. */
-  extract_text: z20.boolean().default(true)
+  extract_text: z20.boolean().default(true),
+  /** Since 1.38: where the rendered page is saved (see WebLand). */
+  land: WebLand.optional()
 });
 var WebBrowserFetchResult = z20.strictObject({
   url: z20.string(),
@@ -1862,7 +2022,137 @@ var WebBrowserFetchResult = z20.strictObject({
   title: z20.string().nullable(),
   content: WebText,
   truncated: z20.boolean(),
-  elapsed_ms: nonNegInt
+  elapsed_ms: nonNegInt,
+  /** Since 1.38: the rendered page's Source (absent from a 1.37 core). */
+  source: WebSourceState.optional()
+});
+var ToolsParseFile = z20.strictObject({
+  /** Absolute path of the gzipped JSON the core reads, saves and then removes. */
+  path: z20.string().min(1).max(4096),
+  bytes: nonNegInt
+});
+var ToolsWebScrapeParams = z20.strictObject({
+  urls: z20.array(WebUrl).min(1).max(20),
+  use_cache: z20.boolean().default(true),
+  get_links: z20.boolean().default(false),
+  /** `browser`: render every page in this computer's browser, then parse it. */
+  engine: z20.enum(["auto", "browser"]).default("auto"),
+  /** Pages read at once (desktop.web/scrape_concurrency). */
+  concurrency: z20.int().min(1).max(20).default(5),
+  /** The wait between pages from the same site (desktop.web/request_delay_ms). */
+  delay_ms: z20.int().min(0).max(3e4).default(0),
+  /** Where the parse files go (the core's spool folder). */
+  spool_dir: z20.string().min(1).max(4096)
+});
+var ToolsWebScrapePage = z20.strictObject({
+  page: WebScrapePage,
+  /** The page's whole parse, for the door; null when the page failed or had no words. */
+  parse: ToolsParseFile.nullable(),
+  /** The page as fetched, for research (rendered HTML or the HTTP body); null when not kept. */
+  html: ToolsParseFile.nullable()
+});
+var ToolsWebScrapeResult = z20.strictObject({ pages: z20.array(ToolsWebScrapePage), elapsed_ms: nonNegInt });
+var ToolsWebBrowserFetchParams = z20.strictObject({
+  url: WebUrl,
+  wait_for: z20.string().max(1024).optional(),
+  wait_timeout_ms: z20.int().min(100).max(12e4).default(3e4),
+  extract_text: z20.boolean().default(true),
+  spool_dir: z20.string().min(1).max(4096)
+});
+var ToolsWebBrowserFetchResult = z20.strictObject({ result: WebBrowserFetchResult, parse: ToolsParseFile.nullable() });
+var WebRuntimeStateName = z20.enum(["not_installed", "installing", "installed", "failed"]);
+var WebRuntimeParams = z20.strictObject({});
+var WebRuntimeState = z20.strictObject({
+  state: WebRuntimeStateName,
+  /** Why it failed, in the installer's words; null otherwise. */
+  error: z20.string().max(2e3).nullable(),
+  /** Bytes the browser takes on this computer (its packages and Chromium); null when unknown. */
+  size_bytes: nonNegInt.nullable(),
+  /** Whether it can show a window while it works (false: only the headless shell is installed). */
+  can_show_window: z20.boolean()
+});
+var WebOutboxItem = z20.strictObject({
+  outbox_id: z20.string().min(1).max(64),
+  url: z20.string().max(8192),
+  title: z20.string().max(500).nullable(),
+  organization_id: OrgId.nullable(),
+  reason: WebNotSavedReason,
+  message: z20.string().max(2e3),
+  attempts: nonNegInt,
+  created_at_ms: nonNegInt,
+  last_attempt_at_ms: nonNegInt.nullable(),
+  bytes: nonNegInt
+});
+var WebOutboxListParams = z20.strictObject({});
+var WebOutboxListResult = z20.strictObject({
+  items: z20.array(WebOutboxItem),
+  bytes: nonNegInt,
+  /** The most the outbox holds; past it the oldest pages are dropped (and the log says so). */
+  cap_bytes: nonNegInt
+});
+var WebOutboxRetryParams = z20.strictObject({ outbox_id: z20.string().min(1).max(64).optional() });
+var WebOutboxRetryResult = z20.strictObject({ saved: nonNegInt, waiting: nonNegInt });
+var WebOutboxDiscardParams = z20.strictObject({ outbox_id: z20.string().min(1).max(64) });
+var WebOutboxDiscardResult = z20.strictObject({ discarded: z20.boolean() });
+var WebLogVia = z20.enum(["this_computer", "browser", "server"]);
+var WebLogCaller = z20.enum(["person", "agent", "research", "phone", "other"]);
+var WebLogResult = z20.enum(["saved", "not_saved", "failed", "blocked", "read"]);
+var WebLogEntry = z20.strictObject({
+  id: z20.string().min(1).max(64),
+  at_ms: nonNegInt,
+  caller: WebLogCaller,
+  url: z20.string().max(8192),
+  title: z20.string().max(500).nullable(),
+  result: WebLogResult,
+  /** One sentence: why it failed or was blocked, or the save's notice. Never page text. */
+  detail: z20.string().max(1e3).nullable(),
+  via: WebLogVia,
+  duration_ms: nonNegInt,
+  processed_document_id: z20.string().max(64).nullable()
+});
+var WebLogListParams = z20.strictObject({ since_ms: nonNegInt.optional(), limit: z20.int().min(1).max(1e3).default(200) });
+var WebLogListResult = z20.strictObject({ entries: z20.array(WebLogEntry) });
+var WebLogClearParams = z20.strictObject({});
+var WebLogClearResult = z20.strictObject({ cleared: nonNegInt });
+var WebProgressEvent = z20.strictObject({
+  request_id: RequestId,
+  phase: z20.enum(["installing", "fetching", "saving"]),
+  done: nonNegInt,
+  total: nonNegInt
+});
+var WebResearchItemState = z20.enum(["waiting", "fetching", "saved", "thin", "failed", "cannot_edit", "blocked"]);
+var WebResearchItem = z20.strictObject({
+  topic_id: z20.string().min(1).max(64),
+  topic_name: z20.string().max(500),
+  source_id: z20.string().min(1).max(64),
+  url: z20.string().max(8192),
+  title: z20.string().max(500).nullable(),
+  /** The capture level this computer would try (1 quick, 2 scroll); 3+ is the extension's. */
+  level: z20.int().min(1).max(4),
+  last_failure: z20.string().max(1e3).nullable(),
+  state: WebResearchItemState,
+  /** One sentence after a fetch: what happened. */
+  message: z20.string().max(1e3).nullable()
+});
+var WebResearchQueueParams = z20.strictObject({ topic_id: z20.string().min(1).max(64).optional() });
+var WebResearchQueueResult = z20.strictObject({
+  state: z20.enum(["ready", "signed_out", "unavailable"]),
+  problem: z20.string().max(1e3).nullable(),
+  /** L1/L2 items on topics this person can edit: what this computer can fetch. */
+  items: z20.array(WebResearchItem),
+  /** Items on topics the person can view but not add to (shown, never fetched). */
+  view_only: nonNegInt
+});
+var WebResearchFetchParams = z20.strictObject({
+  topic_id: z20.string().min(1).max(64).optional(),
+  source_ids: z20.array(z20.string().min(1).max(64)).max(200).optional()
+});
+var WebResearchFetchResult = z20.strictObject({
+  items: z20.array(WebResearchItem),
+  saved: nonNegInt,
+  thin: nonNegInt,
+  failed: nonNegInt,
+  cannot_edit: nonNegInt
 });
 var ToolsServiceProgress = z20.strictObject({ phase: z20.enum(["fetching", "installing"]), done: nonNegInt, total: nonNegInt });
 
@@ -1900,7 +2190,27 @@ var SystemSettingsPane = z21.enum([
   "storage",
   "system_report",
   /** (1.35) Privacy & Security › Microphone: where the person allows Matrx 2 the microphone. */
-  "microphone"
+  "microphone",
+  // (1.41) Each other privacy grant's own page (Settings › Permissions and privacy's buttons), named
+  // as sysinfo's OsPermissionName so a row opens its pane by its own name. A 1.40 core refuses these
+  // as INVALID_PARAMS, so a client asks only a 1.41 core for them.
+  "full_disk_access",
+  "accessibility",
+  "screen_recording",
+  "camera",
+  "automation",
+  "contacts",
+  "calendars",
+  "reminders",
+  "photos",
+  "location",
+  "local_network",
+  "bluetooth",
+  "wifi",
+  "notifications",
+  "speech_recognition",
+  "messages",
+  "mail"
 ]);
 var SystemOpenSettingsParams = z21.strictObject({ pane: SystemSettingsPane });
 var SystemOpenSettingsResult = z21.strictObject({ pane: SystemSettingsPane });
@@ -2606,10 +2916,10 @@ var ExecJobListResult = z31.strictObject({ jobs: z31.array(ExecJobInfo).max(64)
 
 // src/schema/coding.ts
 import { z as z32 } from "zod";
-import { UUID_SHAPE_PATTERN as UUID_SHAPE_PATTERN4 } from "@ai-matrx/kit/uuid";
+import { UUID_SHAPE_PATTERN as UUID_SHAPE_PATTERN5 } from "@ai-matrx/kit/uuid";
 var CodingServiceCredentials = z32.strictObject({
   access_token: z32.string().min(16).max(16384),
-  user_id: z32.string().regex(UUID_SHAPE_PATTERN4),
+  user_id: z32.string().regex(UUID_SHAPE_PATTERN5),
   /** The AI Matrx server this app talks to (production, or a local server on the nightly copy). */
   server_url: z32.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
@@ -2680,22 +2990,387 @@ var CodingHistoryProgressEvent = z32.strictObject({
   failed: nonNegInt
 });
 
-// src/schema/browser.ts
+// src/schema/coding-sessions.ts
 import { z as z33 } from "zod";
-var BrowserClientInstance = z33.string().min(1).max(64).regex(/^[A-Za-z0-9_.:-]+$/);
-var BrowserKind = z33.enum(["chrome", "edge", "brave", "arc", "opera", "vivaldi", "chromium", "firefox", "other"]);
-var BrowserSessionState = z33.enum(["connected", "different_account", "extension_signed_out", "device_signed_out", "unverified"]);
-var BrowserSession = z33.strictObject({
+var CodingProviderName = z33.enum(["claude", "codex"]);
+var CodingRunStatus = z33.enum(["starting", "running", "completed", "stopped", "failed"]);
+var SessionKey = z33.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var IsoTime = z33.string().min(10).max(40);
+var LocalPath = z33.string().min(1).max(4096);
+var CodingClientRequestId = z33.string().regex(/^[A-Za-z0-9_-]{8,64}$/);
+var ShortText = z33.string().max(500);
+var CodingRunUsage = z33.strictObject({
+  inputTokens: nonNegInt,
+  outputTokens: nonNegInt,
+  cachedInputTokens: nonNegInt
+});
+var CodingStartedBy = z33.strictObject({
+  kind: z33.enum(["this_computer", "web", "phone", "agent", "other"]),
+  label: z33.string().min(1).max(80)
+});
+var CodingRunRecord = z33.strictObject({
+  runId: z33.string().min(1).max(64),
+  sessionId: SessionKey,
+  provider: CodingProviderName,
+  cwd: LocalPath,
+  prompt: z33.string().max(1048576),
+  model: z33.string().max(200).nullable(),
+  status: CodingRunStatus,
+  startedAt: IsoTime,
+  endedAt: IsoTime.nullable(),
+  error: z33.string().max(65536).nullable(),
+  usage: CodingRunUsage.nullable(),
+  costUsd: z33.number().nullable(),
+  billing: z33.enum(["subscription", "api", "unknown"]).nullable(),
+  startedBy: CodingStartedBy.nullable()
+});
+var CodingSessionAgentPart = z33.strictObject({
+  part: z33.enum(["instructions", "skills", "tools"]),
+  loaded: nonNegInt,
+  total: nonNegInt
+});
+var CodingSessionAgent = z33.strictObject({
+  agentId: z33.string().min(1).max(64),
+  versionId: z33.string().max(64).nullable(),
+  versionNumber: nonNegInt.nullable(),
+  name: z33.string().max(300),
+  definitionHash: z33.string().max(200),
+  loaded: z33.array(CodingSessionAgentPart).max(3),
+  unavailable: z33.array(z33.strictObject({ kind: z33.string().max(60), name: z33.string().max(300), reason: ShortText })).max(500),
+  skills: z33.array(z33.string().max(300)).max(500),
+  tools: z33.array(z33.string().max(300)).max(500),
+  variables: z33.record(z33.string().max(200), z33.unknown()),
+  blockDue: z33.boolean(),
+  deliveredAt: IsoTime.nullable(),
+  replaces: z33.string().max(300).nullable()
+});
+var CodingSessionRecord = z33.strictObject({
+  id: SessionKey,
+  provider: CodingProviderName,
+  providerSessionId: SessionKey.nullable(),
+  cwd: LocalPath,
+  title: z33.string().max(500),
+  model: z33.string().max(200).nullable(),
+  effort: z33.string().max(40).nullable(),
+  origin: z33.enum(["started", "takeover"]),
+  createdAt: IsoTime,
+  updatedAt: IsoTime,
+  lastRunId: z33.string().max(64).nullable(),
+  lastRunStatus: CodingRunStatus.nullable(),
+  queued: z33.array(z33.string().max(1048576)).max(100),
+  agent: CodingSessionAgent.nullable(),
+  agentRemovedDue: z33.boolean()
+});
+var CodingActiveElsewhere = z33.strictObject({
+  reason: z33.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: z33.int().min(1).nullable()
+});
+var CodingTitleSource = z33.enum(["app", "app-remembered", "custom-title", "ai-title", "agent-name", "summary", "first-prompt", "last-prompt", "unknown"]);
+var CodingDiscoveredChat = z33.strictObject({
+  provider: CodingProviderName,
+  providerSessionId: SessionKey,
+  cwd: LocalPath.nullable(),
+  title: z33.string().max(500),
+  titleSource: CodingTitleSource.optional(),
+  titlePending: z33.boolean().optional(),
+  archived: z33.boolean().optional(),
+  scheduled: z33.boolean().optional(),
+  unlisted: z33.boolean().optional(),
+  unavailable: ShortText.nullable(),
+  updatedAt: IsoTime,
+  source: z33.string().max(60).nullable(),
+  activeElsewhere: CodingActiveElsewhere.nullable()
+});
+var CodingTranscriptItem = z33.discriminatedUnion("kind", [
+  z33.strictObject({ kind: z33.literal("user"), id: z33.string().max(200), text: z33.string(), at: IsoTime.nullable() }),
+  z33.strictObject({ kind: z33.literal("text"), id: z33.string().max(200), text: z33.string() }),
+  z33.strictObject({ kind: z33.literal("text-delta"), id: z33.string().max(200), text: z33.string() }),
+  z33.strictObject({ kind: z33.literal("reasoning"), id: z33.string().max(200), text: z33.string() }),
+  z33.strictObject({ kind: z33.literal("tool-call"), id: z33.string().max(200), name: z33.string().max(300), input: z33.unknown() }),
+  z33.strictObject({
+    kind: z33.literal("tool-result"),
+    id: z33.string().max(200),
+    output: z33.string(),
+    isError: z33.boolean(),
+    /** The output's full size when only its start is here; `coding.item.full` reads the rest. */
+    fullBytes: nonNegInt.optional()
+  }),
+  z33.strictObject({ kind: z33.literal("usage"), usage: CodingRunUsage, costUsd: z33.number().nullable() }),
+  z33.strictObject({ kind: z33.literal("notice"), id: z33.string().max(200), level: z33.enum(["info", "warning"]), text: z33.string() }),
+  z33.strictObject({ kind: z33.literal("error"), id: z33.string().max(200), text: z33.string() })
+]);
+var CodingHistoryRecord = z33.strictObject({
+  items: z33.array(CodingTranscriptItem),
+  /** Only the end of the chat is here; "Show earlier" reads more (a bigger `max_bytes`). */
+  truncated: z33.boolean(),
+  unavailable: ShortText.nullable(),
+  /** The last live item `seq` this read already contains; a watch applies only newer ones. */
+  seq: nonNegInt
+});
+var CodingQuotaWindow = z33.strictObject({
+  label: z33.string().max(120),
+  usedPercent: z33.number().nullable(),
+  resetsAt: z33.string().max(80).nullable(),
+  valueLabel: z33.string().max(120).nullable()
+});
+var CodingProviderProblem = z33.strictObject({
+  kind: z33.enum(["usage-limit", "signed-out"]),
+  message: z33.string().max(2e3),
+  until: z33.string().max(120).nullable(),
+  at: IsoTime
+});
+var CodingProviderBinary = z33.strictObject({
+  path: LocalPath,
+  version: z33.string().max(80).nullable(),
+  source: z33.enum(["desktop-app", "path", "npm-global", "configured"]),
+  sourceLabel: z33.string().max(120),
+  newer: z33.strictObject({ path: LocalPath, version: z33.string().max(80), sourceLabel: z33.string().max(120) }).nullable()
+});
+var CodingProviderStatus = z33.strictObject({
+  provider: CodingProviderName,
+  label: z33.string().max(60),
+  installed: z33.boolean(),
+  version: z33.string().max(80).nullable(),
+  loggedIn: z33.boolean(),
+  billing: z33.enum(["subscription", "api", "unknown"]),
+  plan: z33.string().max(80).nullable(),
+  account: z33.string().max(320).nullable(),
+  problem: ShortText.nullable(),
+  fix: ShortText.nullable(),
+  ready: z33.boolean(),
+  lastProblem: CodingProviderProblem.nullable(),
+  quota: z33.array(CodingQuotaWindow).max(20),
+  models: z33.array(z33.strictObject({ id: z33.string().max(200), label: z33.string().max(200) })).max(200),
+  efforts: z33.array(z33.string().max(40)).max(20),
+  defaultModel: z33.strictObject({ id: z33.string().max(200), source: z33.enum(["settings", "driver"]) }).nullable(),
+  defaultEffort: z33.string().max(40).nullable(),
+  binary: CodingProviderBinary.nullable()
+});
+var CodingChatPreference = z33.strictObject({
+  title: z33.string().max(500).nullable(),
+  pinned: z33.boolean(),
+  hidden: z33.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 = z33.strictObject({
+  owner: z33.boolean(),
+  pending: z33.boolean(),
+  problem: ShortText.nullable(),
+  renames: ShortText.nullable()
+});
+var CodingRecentRow = z33.strictObject({
+  target: z33.string().min(3).max(200),
+  title: z33.string().max(500),
+  provider: CodingProviderName,
+  sessionId: SessionKey.nullable(),
+  providerSessionId: SessionKey.nullable(),
+  cwd: LocalPath.nullable(),
+  updatedAt: IsoTime,
+  state: z33.enum(["running", "needs_attention", "new_output", "elsewhere", "idle"]),
+  stateLabel: z33.string().max(120).nullable(),
+  pinned: z33.boolean(),
+  startedBy: CodingStartedBy.nullable()
+});
+var CodingFolderCheck = z33.strictObject({
+  path: z33.string().max(4096),
+  exists: z33.boolean(),
+  isDirectory: z33.boolean()
+});
+var CodingRecentFolder = z33.strictObject({ path: LocalPath, lastUsedAt: IsoTime, exists: z33.boolean() });
+var CodingAgentSelectionParams = z33.strictObject({
+  agent_id: z33.string().min(1).max(64),
+  version_id: z33.string().min(1).max(64).optional(),
+  variables: z33.record(z33.string().max(200), z33.unknown()).optional()
+});
+var CodingSendResult = z33.strictObject({
+  session: CodingSessionRecord,
+  run: CodingRunRecord.nullable(),
+  /** The prompt waits behind a live run (it shows as a queued bubble). */
+  queued: z33.boolean()
+});
+var CodingProvidersParams = z33.strictObject({});
+var CodingProvidersResult = z33.strictObject({ providers: z33.array(CodingProviderStatus).max(4) });
+var CodingSessionsListParams = z33.strictObject({});
+var CodingSessionsListResult = z33.strictObject({
+  sessions: z33.array(CodingSessionRecord),
+  /** The latest run of each session, by session id. */
+  runs: z33.record(z33.string().max(128), CodingRunRecord),
+  recent: z33.array(CodingRecentRow),
+  title_status: CodingTitleStatus
+});
+var CodingDiscoverParams = z33.strictObject({ limit: z33.int().min(1).max(1e3).optional() });
+var CodingDiscoverResult = z33.strictObject({ chats: z33.array(CodingDiscoveredChat) });
+var CodingRunsListParams = z33.strictObject({ session_id: SessionKey });
+var CodingRunsListResult = z33.strictObject({ runs: z33.array(CodingRunRecord) });
+var CodingHistoryParams = z33.strictObject({ session_id: SessionKey, max_bytes: z33.int().min(1024).max(209715200).optional() });
+var CodingHistoryResult = CodingHistoryRecord;
+var CodingTranscriptReadParams = z33.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  max_bytes: z33.int().min(1024).max(209715200).optional()
+});
+var CodingTranscriptReadResult = CodingHistoryRecord;
+var CodingItemFullParams = z33.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  item_id: z33.string().min(1).max(200)
+});
+var CodingItemFullResult = z33.strictObject({ output: z33.string(), bytes: nonNegInt });
+var CodingActivityParams = z33.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingActivityResult = z33.strictObject({ active: CodingActiveElsewhere.nullable() });
+var CodingFoldersRecentParams = z33.strictObject({});
+var CodingFoldersRecentResult = z33.strictObject({ folders: z33.array(CodingRecentFolder).max(100) });
+var CodingFoldersCheckParams = z33.strictObject({ path: z33.string().min(1).max(4096) });
+var CodingFoldersCheckResult = CodingFolderCheck;
+var CodingFoldersCreateParams = z33.strictObject({ path: z33.string().min(1).max(4096) });
+var CodingFoldersCreateResult = CodingFolderCheck;
+var CodingStartParams = z33.strictObject({
+  provider: CodingProviderName,
+  cwd: z33.string().min(1).max(4096),
+  prompt: z33.string().min(1).max(1048576),
+  model: z33.string().min(1).max(200).optional(),
+  effort: z33.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: z33.string().min(1).max(64).optional(),
+  client_request_id: CodingClientRequestId
+});
+var CodingStartResult = CodingSendResult;
+var CodingTakeoverParams = z33.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  cwd: z33.string().min(1).max(4096),
+  title: z33.string().max(500).optional(),
+  agent: CodingAgentSelectionParams.optional(),
+  confirm_elsewhere: z33.boolean().optional()
+});
+var CodingTakeoverResult = z33.strictObject({ session: CodingSessionRecord });
+var CodingSendParams = z33.strictObject({
+  session_id: SessionKey,
+  prompt: z33.string().min(1).max(1048576),
+  client_request_id: CodingClientRequestId
+});
+var CodingStopParams = z33.strictObject({ run_id: z33.string().min(1).max(64) });
+var CodingStopResult = z33.strictObject({ run: CodingRunRecord.nullable() });
+var CodingStopElsewhereParams = z33.strictObject({
+  provider: CodingProviderName,
+  provider_session_id: SessionKey,
+  pid: z33.int().min(1)
+});
+var CodingStopElsewhereResult = z33.strictObject({ stopped: z33.boolean(), message: ShortText });
+var CodingOptionsSetParams = z33.strictObject({
+  session_id: SessionKey,
+  model: z33.string().max(200).optional(),
+  effort: z33.string().max(40).optional()
+});
+var CodingOptionsSetResult = z33.strictObject({ session: CodingSessionRecord });
+var CodingAgentSetParams = z33.strictObject({ session_id: SessionKey, agent: CodingAgentSelectionParams.optional() });
+var CodingAgentSetResult = z33.strictObject({ session: CodingSessionRecord });
+var CodingAgentsAccessParams = z33.strictObject({});
+var CodingAgentsAccessResult = z33.strictObject({
+  signedIn: z33.boolean(),
+  userId: z33.string().max(64).nullable(),
+  organizationId: z33.string().max(64).nullable(),
+  configured: z33.boolean()
+});
+var CodingTitlesStatusParams = z33.strictObject({});
+var CodingTitlesStatusResult = CodingTitleStatus;
+var CodingPrefsListParams = z33.strictObject({});
+var CodingPrefsListResult = z33.strictObject({ preferences: z33.record(z33.string().max(200), CodingChatPreference) });
+var CodingPrefsSetParams = z33.strictObject({
+  key: z33.string().min(1).max(200),
+  title: z33.string().min(1).max(500).optional(),
+  clear_title: z33.boolean().optional(),
+  pinned: z33.boolean().optional(),
+  hidden: z33.boolean().optional()
+});
+var CodingPrefsSetResult = CodingPrefsListResult;
+var CodingRecentSeenParams = z33.strictObject({ target: z33.string().min(3).max(200) });
+var CodingRecentSeenResult = z33.strictObject({ recent: z33.array(CodingRecentRow) });
+var CodingSearchParams = z33.strictObject({
+  query: z33.string().min(1).max(500),
+  cursor: nonNegInt.optional(),
+  limit: z33.int().min(1).max(100).optional()
+});
+var CodingSearchResult = z33.strictObject({
+  query: z33.string().max(500),
+  hits: z33.array(
+    z33.strictObject({
+      provider: CodingProviderName,
+      providerSessionId: SessionKey,
+      title: z33.string().max(500),
+      cwd: LocalPath.nullable(),
+      updatedAt: IsoTime,
+      where: z33.enum(["title", "content"]),
+      snippet: z33.string().max(2e3).nullable()
+    })
+  ),
+  scanned: nonNegInt,
+  total: nonNegInt,
+  nextCursor: nonNegInt.nullable()
+});
+var CodingReconcileParams = z33.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingReconcileResult = z33.strictObject({
+  state: z33.enum(["done", "blocked", "nothing_to_do"]),
+  summary: z33.string().max(400)
+});
+var CodingTranscriptRawParams = z33.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingTranscriptRawResult = z33.strictObject({
+  available: z33.boolean(),
+  reason: ShortText.nullable(),
+  file_name: z33.string().max(300).nullable(),
+  bytes: nonNegInt,
+  /** The opt-in cloud backup was refreshed (false: off, unchanged, or signed out). */
+  backup_refreshed: z33.boolean(),
+  /** Subagent transcripts beside the chat (Claude Code), downloaded separately. */
+  subagents: nonNegInt
+});
+var CodingWatchParams = z33.strictObject({});
+var CodingWatchResult = z33.strictObject({ resource_id: ResourceId });
+var CodingSessionWatchParams = z33.strictObject({ session_id: SessionKey, since_seq: nonNegInt.optional() });
+var CodingSessionWatchResult = z33.strictObject({
+  resource_id: ResourceId,
+  /** The newest item seq the device has for this session right now. */
+  seq: nonNegInt
+});
+var CodingChangedEvent = z33.discriminatedUnion("kind", [
+  z33.strictObject({ kind: z33.literal("session"), session: CodingSessionRecord }),
+  z33.strictObject({ kind: z33.literal("run"), run: CodingRunRecord }),
+  z33.strictObject({ kind: z33.literal("preferences"), preferences: z33.record(z33.string().max(200), CodingChatPreference) }),
+  z33.strictObject({ kind: z33.literal("titles") }),
+  z33.strictObject({ kind: z33.literal("recent"), recent: z33.array(CodingRecentRow) })
+]);
+var CodingWatchStateEvent = z33.strictObject({ live: z33.boolean(), reason: ShortText.nullable(), beat_ms: z33.int().min(1e3) });
+var CodingItemEvent = z33.strictObject({
+  session_id: SessionKey,
+  run_id: z33.string().min(1).max(64),
+  seq: nonNegInt,
+  item: CodingTranscriptItem
+});
+var CodingGapEvent = z33.strictObject({ session_id: SessionKey, since_seq: nonNegInt, seq: nonNegInt });
+var SessionIdentifyParams = z33.strictObject({ label: z33.string().min(1).max(60) });
+var SessionIdentifyResult = z33.strictObject({ label: z33.string().max(60) });
+
+// src/schema/browser.ts
+import { z as z34 } from "zod";
+var BrowserClientInstance = z34.string().min(1).max(64).regex(/^[A-Za-z0-9_.:-]+$/);
+var BrowserKind = z34.enum(["chrome", "edge", "brave", "arc", "opera", "vivaldi", "chromium", "firefox", "other"]);
+var BrowserSessionState = z34.enum(["connected", "different_account", "extension_signed_out", "device_signed_out", "unverified"]);
+var BrowserSession = z34.strictObject({
   client_instance: BrowserClientInstance,
   /** What the person sees ("Chrome — Work"), set by the extension. */
-  client_label: z33.string().min(1).max(128),
+  client_label: z34.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z33.string().min(1).max(32),
+  extension_version: z34.string().min(1).max(32),
   state: BrowserSessionState,
   /** True only for `connected`: an agent's call can reach this session. */
-  routable: z33.boolean(),
+  routable: z34.boolean(),
   /** The extension's account email from its token (null when signed out or unknown). */
-  account_email: z33.string().max(320).nullable(),
+  account_email: z34.string().max(320).nullable(),
   connected_at_ms: epochMs,
   last_call_at_ms: epochMs.nullable(),
   calls: nonNegInt,
@@ -2704,119 +3379,119 @@ var BrowserSession = z33.strictObject({
   p50_ms: nonNegInt.nullable(),
   p95_ms: nonNegInt.nullable(),
   /** A call is waiting for the person to confirm it in the browser. */
-  awaiting_confirmation: z33.boolean()
+  awaiting_confirmation: z34.boolean()
 });
-var BrowserRegisterParams = z33.strictObject({
+var BrowserRegisterParams = z34.strictObject({
   client_instance: BrowserClientInstance,
-  client_label: z33.string().min(1).max(128),
+  client_label: z34.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z33.string().min(1).max(32),
+  extension_version: z34.string().min(1).max(32),
   /** The extension's current AI Matrx access token, checked against the device owner; null when signed out. */
-  account_token: z33.string().min(16).max(8192).nullable()
+  account_token: z34.string().min(16).max(8192).nullable()
 });
-var BrowserRegisterResult = z33.strictObject({ session: BrowserSession });
-var BrowserCallError = z33.strictObject({
-  message: z33.string().max(1e3),
+var BrowserRegisterResult = z34.strictObject({ session: BrowserSession });
+var BrowserCallError = z34.strictObject({
+  message: z34.string().max(1e3),
   /** The extension's own error code, when it has one ("tool_not_found", "denied"). */
-  code: z33.string().max(64).nullable()
+  code: z34.string().max(64).nullable()
 });
-var BrowserResultParams = z33.strictObject({
-  call_id: z33.string().min(1).max(64),
-  ok: z33.boolean(),
+var BrowserResultParams = z34.strictObject({
+  call_id: z34.string().min(1).max(64),
+  ok: z34.boolean(),
   /** The tool's result when ok (any JSON). */
-  result: z33.unknown(),
+  result: z34.unknown(),
   error: BrowserCallError.nullable()
 });
-var BrowserResultResult = z33.strictObject({ accepted: z33.boolean() });
-var BrowserCallPhase = z33.enum(["awaiting_confirmation", "running"]);
-var BrowserProgressParams = z33.strictObject({ call_id: z33.string().min(1).max(64), phase: BrowserCallPhase });
-var BrowserProgressResult = z33.strictObject({ accepted: z33.boolean() });
-var BrowserSessionsParams = z33.strictObject({});
-var BrowserSessionsResult = z33.strictObject({
+var BrowserResultResult = z34.strictObject({ accepted: z34.boolean() });
+var BrowserCallPhase = z34.enum(["awaiting_confirmation", "running"]);
+var BrowserProgressParams = z34.strictObject({ call_id: z34.string().min(1).max(64), phase: BrowserCallPhase });
+var BrowserProgressResult = z34.strictObject({ accepted: z34.boolean() });
+var BrowserSessionsParams = z34.strictObject({});
+var BrowserSessionsResult = z34.strictObject({
   /** The person's Browser connection switch. Off: no pairing, no extension sessions. */
-  enabled: z33.boolean(),
+  enabled: z34.boolean(),
   /** Whether Matrx 2 is signed in (without an owner no session is routable). */
-  owner_signed_in: z33.boolean(),
-  sessions: z33.array(BrowserSession).max(64)
-});
-var BrowserDisconnectParams = z33.strictObject({ client_instance: BrowserClientInstance });
-var BrowserDisconnectResult = z33.strictObject({ disconnected: z33.boolean() });
-var BrowserSetEnabledParams = z33.strictObject({ enabled: z33.boolean() });
-var BrowserSetEnabledResult = z33.strictObject({ enabled: z33.boolean() });
-var BrowserPairCodeParams = z33.strictObject({});
-var BrowserPairCodeResult = z33.strictObject({ code: z33.string().min(16).max(128) });
-var BrowserPairResetParams = z33.strictObject({});
-var BrowserCallParams = z33.strictObject({
-  tool: z33.string().min(1).max(96).regex(/^[a-z][a-z0-9_]*$/),
-  args: z33.record(z33.string(), z33.unknown()),
+  owner_signed_in: z34.boolean(),
+  sessions: z34.array(BrowserSession).max(64)
+});
+var BrowserDisconnectParams = z34.strictObject({ client_instance: BrowserClientInstance });
+var BrowserDisconnectResult = z34.strictObject({ disconnected: z34.boolean() });
+var BrowserSetEnabledParams = z34.strictObject({ enabled: z34.boolean() });
+var BrowserSetEnabledResult = z34.strictObject({ enabled: z34.boolean() });
+var BrowserPairCodeParams = z34.strictObject({});
+var BrowserPairCodeResult = z34.strictObject({ code: z34.string().min(16).max(128) });
+var BrowserPairResetParams = z34.strictObject({});
+var BrowserCallParams = z34.strictObject({
+  tool: z34.string().min(1).max(96).regex(/^[a-z][a-z0-9_]*$/),
+  args: z34.record(z34.string(), z34.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: z33.int().min(1e3).max(6e5).optional()
+  timeout_ms: z34.int().min(1e3).max(6e5).optional()
 });
-var BrowserCallResult = z33.strictObject({
+var BrowserCallResult = z34.strictObject({
   client_instance: BrowserClientInstance,
-  result: z33.unknown(),
+  result: z34.unknown(),
   duration_ms: nonNegInt
 });
-var BrowserToolMetricsParams = z33.strictObject({ client_instance: BrowserClientInstance });
-var BrowserToolMetric = z33.strictObject({
-  tool: z33.string().max(256),
+var BrowserToolMetricsParams = z34.strictObject({ client_instance: BrowserClientInstance });
+var BrowserToolMetric = z34.strictObject({
+  tool: z34.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: z33.string().max(2048).nullable()
+  last_error: z34.string().max(2048).nullable()
 });
-var BrowserToolMetricsResult = z33.strictObject({ client_instance: z33.string(), tools: z33.array(BrowserToolMetric) });
-var BrowserResetCountersParams = z33.strictObject({ client_instance: BrowserClientInstance });
-var BrowserResetCountersResult = z33.strictObject({ reset: z33.boolean() });
-var BrowserLogParams = z33.strictObject({
+var BrowserToolMetricsResult = z34.strictObject({ client_instance: z34.string(), tools: z34.array(BrowserToolMetric) });
+var BrowserResetCountersParams = z34.strictObject({ client_instance: BrowserClientInstance });
+var BrowserResetCountersResult = z34.strictObject({ reset: z34.boolean() });
+var BrowserLogParams = z34.strictObject({
   /** Only messages after this seq (0: from the oldest kept; the core keeps the last 500). */
   after_seq: nonNegInt.default(0),
-  limit: z33.int().min(1).max(500).default(500)
+  limit: z34.int().min(1).max(500).default(500)
 });
-var BrowserLogMessage = z33.strictObject({
+var BrowserLogMessage = z34.strictObject({
   seq: nonNegInt,
   at_ms: epochMs,
-  direction: z33.enum(["to_browser", "from_browser", "core"]),
-  client_instance: z33.string(),
-  kind: z33.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
-  tool: z33.string().nullable(),
-  call_id: z33.string().nullable(),
-  ok: z33.boolean().nullable(),
-  detail: z33.string().max(1024)
-});
-var BrowserLogResult = z33.strictObject({
-  messages: z33.array(BrowserLogMessage),
+  direction: z34.enum(["to_browser", "from_browser", "core"]),
+  client_instance: z34.string(),
+  kind: z34.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
+  tool: z34.string().nullable(),
+  call_id: z34.string().nullable(),
+  ok: z34.boolean().nullable(),
+  detail: z34.string().max(1024)
+});
+var BrowserLogResult = z34.strictObject({
+  messages: z34.array(BrowserLogMessage),
   /** The newest seq the core has written (pass it back as after_seq to follow the log). */
   last_seq: nonNegInt
 });
-var BrowserInvokeEvent = z33.strictObject({
-  call_id: z33.string().min(1).max(64),
-  tool: z33.string().min(1).max(96),
-  args: z33.record(z33.string(), z33.unknown()),
+var BrowserInvokeEvent = z34.strictObject({
+  call_id: z34.string().min(1).max(64),
+  tool: z34.string().min(1).max(96),
+  args: z34.record(z34.string(), z34.unknown()),
   deadline_ms: epochMs
 });
-var BrowserSessionsChangedEvent = z33.strictObject({ count: nonNegInt, enabled: z33.boolean() });
-var BrowserProgressEvent = z33.strictObject({
-  call_id: z33.string().min(1).max(64),
+var BrowserSessionsChangedEvent = z34.strictObject({ count: nonNegInt, enabled: z34.boolean() });
+var BrowserProgressEvent = z34.strictObject({
+  call_id: z34.string().min(1).max(64),
   client_instance: BrowserClientInstance,
   phase: BrowserCallPhase
 });
-var DesktopHealth = z33.strictObject({
-  status: z33.literal("ok"),
-  service: z33.literal("matrx-desktop"),
-  version: z33.string().max(32),
-  protocol_version: z33.string().max(16),
-  ws_path: z33.literal("/v1/connect"),
-  device_id: z33.string().max(64),
-  browser_connection: z33.enum(["on", "off"])
-});
-var BrowserPairRequest = z33.strictObject({ client_instance: BrowserClientInstance });
-var BrowserPairResult = z33.strictObject({ pair_token: z33.string().min(16).max(128), ws_path: z33.literal("/v1/connect") });
+var DesktopHealth = z34.strictObject({
+  status: z34.literal("ok"),
+  service: z34.literal("matrx-desktop"),
+  version: z34.string().max(32),
+  protocol_version: z34.string().max(16),
+  ws_path: z34.literal("/v1/connect"),
+  device_id: z34.string().max(64),
+  browser_connection: z34.enum(["on", "off"])
+});
+var BrowserPairRequest = z34.strictObject({ client_instance: BrowserClientInstance });
+var BrowserPairResult = z34.strictObject({ pair_token: z34.string().min(16).max(128), ws_path: z34.literal("/v1/connect") });
 var MATRX_EXTENSION_IDS = {
   store: "hnfolienncfklkgmdjjmhhegglimlamg",
   development: "cihdmkcdjjckfhjpgoedmgfpoljebaml"
@@ -2824,572 +3499,572 @@ var MATRX_EXTENSION_IDS = {
 var DISCOVERY_FILE = { live: "matrx2.json", development: "matrx2-dev.json" };
 
 // src/schema/net.ts
-import { z as z34 } from "zod";
-var NetInfoParams = z34.strictObject({});
-var NetAddress = z34.strictObject({
-  address: z34.string(),
-  family: z34.enum(["ipv4", "ipv6"]),
-  netmask: z34.string().nullable(),
+import { z as z35 } from "zod";
+var NetInfoParams = z35.strictObject({});
+var NetAddress = z35.strictObject({
+  address: z35.string(),
+  family: z35.enum(["ipv4", "ipv6"]),
+  netmask: z35.string().nullable(),
   /** CIDR form ("192.168.1.20/24"); null where the OS gives no prefix. */
-  cidr: z34.string().nullable()
+  cidr: z35.string().nullable()
 });
-var NetInterface = z34.strictObject({
-  name: z34.string(),
-  mac: z34.string().nullable(),
+var NetInterface = z35.strictObject({
+  name: z35.string(),
+  mac: z35.string().nullable(),
   /** Loopback and other internal interfaces. */
-  internal: z34.boolean(),
-  addresses: z34.array(NetAddress)
+  internal: z35.boolean(),
+  addresses: z35.array(NetAddress)
 });
-var NetInfoResult = z34.strictObject({
-  hostname: z34.string(),
-  interfaces: z34.array(NetInterface),
+var NetInfoResult = z35.strictObject({
+  hostname: z35.string(),
+  interfaces: z35.array(NetInterface),
   /** The default route's gateway; null when the OS does not say (or there is none). */
-  gateway: z34.string().nullable(),
+  gateway: z35.string().nullable(),
   /** The DNS servers the OS uses; empty when it does not say. */
-  dns: z34.array(z34.string())
+  dns: z35.array(z35.string())
 });
-var NetWifiParams = z34.strictObject({});
-var NetWifiNetwork = z34.strictObject({
+var NetWifiParams = z35.strictObject({});
+var NetWifiNetwork = z35.strictObject({
   /** null: the OS hides the name (macOS without Location Services for this app). */
-  ssid: z34.string().nullable(),
+  ssid: z35.string().nullable(),
   /** dBm; null where the OS does not say. */
-  rssi: z34.int().nullable(),
-  channel: z34.string().nullable(),
-  security: z34.string().nullable()
+  rssi: z35.int().nullable(),
+  channel: z35.string().nullable(),
+  security: z35.string().nullable()
 });
-var NetWifiResult = z34.strictObject({
+var NetWifiResult = z35.strictObject({
   /** Whether the computer has a Wi-Fi interface at all. */
-  available: z34.boolean(),
+  available: z35.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: z34.array(NetWifiNetwork)
+  networks: z35.array(NetWifiNetwork)
 });
-var NetBluetoothParams = z34.strictObject({});
-var NetBluetoothDevice = z34.strictObject({
-  name: z34.string(),
-  address: z34.string().nullable(),
-  connected: z34.boolean(),
+var NetBluetoothParams = z35.strictObject({});
+var NetBluetoothDevice = z35.strictObject({
+  name: z35.string(),
+  address: z35.string().nullable(),
+  connected: z35.boolean(),
   /** What it is, in the OS's words ("Headphones", "Keyboard"); null where it does not say. */
-  kind: z34.string().nullable(),
+  kind: z35.string().nullable(),
   /** Battery percent, where the OS reports it. */
-  battery: z34.int().min(0).max(100).nullable()
+  battery: z35.int().min(0).max(100).nullable()
 });
-var NetBluetoothResult = z34.strictObject({
+var NetBluetoothResult = z35.strictObject({
   /** Bluetooth is on; null where the OS does not say. */
-  powered: z34.boolean().nullable(),
-  devices: z34.array(NetBluetoothDevice)
-});
-var NetDevicesParams = z34.strictObject({});
-var NetDevice = z34.strictObject({
-  ip: z34.string(),
-  mac: z34.string().nullable(),
-  interface: z34.string().nullable(),
+  powered: z35.boolean().nullable(),
+  devices: z35.array(NetBluetoothDevice)
+});
+var NetDevicesParams = z35.strictObject({});
+var NetDevice = z35.strictObject({
+  ip: z35.string(),
+  mac: z35.string().nullable(),
+  interface: z35.string().nullable(),
   /** The name the local network gives it (reverse DNS / mDNS), when the table carries one. */
-  hostname: z34.string().nullable()
+  hostname: z35.string().nullable()
 });
-var NetDevicesResult = z34.strictObject({ devices: z34.array(NetDevice) });
-var NetMdnsParams = z34.strictObject({
+var NetDevicesResult = z35.strictObject({ devices: z35.array(NetDevice) });
+var NetMdnsParams = z35.strictObject({
   /** A service type ("_http._tcp"); absent lists the service types found. */
-  service_type: z34.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
+  service_type: z35.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
   /** How long to listen. */
-  timeout_s: z34.int().min(1).max(30).default(3)
+  timeout_s: z35.int().min(1).max(30).default(3)
 });
-var NetMdnsService = z34.strictObject({
-  name: z34.string(),
-  type: z34.string(),
-  domain: z34.string(),
-  interface: z34.string().nullable()
+var NetMdnsService = z35.strictObject({
+  name: z35.string(),
+  type: z35.string(),
+  domain: z35.string(),
+  interface: z35.string().nullable()
 });
-var NetMdnsResult = z34.strictObject({ services: z34.array(NetMdnsService) });
-var NetScanParams = z34.strictObject({
+var NetMdnsResult = z35.strictObject({ services: z35.array(NetMdnsService) });
+var NetScanParams = z35.strictObject({
   /** A host name or address; a private or loopback address unless `allow_public`. */
-  host: z34.string().min(1).max(253),
-  ports: z34.array(z34.int().min(1).max(65535)).min(1).max(1024),
-  timeout_ms: z34.int().min(50).max(1e4).default(800),
+  host: z35.string().min(1).max(253),
+  ports: z35.array(z35.int().min(1).max(65535)).min(1).max(1024),
+  timeout_ms: z35.int().min(50).max(1e4).default(800),
   /** Scanning a host on the public internet needs saying so. */
-  allow_public: z34.boolean().default(false)
+  allow_public: z35.boolean().default(false)
 });
-var NetScanResult = z34.strictObject({
-  host: z34.string(),
+var NetScanResult = z35.strictObject({
+  host: z35.string(),
   /** The address the host resolved to. */
-  address: z34.string(),
-  open: z34.array(z34.int().min(1).max(65535)),
+  address: z35.string(),
+  open: z35.array(z35.int().min(1).max(65535)),
   closed: nonNegInt,
   elapsed_ms: nonNegInt
 });
-var NetDownloadParams = z34.strictObject({
-  url: z34.string().min(1).max(8192).regex(/^https?:\/\//),
+var NetDownloadParams = z35.strictObject({
+  url: z35.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: z34.boolean().default(false),
-  timeout_s: z34.int().min(1).max(3600).default(300),
+  overwrite: z35.boolean().default(false),
+  timeout_s: z35.int().min(1).max(3600).default(300),
   /** Refuse anything larger. */
-  max_bytes: z34.int().min(1).max(10737418240).default(2147483648)
+  max_bytes: z35.int().min(1).max(10737418240).default(2147483648)
 });
-var NetDownloadResult = z34.strictObject({
-  path: z34.string(),
+var NetDownloadResult = z35.strictObject({
+  path: z35.string(),
   bytes: nonNegInt,
-  content_type: z34.string().nullable(),
+  content_type: z35.string().nullable(),
   /** The final URL after redirects. */
-  url: z34.string(),
+  url: z35.string(),
   elapsed_ms: nonNegInt
 });
 
 // src/schema/personal.ts
-import { z as z35 } from "zod";
-var Text = z35.string().max(65536);
-var AutomationScriptParams = z35.strictObject({
+import { z as z36 } from "zod";
+var Text = z36.string().max(65536);
+var AutomationScriptParams = z36.strictObject({
   /** applescript and jxa: macOS (osascript); powershell: Windows (and pwsh where installed). */
-  language: z35.enum(["applescript", "jxa", "powershell"]),
-  script: z35.string().min(1).max(262144),
-  timeout_s: z35.int().min(1).max(600).default(60)
-});
-var AutomationScriptResult = z35.strictObject({
-  stdout: z35.string(),
-  stderr: z35.string(),
-  exit_code: z35.int(),
-  timed_out: z35.boolean(),
+  language: z36.enum(["applescript", "jxa", "powershell"]),
+  script: z36.string().min(1).max(262144),
+  timeout_s: z36.int().min(1).max(600).default(60)
+});
+var AutomationScriptResult = z36.strictObject({
+  stdout: z36.string(),
+  stderr: z36.string(),
+  exit_code: z36.int(),
+  timed_out: z36.boolean(),
   /** stdout or stderr was cut at 1 MiB. */
-  truncated: z35.boolean(),
+  truncated: z36.boolean(),
   elapsed_ms: nonNegInt
 });
-var MailAccountsParams = z35.strictObject({});
-var MailAccount = z35.strictObject({ name: z35.string(), emails: z35.array(z35.string()), enabled: z35.boolean() });
-var MailAccountsResult = z35.strictObject({ accounts: z35.array(MailAccount) });
-var MailListParams = z35.strictObject({
+var MailAccountsParams = z36.strictObject({});
+var MailAccount = z36.strictObject({ name: z36.string(), emails: z36.array(z36.string()), enabled: z36.boolean() });
+var MailAccountsResult = z36.strictObject({ accounts: z36.array(MailAccount) });
+var MailListParams = z36.strictObject({
   /** The account's name in Mail; absent: every account. */
-  account: z35.string().min(1).max(256).optional(),
+  account: z36.string().min(1).max(256).optional(),
   /** The mailbox's name ("INBOX", "Sent Messages"). */
-  mailbox: z35.string().min(1).max(256).default("INBOX"),
-  unread_only: z35.boolean().default(false),
-  limit: z35.int().min(1).max(200).default(25)
-});
-var MailMessage = z35.strictObject({
-  id: z35.string(),
-  subject: z35.string(),
-  sender: z35.string(),
+  mailbox: z36.string().min(1).max(256).default("INBOX"),
+  unread_only: z36.boolean().default(false),
+  limit: z36.int().min(1).max(200).default(25)
+});
+var MailMessage = z36.strictObject({
+  id: z36.string(),
+  subject: z36.string(),
+  sender: z36.string(),
   received_at_ms: epochMs.nullable(),
-  read: z35.boolean(),
-  account: z35.string(),
-  mailbox: z35.string(),
+  read: z36.boolean(),
+  account: z36.string(),
+  mailbox: z36.string(),
   /** The first lines of the message's text. */
-  preview: z35.string()
+  preview: z36.string()
 });
-var MailListResult = z35.strictObject({ messages: z35.array(MailMessage) });
-var MailSendParams = z35.strictObject({
-  to: z35.array(z35.string().min(3).max(320)).min(1).max(50),
-  cc: z35.array(z35.string().min(3).max(320)).max(50).default([]),
-  subject: z35.string().max(998),
+var MailListResult = z36.strictObject({ messages: z36.array(MailMessage) });
+var MailSendParams = z36.strictObject({
+  to: z36.array(z36.string().min(3).max(320)).min(1).max(50),
+  cc: z36.array(z36.string().min(3).max(320)).max(50).default([]),
+  subject: z36.string().max(998),
   body: Text,
   /** The sending account's address; absent: Mail's default. */
-  from: z35.string().min(3).max(320).optional(),
+  from: z36.string().min(3).max(320).optional(),
   /** false leaves it open in Mail as a draft for the person to send. */
-  send: z35.boolean().default(true)
-});
-var MailSendResult = z35.strictObject({ sent: z35.boolean() });
-var MessagesChatsParams = z35.strictObject({ limit: z35.int().min(1).max(200).default(25) });
-var MessagesChat = z35.strictObject({
-  chat_id: z35.string(),
-  name: z35.string().nullable(),
-  participants: z35.array(z35.string()),
+  send: z36.boolean().default(true)
+});
+var MailSendResult = z36.strictObject({ sent: z36.boolean() });
+var MessagesChatsParams = z36.strictObject({ limit: z36.int().min(1).max(200).default(25) });
+var MessagesChat = z36.strictObject({
+  chat_id: z36.string(),
+  name: z36.string().nullable(),
+  participants: z36.array(z36.string()),
   last_message_at_ms: epochMs.nullable(),
-  service: z35.string().nullable()
+  service: z36.string().nullable()
 });
-var MessagesChatsResult = z35.strictObject({ chats: z35.array(MessagesChat) });
-var MessagesListParams = z35.strictObject({
+var MessagesChatsResult = z36.strictObject({ chats: z36.array(MessagesChat) });
+var MessagesListParams = z36.strictObject({
   /** One chat (messages.chats' chat_id); absent: the newest across all. */
-  chat_id: z35.string().min(1).max(512).optional(),
-  limit: z35.int().min(1).max(500).default(50)
-});
-var MessagesMessage = z35.strictObject({
-  id: z35.string(),
-  chat_id: z35.string().nullable(),
-  text: z35.string(),
-  from_me: z35.boolean(),
+  chat_id: z36.string().min(1).max(512).optional(),
+  limit: z36.int().min(1).max(500).default(50)
+});
+var MessagesMessage = z36.strictObject({
+  id: z36.string(),
+  chat_id: z36.string().nullable(),
+  text: z36.string(),
+  from_me: z36.boolean(),
   /** The other person's handle (phone or email); null for the person's own messages. */
-  sender: z35.string().nullable(),
+  sender: z36.string().nullable(),
   sent_at_ms: epochMs.nullable()
 });
-var MessagesListResult = z35.strictObject({ messages: z35.array(MessagesMessage) });
-var MessagesSendParams = z35.strictObject({
+var MessagesListResult = z36.strictObject({ messages: z36.array(MessagesMessage) });
+var MessagesSendParams = z36.strictObject({
   /** A phone number or email the person can message. */
-  to: z35.string().min(3).max(320),
-  text: z35.string().min(1).max(2e4)
+  to: z36.string().min(3).max(320),
+  text: z36.string().min(1).max(2e4)
 });
-var MessagesSendResult = z35.strictObject({ sent: z35.boolean() });
-var ContactsSearchParams = z35.strictObject({
+var MessagesSendResult = z36.strictObject({ sent: z36.boolean() });
+var ContactsSearchParams = z36.strictObject({
   /** Matched against names, organizations, emails and phone numbers. */
-  query: z35.string().min(1).max(256),
-  limit: z35.int().min(1).max(200).default(25)
+  query: z36.string().min(1).max(256),
+  limit: z36.int().min(1).max(200).default(25)
 });
-var ContactLabeled = z35.strictObject({ label: z35.string().nullable(), value: z35.string() });
-var ContactSummary = z35.strictObject({
-  id: z35.string(),
-  name: z35.string(),
-  organization: z35.string().nullable(),
-  emails: z35.array(ContactLabeled),
-  phones: z35.array(ContactLabeled)
-});
-var ContactsSearchResult = z35.strictObject({ contacts: z35.array(ContactSummary) });
-var ContactsGetParams = z35.strictObject({ id: z35.string().min(1).max(256) });
-var ContactDetail = z35.strictObject({
-  id: z35.string(),
-  name: z35.string(),
-  organization: z35.string().nullable(),
-  job_title: z35.string().nullable(),
-  emails: z35.array(ContactLabeled),
-  phones: z35.array(ContactLabeled),
-  addresses: z35.array(ContactLabeled),
-  birthday: z35.string().nullable(),
-  note: z35.string().nullable()
-});
-var ContactsGetResult = z35.strictObject({ contact: ContactDetail });
-var CalendarListParams = z35.strictObject({
+var ContactLabeled = z36.strictObject({ label: z36.string().nullable(), value: z36.string() });
+var ContactSummary = z36.strictObject({
+  id: z36.string(),
+  name: z36.string(),
+  organization: z36.string().nullable(),
+  emails: z36.array(ContactLabeled),
+  phones: z36.array(ContactLabeled)
+});
+var ContactsSearchResult = z36.strictObject({ contacts: z36.array(ContactSummary) });
+var ContactsGetParams = z36.strictObject({ id: z36.string().min(1).max(256) });
+var ContactDetail = z36.strictObject({
+  id: z36.string(),
+  name: z36.string(),
+  organization: z36.string().nullable(),
+  job_title: z36.string().nullable(),
+  emails: z36.array(ContactLabeled),
+  phones: z36.array(ContactLabeled),
+  addresses: z36.array(ContactLabeled),
+  birthday: z36.string().nullable(),
+  note: z36.string().nullable()
+});
+var ContactsGetResult = z36.strictObject({ contact: ContactDetail });
+var CalendarListParams = z36.strictObject({
   from_ms: epochMs,
   to_ms: epochMs,
   /** One calendar's name; absent: every calendar. */
-  calendar: z35.string().min(1).max(256).optional(),
-  limit: z35.int().min(1).max(500).default(100)
+  calendar: z36.string().min(1).max(256).optional(),
+  limit: z36.int().min(1).max(500).default(100)
 });
-var CalendarEvent = z35.strictObject({
-  id: z35.string(),
-  title: z35.string(),
+var CalendarEvent = z36.strictObject({
+  id: z36.string(),
+  title: z36.string(),
   start_ms: epochMs,
   end_ms: epochMs,
-  all_day: z35.boolean(),
-  calendar: z35.string(),
-  location: z35.string().nullable(),
-  notes: z35.string().nullable()
-});
-var CalendarListResult = z35.strictObject({ events: z35.array(CalendarEvent) });
-var CalendarCreateParams = z35.strictObject({
-  title: z35.string().min(1).max(1024),
+  all_day: z36.boolean(),
+  calendar: z36.string(),
+  location: z36.string().nullable(),
+  notes: z36.string().nullable()
+});
+var CalendarListResult = z36.strictObject({ events: z36.array(CalendarEvent) });
+var CalendarCreateParams = z36.strictObject({
+  title: z36.string().min(1).max(1024),
   start_ms: epochMs,
   end_ms: epochMs,
-  all_day: z35.boolean().default(false),
+  all_day: z36.boolean().default(false),
   /** The calendar's name; absent: the first writable calendar. */
-  calendar: z35.string().min(1).max(256).optional(),
-  location: z35.string().max(1024).optional(),
+  calendar: z36.string().min(1).max(256).optional(),
+  location: z36.string().max(1024).optional(),
   notes: Text.optional()
 });
-var CalendarCreateResult = z35.strictObject({ id: z35.string(), calendar: z35.string() });
-var RemindersListParams = z35.strictObject({
+var CalendarCreateResult = z36.strictObject({ id: z36.string(), calendar: z36.string() });
+var RemindersListParams = z36.strictObject({
   /** One list's name; absent: every list. */
-  list: z35.string().min(1).max(256).optional(),
-  include_completed: z35.boolean().default(false),
-  limit: z35.int().min(1).max(500).default(100)
-});
-var Reminder = z35.strictObject({
-  id: z35.string(),
-  title: z35.string(),
-  list: z35.string(),
+  list: z36.string().min(1).max(256).optional(),
+  include_completed: z36.boolean().default(false),
+  limit: z36.int().min(1).max(500).default(100)
+});
+var Reminder = z36.strictObject({
+  id: z36.string(),
+  title: z36.string(),
+  list: z36.string(),
   due_ms: epochMs.nullable(),
-  completed: z35.boolean(),
-  notes: z35.string().nullable()
+  completed: z36.boolean(),
+  notes: z36.string().nullable()
 });
-var RemindersListResult = z35.strictObject({ reminders: z35.array(Reminder) });
-var RemindersCreateParams = z35.strictObject({
-  title: z35.string().min(1).max(1024),
+var RemindersListResult = z36.strictObject({ reminders: z36.array(Reminder) });
+var RemindersCreateParams = z36.strictObject({
+  title: z36.string().min(1).max(1024),
   due_ms: epochMs.optional(),
-  list: z35.string().min(1).max(256).optional(),
+  list: z36.string().min(1).max(256).optional(),
   notes: Text.optional()
 });
-var RemindersCreateResult = z35.strictObject({ id: z35.string(), list: z35.string() });
-var PhotosSearchParams = z35.strictObject({
+var RemindersCreateResult = z36.strictObject({ id: z36.string(), list: z36.string() });
+var PhotosSearchParams = z36.strictObject({
   /** Matched against file names, titles, descriptions and keywords; absent: the newest. */
-  query: z35.string().min(1).max(256).optional(),
+  query: z36.string().min(1).max(256).optional(),
   from_ms: epochMs.optional(),
   to_ms: epochMs.optional(),
-  favorites_only: z35.boolean().default(false),
-  limit: z35.int().min(1).max(200).default(25)
+  favorites_only: z36.boolean().default(false),
+  limit: z36.int().min(1).max(200).default(25)
 });
-var Photo = z35.strictObject({
-  id: z35.string(),
-  filename: z35.string(),
+var Photo = z36.strictObject({
+  id: z36.string(),
+  filename: z36.string(),
   taken_at_ms: epochMs.nullable(),
   width: nonNegInt.nullable(),
   height: nonNegInt.nullable(),
-  favorite: z35.boolean(),
-  title: z35.string().nullable()
+  favorite: z36.boolean(),
+  title: z36.string().nullable()
 });
-var PhotosSearchResult = z35.strictObject({ photos: z35.array(Photo) });
-var PhotosGetParams = z35.strictObject({
-  id: z35.string().min(1).max(256),
+var PhotosSearchResult = z36.strictObject({ photos: z36.array(Photo) });
+var PhotosGetParams = z36.strictObject({
+  id: z36.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: z35.boolean().default(false)
+  export: z36.boolean().default(false)
 });
-var PhotosGetResult = z35.strictObject({ photo: Photo, path: z35.string().nullable() });
-var LocationGetParams = z35.strictObject({ timeout_s: z35.int().min(1).max(60).default(15) });
-var LocationGetResult = z35.strictObject({
-  latitude: z35.number().min(-90).max(90),
-  longitude: z35.number().min(-180).max(180),
+var PhotosGetResult = z36.strictObject({ photo: Photo, path: z36.string().nullable() });
+var LocationGetParams = z36.strictObject({ timeout_s: z36.int().min(1).max(60).default(15) });
+var LocationGetResult = z36.strictObject({
+  latitude: z36.number().min(-90).max(90),
+  longitude: z36.number().min(-180).max(180),
   /** Metres; null where the OS does not say. */
-  accuracy_m: z35.number().min(0).nullable(),
+  accuracy_m: z36.number().min(0).nullable(),
   at_ms: epochMs,
   /** Who answered: the OS's own location service. */
-  source: z35.enum(["corelocation", "windows", "geoclue"])
+  source: z36.enum(["corelocation", "windows", "geoclue"])
 });
 
 // src/schema/windows.ts
-import { z as z36 } from "zod";
-var RegistryKey = z36.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 = z36.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
-var WindowsRegistryReadParams = z36.strictObject({
+import { z as z37 } from "zod";
+var RegistryKey = z37.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 = z37.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
+var WindowsRegistryReadParams = z37.strictObject({
   key: RegistryKey,
   /** One value's name ("" is the key's default value); absent: every value and the subkeys. */
-  name: z36.string().max(16383).optional()
+  name: z37.string().max(16383).optional()
 });
-var RegistryValue = z36.strictObject({ name: z36.string(), type: RegistryValueType, data: z36.string() });
-var WindowsRegistryReadResult = z36.strictObject({
-  key: z36.string(),
-  exists: z36.boolean(),
-  values: z36.array(RegistryValue),
-  subkeys: z36.array(z36.string())
+var RegistryValue = z37.strictObject({ name: z37.string(), type: RegistryValueType, data: z37.string() });
+var WindowsRegistryReadResult = z37.strictObject({
+  key: z37.string(),
+  exists: z37.boolean(),
+  values: z37.array(RegistryValue),
+  subkeys: z37.array(z37.string())
 });
-var WindowsRegistryWriteParams = z36.strictObject({
+var WindowsRegistryWriteParams = z37.strictObject({
   key: RegistryKey,
-  name: z36.string().max(16383),
+  name: z37.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: z36.string().max(1048576),
+  data: z37.string().max(1048576),
   /** Remove the value instead of writing it. */
-  delete: z36.boolean().default(false)
+  delete: z37.boolean().default(false)
 });
-var WindowsRegistryWriteResult = z36.strictObject({ key: z36.string(), name: z36.string(), deleted: z36.boolean() });
-var WindowsServicesParams = z36.strictObject({
+var WindowsRegistryWriteResult = z37.strictObject({ key: z37.string(), name: z37.string(), deleted: z37.boolean() });
+var WindowsServicesParams = z37.strictObject({
   /** Matched against the service's name and display name. */
-  filter: z36.string().min(1).max(256).optional(),
-  limit: z36.int().min(1).max(1e3).default(200)
+  filter: z37.string().min(1).max(256).optional(),
+  limit: z37.int().min(1).max(1e3).default(200)
 });
-var WindowsService = z36.strictObject({
-  name: z36.string(),
-  display_name: z36.string(),
+var WindowsService = z37.strictObject({
+  name: z37.string(),
+  display_name: z37.string(),
   /** Running, Stopped, Paused… as Windows says it. */
-  status: z36.string(),
+  status: z37.string(),
   /** Automatic, Manual, Disabled…; null where Windows does not say. */
-  start_type: z36.string().nullable()
+  start_type: z37.string().nullable()
 });
-var WindowsServicesResult = z36.strictObject({ services: z36.array(WindowsService) });
-var WindowsServiceControlParams = z36.strictObject({
-  name: z36.string().min(1).max(256),
-  action: z36.enum(["start", "stop", "restart"])
+var WindowsServicesResult = z37.strictObject({ services: z37.array(WindowsService) });
+var WindowsServiceControlParams = z37.strictObject({
+  name: z37.string().min(1).max(256),
+  action: z37.enum(["start", "stop", "restart"])
 });
-var WindowsServiceControlResult = z36.strictObject({ name: z36.string(), status: z36.string() });
-var WindowsEventLogParams = z36.strictObject({
-  log: z36.string().min(1).max(256).default("System"),
+var WindowsServiceControlResult = z37.strictObject({ name: z37.string(), status: z37.string() });
+var WindowsEventLogParams = z37.strictObject({
+  log: z37.string().min(1).max(256).default("System"),
   /** Only these levels; absent: all. */
-  levels: z36.array(z36.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
+  levels: z37.array(z37.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
   since_ms: epochMs.optional(),
-  limit: z36.int().min(1).max(500).default(50)
+  limit: z37.int().min(1).max(500).default(50)
 });
-var WindowsEvent = z36.strictObject({
-  id: z36.int(),
-  level: z36.string(),
-  source: z36.string(),
+var WindowsEvent = z37.strictObject({
+  id: z37.int(),
+  level: z37.string(),
+  source: z37.string(),
   at_ms: epochMs,
-  message: z36.string()
+  message: z37.string()
 });
-var WindowsEventLogResult = z36.strictObject({ log: z36.string(), events: z36.array(WindowsEvent) });
-var WindowsFeaturesParams = z36.strictObject({ filter: z36.string().min(1).max(256).optional() });
-var WindowsFeature = z36.strictObject({ name: z36.string(), state: z36.string() });
-var WindowsFeaturesResult = z36.strictObject({ features: z36.array(WindowsFeature) });
+var WindowsEventLogResult = z37.strictObject({ log: z37.string(), events: z37.array(WindowsEvent) });
+var WindowsFeaturesParams = z37.strictObject({ filter: z37.string().min(1).max(256).optional() });
+var WindowsFeature = z37.strictObject({ name: z37.string(), state: z37.string() });
+var WindowsFeaturesResult = z37.strictObject({ features: z37.array(WindowsFeature) });
 
 // src/schema/schedule.ts
-import { z as z37 } from "zod";
-var OpRef = z37.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
-var ScheduleCreateParams = z37.strictObject({
-  name: z37.string().min(1).max(200),
+import { z as z38 } from "zod";
+var OpRef = z38.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
+var ScheduleCreateParams = z38.strictObject({
+  name: z38.string().min(1).max(200),
   op: OpRef,
   /** The op's params, exactly as the op takes them; checked when the task is created. */
-  params: z37.record(z37.string(), z37.unknown()).default({}),
-  interval_s: z37.int().min(10).max(2592e3),
+  params: z38.record(z38.string(), z38.unknown()).default({}),
+  interval_s: z38.int().min(10).max(2592e3),
   /** Stop after this many runs; absent: until cancelled. */
-  max_runs: z37.int().min(1).max(1e5).optional(),
+  max_runs: z38.int().min(1).max(1e5).optional(),
   /** Run once now, before the first interval. */
-  run_now: z37.boolean().default(false)
+  run_now: z38.boolean().default(false)
 });
-var ScheduleRun = z37.strictObject({
+var ScheduleRun = z38.strictObject({
   at_ms: epochMs,
-  ok: z37.boolean(),
+  ok: z38.boolean(),
   elapsed_ms: nonNegInt,
   /** The error's code and message when the run failed. */
-  error: z37.string().nullable(),
+  error: z38.string().nullable(),
   /** The start of the answer, as JSON (cut at 4 KiB). */
-  result_preview: z37.string().nullable()
+  result_preview: z38.string().nullable()
 });
-var ScheduledTask = z37.strictObject({
-  id: z37.string(),
-  name: z37.string(),
-  op: z37.string(),
-  params: z37.record(z37.string(), z37.unknown()),
+var ScheduledTask = z38.strictObject({
+  id: z38.string(),
+  name: z38.string(),
+  op: z38.string(),
+  params: z38.record(z38.string(), z38.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: z37.enum(["active", "done", "cancelled"]),
+  state: z38.enum(["active", "done", "cancelled"]),
   /** The newest runs, newest first (at most 10). */
-  recent: z37.array(ScheduleRun)
+  recent: z38.array(ScheduleRun)
 });
-var ScheduleCreateResult = z37.strictObject({ task: ScheduledTask });
-var ScheduleListParams = z37.strictObject({ include_finished: z37.boolean().default(false) });
-var ScheduleListResult = z37.strictObject({ tasks: z37.array(ScheduledTask) });
-var ScheduleCancelParams = z37.strictObject({ id: z37.string().min(1).max(64) });
-var ScheduleCancelResult = z37.strictObject({ task: ScheduledTask });
+var ScheduleCreateResult = z38.strictObject({ task: ScheduledTask });
+var ScheduleListParams = z38.strictObject({ include_finished: z38.boolean().default(false) });
+var ScheduleListResult = z38.strictObject({ tasks: z38.array(ScheduledTask) });
+var ScheduleCancelParams = z38.strictObject({ id: z38.string().min(1).max(64) });
+var ScheduleCancelResult = z38.strictObject({ task: ScheduledTask });
 
 // src/schema/notes.ts
-import { z as z38 } from "zod";
-var NoteFolder = z38.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
-var NotePath = z38.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
-var NotesFoldersParams = z38.strictObject({});
-var NotesFolder = z38.strictObject({ folder: z38.string(), notes: nonNegInt });
-var NotesFoldersResult = z38.strictObject({
+import { z as z39 } from "zod";
+var NoteFolder = z39.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
+var NotePath = z39.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
+var NotesFoldersParams = z39.strictObject({});
+var NotesFolder = z39.strictObject({ folder: z39.string(), notes: nonNegInt });
+var NotesFoldersResult = z39.strictObject({
   /** The notes root on this computer. */
-  root: z38.string(),
-  folders: z38.array(NotesFolder)
+  root: z39.string(),
+  folders: z39.array(NotesFolder)
 });
-var NotesListParams = z38.strictObject({
+var NotesListParams = z39.strictObject({
   folder: NoteFolder.optional(),
-  limit: z38.int().min(1).max(2e3).default(500)
+  limit: z39.int().min(1).max(2e3).default(500)
 });
-var NoteEntry = z38.strictObject({
-  path: z38.string(),
-  label: z38.string(),
-  folder: z38.string(),
+var NoteEntry = z39.strictObject({
+  path: z39.string(),
+  label: z39.string(),
+  folder: z39.string(),
   bytes: nonNegInt,
   modified_at_ms: epochMs
 });
-var NotesListResult = z38.strictObject({ root: z38.string(), notes: z38.array(NoteEntry), total: nonNegInt });
-var NotesReadParams = z38.strictObject({ path: NotePath });
-var NotesReadResult = z38.strictObject({
-  path: z38.string(),
-  content: z38.string(),
+var NotesListResult = z39.strictObject({ root: z39.string(), notes: z39.array(NoteEntry), total: nonNegInt });
+var NotesReadParams = z39.strictObject({ path: NotePath });
+var NotesReadResult = z39.strictObject({
+  path: z39.string(),
+  content: z39.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: z38.string()
+  hash: z39.string()
 });
-var NotesWriteParams = z38.strictObject({
+var NotesWriteParams = z39.strictObject({
   folder: NoteFolder.default("General"),
   /** The note's name, without ".md". */
-  label: z38.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
-  content: z38.string().max(10485760),
+  label: z39.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
+  content: z39.string().max(10485760),
   /** Write only when the note is still this version (notes.read's hash); a change since answers CONFLICT. */
-  if_hash: z38.string().length(64).optional()
+  if_hash: z39.string().length(64).optional()
 });
-var NotesWriteResult = z38.strictObject({ path: z38.string(), bytes: nonNegInt, created: z38.boolean(), hash: z38.string() });
-var NotesSearchParams = z38.strictObject({
-  query: z38.string().min(1).max(512),
-  limit: z38.int().min(1).max(200).default(50)
+var NotesWriteResult = z39.strictObject({ path: z39.string(), bytes: nonNegInt, created: z39.boolean(), hash: z39.string() });
+var NotesSearchParams = z39.strictObject({
+  query: z39.string().min(1).max(512),
+  limit: z39.int().min(1).max(200).default(50)
 });
-var NotesMatch = z38.strictObject({
-  path: z38.string(),
-  label: z38.string(),
-  folder: z38.string(),
+var NotesMatch = z39.strictObject({
+  path: z39.string(),
+  label: z39.string(),
+  folder: z39.string(),
   /** The matching lines (at most five), trimmed. */
-  lines: z38.array(z38.string())
+  lines: z39.array(z39.string())
 });
-var NotesSearchResult = z38.strictObject({ matches: z38.array(NotesMatch), total: nonNegInt });
+var NotesSearchResult = z39.strictObject({ matches: z39.array(NotesMatch), total: nonNegInt });
 
 // src/schema/documents.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var DOCUMENTS_MAX_TEXT_CHARS = 1048576;
-var DocumentsPdfTextParams = z39.strictObject({
+var DocumentsPdfTextParams = z40.strictObject({
   path: AbsPath,
   /** 1-based, inclusive. */
-  first_page: z39.int().min(1).optional(),
-  last_page: z39.int().min(1).optional(),
-  max_chars: z39.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
+  first_page: z40.int().min(1).optional(),
+  last_page: z40.int().min(1).optional(),
+  max_chars: z40.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
 });
-var DocumentsPdfPage = z39.strictObject({ page: z39.int().min(1), text: z39.string() });
-var DocumentsPdfTextResult = z39.strictObject({
+var DocumentsPdfPage = z40.strictObject({ page: z40.int().min(1), text: z40.string() });
+var DocumentsPdfTextResult = z40.strictObject({
   pages: nonNegInt,
   /** Each page read, in order (an image-only page has empty text: OCR it). */
-  read: z39.array(DocumentsPdfPage),
-  truncated: z39.boolean(),
-  title: z39.string().nullable(),
-  author: z39.string().nullable()
+  read: z40.array(DocumentsPdfPage),
+  truncated: z40.boolean(),
+  title: z40.string().nullable(),
+  author: z40.string().nullable()
 });
-var DocumentsOcrParams = z39.strictObject({
+var DocumentsOcrParams = z40.strictObject({
   path: AbsPath,
   /** BCP-47 language hints ("en-US", "fr-FR"); absent: the OS's own choice. */
-  languages: z39.array(z39.string().min(2).max(16)).max(8).optional(),
+  languages: z40.array(z40.string().min(2).max(16)).max(8).optional(),
   /** Faster, less accurate. */
-  fast: z39.boolean().default(false)
+  fast: z40.boolean().default(false)
 });
-var DocumentsOcrLine = z39.strictObject({
-  text: z39.string(),
+var DocumentsOcrLine = z40.strictObject({
+  text: z40.string(),
   /** 0–1; null where the engine does not say. */
-  confidence: z39.number().min(0).max(1).nullable()
+  confidence: z40.number().min(0).max(1).nullable()
 });
-var DocumentsOcrResult = z39.strictObject({
-  text: z39.string(),
-  lines: z39.array(DocumentsOcrLine),
-  truncated: z39.boolean(),
+var DocumentsOcrResult = z40.strictObject({
+  text: z40.string(),
+  lines: z40.array(DocumentsOcrLine),
+  truncated: z40.boolean(),
   /** Which engine read it ("vision" on macOS, "windows-ocr", "tesseract"). */
-  engine: z39.string()
+  engine: z40.string()
 });
-var DocumentsImageResizeParams = z39.strictObject({
+var DocumentsImageResizeParams = z40.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: z39.int().min(1).max(32768).optional(),
-  format: z39.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
-  overwrite: z39.boolean().default(false)
+  max_size: z40.int().min(1).max(32768).optional(),
+  format: z40.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
+  overwrite: z40.boolean().default(false)
 });
-var DocumentsImageResizeResult = z39.strictObject({
-  path: z39.string(),
+var DocumentsImageResizeResult = z40.strictObject({
+  path: z40.string(),
   width: nonNegInt,
   height: nonNegInt,
   bytes: nonNegInt
 });
-var DocumentsParagraph = z39.strictObject({
-  style: z39.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
-  text: z39.string().max(1e5)
+var DocumentsParagraph = z40.strictObject({
+  style: z40.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
+  text: z40.string().max(1e5)
 });
-var DocumentsSheet = z39.strictObject({
-  name: z39.string().min(1).max(31),
+var DocumentsSheet = z40.strictObject({
+  name: z40.string().min(1).max(31),
   /** Rows of cells; the first row is the header when `header` is true. */
-  rows: z39.array(z39.array(z39.union([z39.string().max(32767), z39.number(), z39.boolean(), z39.null()])).max(16384)).max(1e5),
-  header: z39.boolean().default(true)
+  rows: z40.array(z40.array(z40.union([z40.string().max(32767), z40.number(), z40.boolean(), z40.null()])).max(16384)).max(1e5),
+  header: z40.boolean().default(true)
 });
-var DocumentsOfficeGenerateParams = z39.strictObject({
-  kind: z39.enum(["docx", "xlsx"]),
+var DocumentsOfficeGenerateParams = z40.strictObject({
+  kind: z40.enum(["docx", "xlsx"]),
   path: AbsPath,
-  title: z39.string().max(1024).optional(),
+  title: z40.string().max(1024).optional(),
   /** docx: the document's paragraphs, in order. */
-  paragraphs: z39.array(DocumentsParagraph).max(5e4).optional(),
+  paragraphs: z40.array(DocumentsParagraph).max(5e4).optional(),
   /** xlsx: the workbook's sheets, in order. */
-  sheets: z39.array(DocumentsSheet).min(1).max(64).optional(),
-  overwrite: z39.boolean().default(false)
+  sheets: z40.array(DocumentsSheet).min(1).max(64).optional(),
+  overwrite: z40.boolean().default(false)
 });
-var DocumentsOfficeGenerateResult = z39.strictObject({ path: z39.string(), bytes: nonNegInt });
-var EntitiesNerParams = z39.strictObject({
-  text: z39.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+var DocumentsOfficeGenerateResult = z40.strictObject({ path: z40.string(), bytes: nonNegInt });
+var EntitiesNerParams = z40.strictObject({
+  text: z40.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
   /** Which kinds to keep; absent: all three. */
-  labels: z39.array(z39.enum(["person", "place", "organization"])).min(1).max(3).optional()
+  labels: z40.array(z40.enum(["person", "place", "organization"])).min(1).max(3).optional()
 });
-var EntitySpan = z39.strictObject({
-  text: z39.string(),
-  label: z39.string(),
+var EntitySpan = z40.strictObject({
+  text: z40.string(),
+  label: z40.string(),
   /** Character offsets into the text (UTF-16, as JavaScript counts). */
   start: nonNegInt,
   end: nonNegInt
 });
-var EntitiesNerResult = z39.strictObject({ entities: z39.array(EntitySpan), engine: z39.string() });
-var PiiKind = z39.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
-var EntitiesPiiParams = z39.strictObject({
-  text: z39.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
-  kinds: z39.array(PiiKind).min(1).max(8).optional(),
+var EntitiesNerResult = z40.strictObject({ entities: z40.array(EntitySpan), engine: z40.string() });
+var PiiKind = z40.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
+var EntitiesPiiParams = z40.strictObject({
+  text: z40.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+  kinds: z40.array(PiiKind).min(1).max(8).optional(),
   /** Also answer the text with each finding replaced by its kind ("[email]"). */
-  redact: z39.boolean().default(false)
+  redact: z40.boolean().default(false)
 });
-var EntitiesPiiResult = z39.strictObject({
-  findings: z39.array(z39.strictObject({ kind: PiiKind, text: z39.string(), start: nonNegInt, end: nonNegInt })),
-  redacted: z39.string().nullable()
+var EntitiesPiiResult = z40.strictObject({
+  findings: z40.array(z40.strictObject({ kind: PiiKind, text: z40.string(), start: nonNegInt, end: nonNegInt })),
+  redacted: z40.string().nullable()
 });
 
 // src/schema/registry.ts
@@ -3523,6 +4198,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"] },
@@ -3539,10 +4244,24 @@ var OPS = {
   "web.scrape": { params: WebScrapeParams, result: WebScrapeResult, kind: "unary", since: "1.22", errors: ["INVALID_PARAMS", "TIMEOUT", "RESOURCE_BUSY", "AUTH_REQUIRED", "INTERNAL"] },
   "web.search": { params: WebSearchParams, result: WebSearchResult, kind: "unary", since: "1.22", errors: ["INVALID_PARAMS", "TIMEOUT", "RESOURCE_BUSY", "AUTH_REQUIRED", "INTERNAL"] },
   "web.fetch_with_browser": { params: WebBrowserFetchParams, result: WebBrowserFetchResult, kind: "unary", since: "1.22", errors: ["INVALID_PARAMS", "TIMEOUT", "RESOURCE_BUSY", "AUTH_REQUIRED", "INTERNAL"] },
+  "web.runtime.state": { params: WebRuntimeParams, result: WebRuntimeState, kind: "unary", since: "1.40", errors: ["INTERNAL"] },
+  "web.runtime.install": { params: WebRuntimeParams, result: WebRuntimeState, kind: "unary", since: "1.40", errors: ["TIMEOUT", "RESOURCE_BUSY", "CANCELLED", "INTERNAL"] },
+  "web.runtime.remove": { params: WebRuntimeParams, result: WebRuntimeState, kind: "unary", since: "1.40", errors: ["RESOURCE_BUSY", "INTERNAL"] },
+  "web.outbox.list": { params: WebOutboxListParams, result: WebOutboxListResult, kind: "unary", since: "1.40", errors: ["INTERNAL"] },
+  "web.outbox.retry": { params: WebOutboxRetryParams, result: WebOutboxRetryResult, kind: "unary", since: "1.40", errors: ["NOT_FOUND", "AUTH_REQUIRED", "INTERNAL"] },
+  "web.outbox.discard": { params: WebOutboxDiscardParams, result: WebOutboxDiscardResult, kind: "unary", since: "1.40", errors: ["NOT_FOUND", "INTERNAL"] },
+  "web.log.list": { params: WebLogListParams, result: WebLogListResult, kind: "unary", since: "1.40", errors: ["INVALID_PARAMS"] },
+  "web.log.clear": { params: WebLogClearParams, result: WebLogClearResult, kind: "unary", since: "1.40", errors: ["INTERNAL"] },
+  "web.research.queue": { params: WebResearchQueueParams, result: WebResearchQueueResult, kind: "unary", since: "1.40", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "web.research.fetch": { params: WebResearchFetchParams, result: WebResearchFetchResult, kind: "unary", since: "1.40", errors: ["INVALID_PARAMS", "AUTH_REQUIRED", "RESOURCE_BUSY", "CANCELLED", "INTERNAL"] },
   // 1.23: the signed-in person's own agents and Vault, read as them (the desktop's Agents library and Vault).
   "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"] },
@@ -3616,12 +4335,18 @@ 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,
   "browser.invoke": BrowserInvokeEvent,
   "browser.sessions_changed": BrowserSessionsChangedEvent,
-  "browser.progress": BrowserProgressEvent
+  "browser.progress": BrowserProgressEvent,
+  "web.log.entry": WebLogEntry,
+  "web.progress": WebProgressEvent
 };
 var SERVICES = {
   ml: {
@@ -3647,9 +4372,12 @@ var SERVICES = {
     progress: ToolsServiceProgress,
     ops: {
       "tools.web_fetch": { params: WebFetchParams, result: WebFetchResult },
-      "tools.web_scrape": { params: WebScrapeParams, result: WebScrapeResult },
+      "tools.web_scrape": { params: ToolsWebScrapeParams, result: ToolsWebScrapeResult },
       "tools.web_search": { params: ToolsWebSearchParams, result: WebSearchResult },
-      "tools.web_browser_fetch": { params: WebBrowserFetchParams, result: WebBrowserFetchResult }
+      "tools.web_browser_fetch": { params: ToolsWebBrowserFetchParams, result: ToolsWebBrowserFetchResult },
+      "tools.web_runtime_state": { params: WebRuntimeParams, result: WebRuntimeState },
+      "tools.web_runtime_install": { params: WebRuntimeParams, result: WebRuntimeState },
+      "tools.web_runtime_remove": { params: WebRuntimeParams, result: WebRuntimeState }
     }
   }
 };
@@ -3682,7 +4410,9 @@ var NAMED_SCHEMAS = {
   RelayMsg,
   ClientToCoreMsg,
   CoreToClientMsg,
+  OsGrantState,
   OsPermissionName,
+  OsRequirementName,
   SysinfoGetParams,
   SysinfoGetResult,
   SysinfoHardwareParams,
@@ -3790,6 +4520,91 @@ var NAMED_SCHEMAS = {
   CodingHistoryImportMissingParams,
   CodingHistoryImportMissingResult,
   CodingHistoryProgressEvent,
+  CodingProviderName,
+  CodingRunStatus,
+  CodingClientRequestId,
+  CodingRunUsage,
+  CodingStartedBy,
+  CodingRunRecord,
+  CodingSessionAgentPart,
+  CodingSessionAgent,
+  CodingSessionRecord,
+  CodingActiveElsewhere,
+  CodingDiscoveredChat,
+  CodingTranscriptItem,
+  CodingHistoryRecord,
+  CodingQuotaWindow,
+  CodingProviderProblem,
+  CodingProviderBinary,
+  CodingProviderStatus,
+  CodingChatPreference,
+  CodingTitleStatus,
+  CodingRecentRow,
+  CodingFolderCheck,
+  CodingRecentFolder,
+  CodingAgentSelectionParams,
+  CodingSendResult,
+  CodingProvidersParams,
+  CodingProvidersResult,
+  CodingSessionsListParams,
+  CodingSessionsListResult,
+  CodingDiscoverParams,
+  CodingDiscoverResult,
+  CodingRunsListParams,
+  CodingRunsListResult,
+  CodingHistoryParams,
+  CodingHistoryResult,
+  CodingTranscriptReadParams,
+  CodingTranscriptReadResult,
+  CodingItemFullParams,
+  CodingItemFullResult,
+  CodingActivityParams,
+  CodingActivityResult,
+  CodingFoldersRecentParams,
+  CodingFoldersRecentResult,
+  CodingFoldersCheckParams,
+  CodingFoldersCheckResult,
+  CodingFoldersCreateParams,
+  CodingFoldersCreateResult,
+  CodingStartParams,
+  CodingStartResult,
+  CodingTakeoverParams,
+  CodingTakeoverResult,
+  CodingSendParams,
+  CodingStopParams,
+  CodingStopResult,
+  CodingStopElsewhereParams,
+  CodingStopElsewhereResult,
+  CodingOptionsSetParams,
+  CodingOptionsSetResult,
+  CodingAgentSetParams,
+  CodingAgentSetResult,
+  CodingAgentsAccessParams,
+  CodingAgentsAccessResult,
+  CodingTitlesStatusParams,
+  CodingTitlesStatusResult,
+  CodingPrefsListParams,
+  CodingPrefsListResult,
+  CodingPrefsSetParams,
+  CodingPrefsSetResult,
+  CodingRecentSeenParams,
+  CodingRecentSeenResult,
+  CodingSearchParams,
+  CodingSearchResult,
+  CodingReconcileParams,
+  CodingReconcileResult,
+  CodingTranscriptRawParams,
+  CodingTranscriptRawResult,
+  CodingWatchParams,
+  CodingWatchResult,
+  CodingSessionWatchParams,
+  CodingSessionWatchResult,
+  SessionIdentifyParams,
+  SessionIdentifyResult,
+  CodingChangedEvent,
+  CodingWatchStateEvent,
+  CodingItemEvent,
+  CodingGapEvent,
   ServiceName,
   ContractHash,
   ServiceToken,
@@ -4086,6 +4901,42 @@ var NAMED_SCHEMAS = {
   ToolsWebSearchParams,
   WebBrowserFetchParams,
   WebBrowserFetchResult,
+  WebAttachTarget,
+  WebLand,
+  WebNotSavedReason,
+  WebSourceNotice,
+  WebSourceState,
+  ToolsParseFile,
+  ToolsWebScrapeParams,
+  ToolsWebScrapePage,
+  ToolsWebScrapeResult,
+  ToolsWebBrowserFetchParams,
+  ToolsWebBrowserFetchResult,
+  WebRuntimeStateName,
+  WebRuntimeParams,
+  WebRuntimeState,
+  WebOutboxItem,
+  WebOutboxListParams,
+  WebOutboxListResult,
+  WebOutboxRetryParams,
+  WebOutboxRetryResult,
+  WebOutboxDiscardParams,
+  WebOutboxDiscardResult,
+  WebLogVia,
+  WebLogCaller,
+  WebLogResult,
+  WebLogEntry,
+  WebLogListParams,
+  WebLogListResult,
+  WebLogClearParams,
+  WebLogClearResult,
+  WebProgressEvent,
+  WebResearchItemState,
+  WebResearchItem,
+  WebResearchQueueParams,
+  WebResearchQueueResult,
+  WebResearchFetchParams,
+  WebResearchFetchResult,
   ToolsServiceProgress,
   AccountRowId,
   AccountReadState,
@@ -4099,6 +4950,17 @@ var NAMED_SCHEMAS = {
   AccountVaultListResult,
   AccountVaultCopyParams,
   AccountVaultCopyResult,
+  AccountAgentVariable,
+  AccountAgentDetail,
+  AccountAgentsGetParams,
+  AccountAgentsGetResult,
+  AccountAgentRunStatus,
+  AccountAgentRun,
+  AccountAgentRunSort,
+  AccountAgentsRunsParams,
+  AccountAgentsRunsResult,
+  AccountAgentsFavoriteParams,
+  AccountAgentsFavoriteResult,
   AppsWindowsUpdateStateParams,
   AppsWindowsUpdateStateResult,
   AppsWindowsReopenParams,
@@ -4283,7 +5145,14 @@ var FIELDS_SINCE = {
   AppsWindowsUpdateStateResult: { closed_by_update: "1.27" },
   AppsProjectsToWindowParams: { pin: "1.32", chat_ids: "1.36", take_off_from: "1.36" },
   AppsProjectsToWindowResult: { pin: "1.32" },
-  AppsChatsTitlesCheckResult: { stale_windows: "1.33" }
+  AppsChatsTitlesCheckResult: { stale_windows: "1.33" },
+  AccountAgent: { tags: "1.39", model_id: "1.39", access_level: "1.39", organization_id: "1.39", origin: "1.39", is_archived: "1.39", orchestra: "1.39" },
+  WebScrapeParams: { engine: "1.40", land: "1.40" },
+  WebScrapePage: { source: "1.40" },
+  WebBrowserFetchParams: { land: "1.40" },
+  WebBrowserFetchResult: { source: "1.40" },
+  SysinfoGetResult: { requirements: "1.41" },
+  "SysinfoGetResult.permissions[]": { detail: "1.41" }
 };
 var NULL_SINCE = {
   "RelayDeviceStatusEvent.since_ms": { since: "1.1", olderPeersGet: 0 }
@@ -4303,6 +5172,25 @@ var REASONS_SINCE = {
   awaiting_confirmation: "1.28",
   tool_disabled_on_device: "1.34"
 };
+var PERMISSIONS_SINCE = {
+  reminders: "1.41",
+  speech_recognition: "1.41",
+  messages: "1.41",
+  mail: "1.41",
+  wifi: "1.41"
+};
+function permissionsForPeer(value, version) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  const body = value;
+  if (!Array.isArray(body.permissions)) return value;
+  const since = PERMISSIONS_SINCE;
+  const kept = body.permissions.filter((p) => {
+    const name = p?.name;
+    const added = typeof name === "string" ? since[name] : void 0;
+    return !added || knows(version, added);
+  });
+  return kept.length === body.permissions.length ? value : { ...body, permissions: kept };
+}
 function statusForPeer(status, version) {
   const rule = NULL_SINCE["RelayDeviceStatusEvent.since_ms"];
   return status.since_ms === null && !knows(version, rule.since) ? { ...status, since_ms: rule.olderPeersGet } : status;
@@ -4347,7 +5235,9 @@ var RESULT_PATH = /* @__PURE__ */ new Map([
   ["apps.chats.list", "AppsChatsListResult"],
   ["apps.accounts.usage", "AppsAccountsUsageResult"],
   ["apps.accounts.resets", "AppsAccountsResetsResult"],
-  ["apps.windows.update_state", "AppsWindowsUpdateStateResult"]
+  ["apps.windows.update_state", "AppsWindowsUpdateStateResult"],
+  ["web.fetch_with_browser", "WebBrowserFetchResult"],
+  ["sysinfo.get", "SysinfoGetResult"]
 ]);
 var NESTED_RESULTS = /* @__PURE__ */ new Map([
   ["apps.chats.list", [["chats", "ChatRow"]]],
@@ -4359,7 +5249,10 @@ var NESTED_RESULTS = /* @__PURE__ */ new Map([
   ["apps.chats.place", [["chat", "ChatRow"]]],
   ["apps.accounts.usage", [["accounts", "AccountUsage"]]],
   ["resources.snapshot", [["disks", "ResourcesDisk"]]],
-  ["stack.state", [["servers", "StackServer"]]]
+  ["stack.state", [["servers", "StackServer"]]],
+  ["account.agents.list", [["agents", "AccountAgent"]]],
+  ["web.scrape", [["pages", "WebScrapePage"]]],
+  ["sysinfo.get", [["permissions", "SysinfoGetResult.permissions[]"]]]
 ]);
 function stripNested(value, nested, version) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
@@ -4401,7 +5294,8 @@ function forPeer(op, part, value, version) {
     const windowKey = op ? WINDOW_RESULTS.get(op) : void 0;
     if (windowKey) return stripWindows(value, windowKey, version);
     const path = op ? RESULT_PATH.get(op) : void 0;
-    const top = path ? strip(value, FIELDS_SINCE[path], version) : value;
+    const known = op === "sysinfo.get" ? permissionsForPeer(value, version) : value;
+    const top = path ? strip(known, FIELDS_SINCE[path], version) : known;
     const nested = op ? NESTED_RESULTS.get(op) : void 0;
     return nested ? stripNested(top, nested, version) : top;
   }
@@ -4420,7 +5314,7 @@ function forPeer(op, part, value, version) {
 var VERSIONED_RESULT_OPS = [.../* @__PURE__ */ new Set([...RESULT_PATH.keys(), ...WINDOW_RESULTS.keys(), ...NESTED_RESULTS.keys()])];
 
 // src/contract.ts
-var CONTRACT_SHA256 = "1091ef68a5cb45a35a85998fc34560b4ddc035fe67d2d34594e935e92a2081dd";
+var CONTRACT_SHA256 = "a2ea77f45ed3f5421e4c722442205e48fce2bbc5bccc892b54403304eca55443";
 
 // src/close-policy.ts
 var CLOSE_RULES = {
@@ -4494,6 +5388,10 @@ var TOOL_CATALOG = [
   { name: "desktop_location", group: "personal_automation", state: "built", path: "device_op", ops: ["location.get"], platforms: ["darwin", "win32"], summary: "Where the computer is (the OS's location service)" },
   { name: "desktop_net", group: "personal_automation", state: "built", path: "device_op", ops: ["net.info", "net.wifi", "net.bluetooth", "net.devices", "net.mdns", "net.scan", "net.download"], platforms: ALL, summary: "Local network, Wi-Fi, Bluetooth, open ports and downloads" },
   { name: "desktop_schedule", group: "personal_automation", state: "built", path: "device_op", ops: ["schedule.create", "schedule.list", "schedule.cancel"], platforms: ALL, summary: "Run a tool's op on this computer on an interval; list and cancel" },
+  // 1.38, code from anywhere: the person's Claude Code and Codex sessions on this computer. Turning
+  // either off in Agents › Tools refuses its ops on every relay connection (the existing switch).
+  { name: "coding_sessions_read", group: "personal_automation", state: "built", path: "device_op", ops: ["coding.providers", "coding.sessions.list", "coding.discover", "coding.runs.list", "coding.history", "coding.transcript.read", "coding.item.full", "coding.activity", "coding.folders.recent", "coding.folders.check", "coding.agents.access", "coding.titles.status", "coding.prefs.list", "coding.recent.seen", "coding.search", "coding.transcript.raw", "coding.watch", "coding.session.watch"], platforms: ALL, summary: "Claude Code and Codex sessions: list, read live, search, download" },
+  { name: "coding_sessions_drive", group: "personal_automation", state: "built", path: "device_op", ops: ["coding.start", "coding.takeover", "coding.send", "coding.stop", "coding.stop_elsewhere", "coding.options.set", "coding.agent.set", "coding.folders.create", "coding.prefs.set", "coding.reconcile"], platforms: ALL, summary: "Claude Code and Codex sessions: start, send, stop, take over, rename" },
   // ── 4. Documents, notes and entities (1.37: the core's `documents` and `notes` owners; desktop_web is the `tools` service) ──
   { name: "desktop_documents", group: "tools_service", state: "built", path: "device_op", ops: ["documents.pdf_text", "documents.ocr", "documents.image_resize", "documents.office_generate"], platforms: ALL, summary: "PDF text, OCR, images, Word and Excel files" },
   { name: "desktop_web", group: "tools_service", state: "built", path: "device_op", ops: ["web.fetch", "web.scrape", "web.search", "web.fetch_with_browser"], platforms: ALL, summary: "Fetch, scrape and search the web from this computer's own connection" },
@@ -4794,8 +5692,19 @@ function sharedOpsBlocking(tool2, disabledTools) {
 export {
   AbsPath,
   AccountAgent,
+  AccountAgentDetail,
+  AccountAgentRun,
+  AccountAgentRunSort,
+  AccountAgentRunStatus,
+  AccountAgentVariable,
+  AccountAgentsFavoriteParams,
+  AccountAgentsFavoriteResult,
+  AccountAgentsGetParams,
+  AccountAgentsGetResult,
   AccountAgentsListParams,
   AccountAgentsListResult,
+  AccountAgentsRunsParams,
+  AccountAgentsRunsResult,
   AccountReadState,
   AccountReset,
   AccountRowId,
@@ -4964,17 +5873,100 @@ export {
   ClipboardWriteResult,
   CloseCode,
   CloseCodeValue,
+  CodingActiveElsewhere,
+  CodingActivityParams,
+  CodingActivityResult,
+  CodingAgentSelectionParams,
+  CodingAgentSetParams,
+  CodingAgentSetResult,
+  CodingAgentsAccessParams,
+  CodingAgentsAccessResult,
+  CodingChangedEvent,
+  CodingChatPreference,
+  CodingClientRequestId,
+  CodingDiscoverParams,
+  CodingDiscoverResult,
+  CodingDiscoveredChat,
+  CodingFolderCheck,
+  CodingFoldersCheckParams,
+  CodingFoldersCheckResult,
+  CodingFoldersCreateParams,
+  CodingFoldersCreateResult,
+  CodingFoldersRecentParams,
+  CodingFoldersRecentResult,
+  CodingGapEvent,
   CodingHistoryBlocked,
   CodingHistoryFailure,
   CodingHistoryImportMissingParams,
   CodingHistoryImportMissingResult,
+  CodingHistoryParams,
   CodingHistoryProgressEvent,
+  CodingHistoryRecord,
+  CodingHistoryResult,
   CodingHistoryRun,
   CodingHistoryStep,
   CodingImportNextParams,
+  CodingItemEvent,
+  CodingItemFullParams,
+  CodingItemFullResult,
+  CodingOptionsSetParams,
+  CodingOptionsSetResult,
   CodingPlanMissingParams,
+  CodingPrefsListParams,
+  CodingPrefsListResult,
+  CodingPrefsSetParams,
+  CodingPrefsSetResult,
+  CodingProviderBinary,
+  CodingProviderName,
+  CodingProviderProblem,
+  CodingProviderStatus,
+  CodingProvidersParams,
+  CodingProvidersResult,
+  CodingQuotaWindow,
+  CodingRecentFolder,
+  CodingRecentRow,
+  CodingRecentSeenParams,
+  CodingRecentSeenResult,
+  CodingReconcileParams,
+  CodingReconcileResult,
+  CodingRunRecord,
+  CodingRunStatus,
+  CodingRunUsage,
+  CodingRunsListParams,
+  CodingRunsListResult,
+  CodingSearchParams,
+  CodingSearchResult,
+  CodingSendParams,
+  CodingSendResult,
   CodingServiceCredentials,
   CodingServiceProgress,
+  CodingSessionAgent,
+  CodingSessionAgentPart,
+  CodingSessionRecord,
+  CodingSessionWatchParams,
+  CodingSessionWatchResult,
+  CodingSessionsListParams,
+  CodingSessionsListResult,
+  CodingStartParams,
+  CodingStartResult,
+  CodingStartedBy,
+  CodingStopElsewhereParams,
+  CodingStopElsewhereResult,
+  CodingStopParams,
+  CodingStopResult,
+  CodingTakeoverParams,
+  CodingTakeoverResult,
+  CodingTitleStatus,
+  CodingTitlesStatusParams,
+  CodingTitlesStatusResult,
+  CodingTranscriptItem,
+  CodingTranscriptRawParams,
+  CodingTranscriptRawResult,
+  CodingTranscriptReadParams,
+  CodingTranscriptReadResult,
+  CodingWatchParams,
+  CodingWatchResult,
+  CodingWatchStateEvent,
   ColdChat,
   ContactDetail,
   ContactLabeled,
@@ -5224,7 +6216,10 @@ export {
   NotesWriteResult,
   OPS,
   OpDescriptor,
+  OsGrantState,
   OsPermissionName,
+  OsRequirementName,
+  PERMISSIONS_SINCE,
   PING_TEXT,
   PONG_TEXT,
   PROTOCOL_MAJOR,
@@ -5337,6 +6332,8 @@ export {
   SessionControlChangedEvent,
   SessionDetachParams,
   SessionDetachResult,
+  SessionIdentifyParams,
+  SessionIdentifyResult,
   SessionListParams,
   SessionListResult,
   SessionReleaseParams,
@@ -5400,7 +6397,13 @@ export {
   ToolPlatform,
   ToolResultsFile,
   ToolTransport,
+  ToolsParseFile,
   ToolsServiceProgress,
+  ToolsWebBrowserFetchParams,
+  ToolsWebBrowserFetchResult,
+  ToolsWebScrapePage,
+  ToolsWebScrapeParams,
+  ToolsWebScrapeResult,
   ToolsWebSearchParams,
   TranscriptSegment,
   TranscriptionModelId,
@@ -5410,11 +6413,39 @@ export {
   VaultItemKind,
   VaultItemSummary,
   WEB_MAX_TEXT_CHARS,
+  WebAttachTarget,
   WebBrowserFetchParams,
   WebBrowserFetchResult,
   WebFetchParams,
   WebFetchResult,
   WebHeader,
+  WebLand,
+  WebLogCaller,
+  WebLogClearParams,
+  WebLogClearResult,
+  WebLogEntry,
+  WebLogListParams,
+  WebLogListResult,
+  WebLogResult,
+  WebLogVia,
+  WebNotSavedReason,
+  WebOutboxDiscardParams,
+  WebOutboxDiscardResult,
+  WebOutboxItem,
+  WebOutboxListParams,
+  WebOutboxListResult,
+  WebOutboxRetryParams,
+  WebOutboxRetryResult,
+  WebProgressEvent,
+  WebResearchFetchParams,
+  WebResearchFetchResult,
+  WebResearchItem,
+  WebResearchItemState,
+  WebResearchQueueParams,
+  WebResearchQueueResult,
+  WebRuntimeParams,
+  WebRuntimeState,
+  WebRuntimeStateName,
   WebScrapePage,
   WebScrapeParams,
   WebScrapeResult,
@@ -5422,6 +6453,8 @@ export {
   WebSearchParams,
   WebSearchQueryResult,
   WebSearchResult,
+  WebSourceNotice,
+  WebSourceState,
   Welcome,
   WindowFocusParams,
   WindowFocusResult,