@ai-matrx/desktop-protocol 0.21.27 → 0.21.29

package/dist/client.js

@@ -112,7 +112,7 @@ import { z as z2 } from "zod";
 import { z } from "zod";
 import { UUID_SHAPE_PATTERN } from "@ai-matrx/kit/uuid";
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 32;
+var PROTOCOL_MINOR = 37;
 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_-]+$/);
@@ -195,8 +195,11 @@ var ErrorReason = z2.enum([
   // AUTH_FORBIDDEN: the named browser is signed in to another account
   "browser_connection_off",
   // AUTH_FORBIDDEN: the person turned Browser connection off
-  "awaiting_confirmation"
+  "awaiting_confirmation",
   // TIMEOUT: the person did not answer the browser's confirmation in time
+  // 1.34 (REASONS_SINCE): the per-device tool policy (src/tools/policy.ts)
+  "tool_disabled_on_device"
+  // AUTH_FORBIDDEN: the person turned this tool off for agents on this computer (Agents › Tools)
 ]);
 var FsPatchEditFailure = z2.strictObject({ edit_index: nonNegInt, reason: z2.string().max(300) });
 var ProtocolErrorBody = z2.strictObject({
@@ -1207,7 +1210,9 @@ var SystemSettingsPane = z16.enum([
   "energy",
   "about",
   "storage",
-  "system_report"
+  "system_report",
+  /** (1.35) Privacy & Security › Microphone: where the person allows Matrx 2 the microphone. */
+  "microphone"
 ]);
 var SystemOpenSettingsParams = z16.strictObject({ pane: SystemSettingsPane });
 var SystemOpenSettingsResult = z16.strictObject({ pane: SystemSettingsPane });
@@ -2400,6 +2405,10 @@ var AppsProjectsToWindowParams = z30.strictObject({
   group: z30.boolean().default(false),
   /** 1.32: also pin them in that window (now if closed, else when it next closes). */
   pin: z30.boolean().optional(),
+  /** 1.36: a batch: exactly these chats of the project and no other (a reused marker is a label, never a sweep). */
+  chat_ids: z30.array(ChatId).min(1).max(5e3).optional(),
+  /** 1.36: take them off this one side window only (a Move's origin), never main or another window that lists them. */
+  take_off_from: ChatPlace.optional(),
   dry_run: z30.boolean().default(false)
 });
 var AppsProjectsToWindowResult = z30.strictObject({
@@ -2466,6 +2475,12 @@ var TitleMismatch = z30.strictObject({
   windows: z30.array(ChatPlace).max(200),
   differs_in: z30.array(TitleCopies).max(200)
 });
+var StaleTitleWindow = z30.strictObject({
+  window: ChatPlace,
+  /** First and latest time (ms) it was seen writing an old name back. */
+  since_ms: nonNegInt,
+  last_ms: nonNegInt
+});
 var AppsChatsTitlesCheckParams = z30.strictObject({ app_key: AppKey });
 var AppsChatsTitlesCheckResult = z30.strictObject({
   app_key: AppKey,
@@ -2474,7 +2489,9 @@ var AppsChatsTitlesCheckResult = z30.strictObject({
   /** Chats with a different name in some window (or in Matrx). */
   chats_with_a_different_name: nonNegInt,
   copies_to_write: nonNegInt,
-  chats: z30.array(TitleMismatch).max(5e3)
+  chats: z30.array(TitleMismatch).max(5e3),
+  /** Windows that keep writing old names back (each is fixed every pass; reloading it, Cmd+R, stops it). Since 1.33. */
+  stale_windows: z30.array(StaleTitleWindow).max(200).optional()
 });
 var AppsChatsTitlesPushParams = z30.strictObject({ app_key: AppKey, chat_id: ChatId.optional(), dry_run: z30.boolean().optional() });
 var AppsChatsTitlesPushResult = z30.strictObject({
@@ -2666,6 +2683,41 @@ var BrowserCallResult = z31.strictObject({
   result: z31.unknown(),
   duration_ms: nonNegInt
 });
+var BrowserToolMetricsParams = z31.strictObject({ client_instance: BrowserClientInstance });
+var BrowserToolMetric = z31.strictObject({
+  tool: z31.string().max(256),
+  calls: nonNegInt,
+  errors: nonNegInt,
+  /** Over the last 200 answered calls; null before the first answer. */
+  p50_ms: nonNegInt.nullable(),
+  p95_ms: nonNegInt.nullable(),
+  last_call_at_ms: epochMs.nullable(),
+  last_error: z31.string().max(2048).nullable()
+});
+var BrowserToolMetricsResult = z31.strictObject({ client_instance: z31.string(), tools: z31.array(BrowserToolMetric) });
+var BrowserResetCountersParams = z31.strictObject({ client_instance: BrowserClientInstance });
+var BrowserResetCountersResult = z31.strictObject({ reset: z31.boolean() });
+var BrowserLogParams = z31.strictObject({
+  /** Only messages after this seq (0: from the oldest kept; the core keeps the last 500). */
+  after_seq: nonNegInt.default(0),
+  limit: z31.int().min(1).max(500).default(500)
+});
+var BrowserLogMessage = z31.strictObject({
+  seq: nonNegInt,
+  at_ms: epochMs,
+  direction: z31.enum(["to_browser", "from_browser", "core"]),
+  client_instance: z31.string(),
+  kind: z31.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
+  tool: z31.string().nullable(),
+  call_id: z31.string().nullable(),
+  ok: z31.boolean().nullable(),
+  detail: z31.string().max(1024)
+});
+var BrowserLogResult = z31.strictObject({
+  messages: z31.array(BrowserLogMessage),
+  /** The newest seq the core has written (pass it back as after_seq to follow the log). */
+  last_seq: nonNegInt
+});
 var BrowserInvokeEvent = z31.strictObject({
   call_id: z31.string().min(1).max(64),
   tool: z31.string().min(1).max(96),
@@ -2690,6 +2742,575 @@ var DesktopHealth = z31.strictObject({
 var BrowserPairRequest = z31.strictObject({ client_instance: BrowserClientInstance });
 var BrowserPairResult = z31.strictObject({ pair_token: z31.string().min(16).max(128), ws_path: z31.literal("/v1/connect") });
 
+// src/schema/net.ts
+import { z as z32 } from "zod";
+var NetInfoParams = z32.strictObject({});
+var NetAddress = z32.strictObject({
+  address: z32.string(),
+  family: z32.enum(["ipv4", "ipv6"]),
+  netmask: z32.string().nullable(),
+  /** CIDR form ("192.168.1.20/24"); null where the OS gives no prefix. */
+  cidr: z32.string().nullable()
+});
+var NetInterface = z32.strictObject({
+  name: z32.string(),
+  mac: z32.string().nullable(),
+  /** Loopback and other internal interfaces. */
+  internal: z32.boolean(),
+  addresses: z32.array(NetAddress)
+});
+var NetInfoResult = z32.strictObject({
+  hostname: z32.string(),
+  interfaces: z32.array(NetInterface),
+  /** The default route's gateway; null when the OS does not say (or there is none). */
+  gateway: z32.string().nullable(),
+  /** The DNS servers the OS uses; empty when it does not say. */
+  dns: z32.array(z32.string())
+});
+var NetWifiParams = z32.strictObject({});
+var NetWifiNetwork = z32.strictObject({
+  /** null: the OS hides the name (macOS without Location Services for this app). */
+  ssid: z32.string().nullable(),
+  /** dBm; null where the OS does not say. */
+  rssi: z32.int().nullable(),
+  channel: z32.string().nullable(),
+  security: z32.string().nullable()
+});
+var NetWifiResult = z32.strictObject({
+  /** Whether the computer has a Wi-Fi interface at all. */
+  available: z32.boolean(),
+  /** The network the computer is on; null when it is on none. */
+  current: NetWifiNetwork.nullable(),
+  /** Networks in range (may be empty where the OS lists none to apps). */
+  networks: z32.array(NetWifiNetwork)
+});
+var NetBluetoothParams = z32.strictObject({});
+var NetBluetoothDevice = z32.strictObject({
+  name: z32.string(),
+  address: z32.string().nullable(),
+  connected: z32.boolean(),
+  /** What it is, in the OS's words ("Headphones", "Keyboard"); null where it does not say. */
+  kind: z32.string().nullable(),
+  /** Battery percent, where the OS reports it. */
+  battery: z32.int().min(0).max(100).nullable()
+});
+var NetBluetoothResult = z32.strictObject({
+  /** Bluetooth is on; null where the OS does not say. */
+  powered: z32.boolean().nullable(),
+  devices: z32.array(NetBluetoothDevice)
+});
+var NetDevicesParams = z32.strictObject({});
+var NetDevice = z32.strictObject({
+  ip: z32.string(),
+  mac: z32.string().nullable(),
+  interface: z32.string().nullable(),
+  /** The name the local network gives it (reverse DNS / mDNS), when the table carries one. */
+  hostname: z32.string().nullable()
+});
+var NetDevicesResult = z32.strictObject({ devices: z32.array(NetDevice) });
+var NetMdnsParams = z32.strictObject({
+  /** A service type ("_http._tcp"); absent lists the service types found. */
+  service_type: z32.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
+  /** How long to listen. */
+  timeout_s: z32.int().min(1).max(30).default(3)
+});
+var NetMdnsService = z32.strictObject({
+  name: z32.string(),
+  type: z32.string(),
+  domain: z32.string(),
+  interface: z32.string().nullable()
+});
+var NetMdnsResult = z32.strictObject({ services: z32.array(NetMdnsService) });
+var NetScanParams = z32.strictObject({
+  /** A host name or address; a private or loopback address unless `allow_public`. */
+  host: z32.string().min(1).max(253),
+  ports: z32.array(z32.int().min(1).max(65535)).min(1).max(1024),
+  timeout_ms: z32.int().min(50).max(1e4).default(800),
+  /** Scanning a host on the public internet needs saying so. */
+  allow_public: z32.boolean().default(false)
+});
+var NetScanResult = z32.strictObject({
+  host: z32.string(),
+  /** The address the host resolved to. */
+  address: z32.string(),
+  open: z32.array(z32.int().min(1).max(65535)),
+  closed: nonNegInt,
+  elapsed_ms: nonNegInt
+});
+var NetDownloadParams = z32.strictObject({
+  url: z32.string().min(1).max(8192).regex(/^https?:\/\//),
+  /** Where to save it: an absolute path (a folder keeps the URL's file name). */
+  path: AbsPath,
+  overwrite: z32.boolean().default(false),
+  timeout_s: z32.int().min(1).max(3600).default(300),
+  /** Refuse anything larger. */
+  max_bytes: z32.int().min(1).max(10737418240).default(2147483648)
+});
+var NetDownloadResult = z32.strictObject({
+  path: z32.string(),
+  bytes: nonNegInt,
+  content_type: z32.string().nullable(),
+  /** The final URL after redirects. */
+  url: z32.string(),
+  elapsed_ms: nonNegInt
+});
+
+// src/schema/personal.ts
+import { z as z33 } from "zod";
+var Text = z33.string().max(65536);
+var AutomationScriptParams = z33.strictObject({
+  /** applescript and jxa: macOS (osascript); powershell: Windows (and pwsh where installed). */
+  language: z33.enum(["applescript", "jxa", "powershell"]),
+  script: z33.string().min(1).max(262144),
+  timeout_s: z33.int().min(1).max(600).default(60)
+});
+var AutomationScriptResult = z33.strictObject({
+  stdout: z33.string(),
+  stderr: z33.string(),
+  exit_code: z33.int(),
+  timed_out: z33.boolean(),
+  /** stdout or stderr was cut at 1 MiB. */
+  truncated: z33.boolean(),
+  elapsed_ms: nonNegInt
+});
+var MailAccountsParams = z33.strictObject({});
+var MailAccount = z33.strictObject({ name: z33.string(), emails: z33.array(z33.string()), enabled: z33.boolean() });
+var MailAccountsResult = z33.strictObject({ accounts: z33.array(MailAccount) });
+var MailListParams = z33.strictObject({
+  /** The account's name in Mail; absent: every account. */
+  account: z33.string().min(1).max(256).optional(),
+  /** The mailbox's name ("INBOX", "Sent Messages"). */
+  mailbox: z33.string().min(1).max(256).default("INBOX"),
+  unread_only: z33.boolean().default(false),
+  limit: z33.int().min(1).max(200).default(25)
+});
+var MailMessage = z33.strictObject({
+  id: z33.string(),
+  subject: z33.string(),
+  sender: z33.string(),
+  received_at_ms: epochMs.nullable(),
+  read: z33.boolean(),
+  account: z33.string(),
+  mailbox: z33.string(),
+  /** The first lines of the message's text. */
+  preview: z33.string()
+});
+var MailListResult = z33.strictObject({ messages: z33.array(MailMessage) });
+var MailSendParams = z33.strictObject({
+  to: z33.array(z33.string().min(3).max(320)).min(1).max(50),
+  cc: z33.array(z33.string().min(3).max(320)).max(50).default([]),
+  subject: z33.string().max(998),
+  body: Text,
+  /** The sending account's address; absent: Mail's default. */
+  from: z33.string().min(3).max(320).optional(),
+  /** false leaves it open in Mail as a draft for the person to send. */
+  send: z33.boolean().default(true)
+});
+var MailSendResult = z33.strictObject({ sent: z33.boolean() });
+var MessagesChatsParams = z33.strictObject({ limit: z33.int().min(1).max(200).default(25) });
+var MessagesChat = z33.strictObject({
+  chat_id: z33.string(),
+  name: z33.string().nullable(),
+  participants: z33.array(z33.string()),
+  last_message_at_ms: epochMs.nullable(),
+  service: z33.string().nullable()
+});
+var MessagesChatsResult = z33.strictObject({ chats: z33.array(MessagesChat) });
+var MessagesListParams = z33.strictObject({
+  /** One chat (messages.chats' chat_id); absent: the newest across all. */
+  chat_id: z33.string().min(1).max(512).optional(),
+  limit: z33.int().min(1).max(500).default(50)
+});
+var MessagesMessage = z33.strictObject({
+  id: z33.string(),
+  chat_id: z33.string().nullable(),
+  text: z33.string(),
+  from_me: z33.boolean(),
+  /** The other person's handle (phone or email); null for the person's own messages. */
+  sender: z33.string().nullable(),
+  sent_at_ms: epochMs.nullable()
+});
+var MessagesListResult = z33.strictObject({ messages: z33.array(MessagesMessage) });
+var MessagesSendParams = z33.strictObject({
+  /** A phone number or email the person can message. */
+  to: z33.string().min(3).max(320),
+  text: z33.string().min(1).max(2e4)
+});
+var MessagesSendResult = z33.strictObject({ sent: z33.boolean() });
+var ContactsSearchParams = z33.strictObject({
+  /** Matched against names, organizations, emails and phone numbers. */
+  query: z33.string().min(1).max(256),
+  limit: z33.int().min(1).max(200).default(25)
+});
+var ContactLabeled = z33.strictObject({ label: z33.string().nullable(), value: z33.string() });
+var ContactSummary = z33.strictObject({
+  id: z33.string(),
+  name: z33.string(),
+  organization: z33.string().nullable(),
+  emails: z33.array(ContactLabeled),
+  phones: z33.array(ContactLabeled)
+});
+var ContactsSearchResult = z33.strictObject({ contacts: z33.array(ContactSummary) });
+var ContactsGetParams = z33.strictObject({ id: z33.string().min(1).max(256) });
+var ContactDetail = z33.strictObject({
+  id: z33.string(),
+  name: z33.string(),
+  organization: z33.string().nullable(),
+  job_title: z33.string().nullable(),
+  emails: z33.array(ContactLabeled),
+  phones: z33.array(ContactLabeled),
+  addresses: z33.array(ContactLabeled),
+  birthday: z33.string().nullable(),
+  note: z33.string().nullable()
+});
+var ContactsGetResult = z33.strictObject({ contact: ContactDetail });
+var CalendarListParams = z33.strictObject({
+  from_ms: epochMs,
+  to_ms: epochMs,
+  /** One calendar's name; absent: every calendar. */
+  calendar: z33.string().min(1).max(256).optional(),
+  limit: z33.int().min(1).max(500).default(100)
+});
+var CalendarEvent = z33.strictObject({
+  id: z33.string(),
+  title: z33.string(),
+  start_ms: epochMs,
+  end_ms: epochMs,
+  all_day: z33.boolean(),
+  calendar: z33.string(),
+  location: z33.string().nullable(),
+  notes: z33.string().nullable()
+});
+var CalendarListResult = z33.strictObject({ events: z33.array(CalendarEvent) });
+var CalendarCreateParams = z33.strictObject({
+  title: z33.string().min(1).max(1024),
+  start_ms: epochMs,
+  end_ms: epochMs,
+  all_day: z33.boolean().default(false),
+  /** The calendar's name; absent: the first writable calendar. */
+  calendar: z33.string().min(1).max(256).optional(),
+  location: z33.string().max(1024).optional(),
+  notes: Text.optional()
+});
+var CalendarCreateResult = z33.strictObject({ id: z33.string(), calendar: z33.string() });
+var RemindersListParams = z33.strictObject({
+  /** One list's name; absent: every list. */
+  list: z33.string().min(1).max(256).optional(),
+  include_completed: z33.boolean().default(false),
+  limit: z33.int().min(1).max(500).default(100)
+});
+var Reminder = z33.strictObject({
+  id: z33.string(),
+  title: z33.string(),
+  list: z33.string(),
+  due_ms: epochMs.nullable(),
+  completed: z33.boolean(),
+  notes: z33.string().nullable()
+});
+var RemindersListResult = z33.strictObject({ reminders: z33.array(Reminder) });
+var RemindersCreateParams = z33.strictObject({
+  title: z33.string().min(1).max(1024),
+  due_ms: epochMs.optional(),
+  list: z33.string().min(1).max(256).optional(),
+  notes: Text.optional()
+});
+var RemindersCreateResult = z33.strictObject({ id: z33.string(), list: z33.string() });
+var PhotosSearchParams = z33.strictObject({
+  /** Matched against file names, titles, descriptions and keywords; absent: the newest. */
+  query: z33.string().min(1).max(256).optional(),
+  from_ms: epochMs.optional(),
+  to_ms: epochMs.optional(),
+  favorites_only: z33.boolean().default(false),
+  limit: z33.int().min(1).max(200).default(25)
+});
+var Photo = z33.strictObject({
+  id: z33.string(),
+  filename: z33.string(),
+  taken_at_ms: epochMs.nullable(),
+  width: nonNegInt.nullable(),
+  height: nonNegInt.nullable(),
+  favorite: z33.boolean(),
+  title: z33.string().nullable()
+});
+var PhotosSearchResult = z33.strictObject({ photos: z33.array(Photo) });
+var PhotosGetParams = z33.strictObject({
+  id: z33.string().min(1).max(256),
+  /** Copy the original into a folder Matrx 2 owns and answer its path (then fs_read or desktop_documents reads it). */
+  export: z33.boolean().default(false)
+});
+var PhotosGetResult = z33.strictObject({ photo: Photo, path: z33.string().nullable() });
+var LocationGetParams = z33.strictObject({ timeout_s: z33.int().min(1).max(60).default(15) });
+var LocationGetResult = z33.strictObject({
+  latitude: z33.number().min(-90).max(90),
+  longitude: z33.number().min(-180).max(180),
+  /** Metres; null where the OS does not say. */
+  accuracy_m: z33.number().min(0).nullable(),
+  at_ms: epochMs,
+  /** Who answered: the OS's own location service. */
+  source: z33.enum(["corelocation", "windows", "geoclue"])
+});
+
+// src/schema/windows.ts
+import { z as z34 } from "zod";
+var RegistryKey = z34.string().min(6).max(1024).regex(/^(HKLM|HKCU|HKCR|HKU|HKCC|HKEY_LOCAL_MACHINE|HKEY_CURRENT_USER|HKEY_CLASSES_ROOT|HKEY_USERS|HKEY_CURRENT_CONFIG)(\\.*)?$/);
+var RegistryValueType = z34.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
+var WindowsRegistryReadParams = z34.strictObject({
+  key: RegistryKey,
+  /** One value's name ("" is the key's default value); absent: every value and the subkeys. */
+  name: z34.string().max(16383).optional()
+});
+var RegistryValue = z34.strictObject({ name: z34.string(), type: RegistryValueType, data: z34.string() });
+var WindowsRegistryReadResult = z34.strictObject({
+  key: z34.string(),
+  exists: z34.boolean(),
+  values: z34.array(RegistryValue),
+  subkeys: z34.array(z34.string())
+});
+var WindowsRegistryWriteParams = z34.strictObject({
+  key: RegistryKey,
+  name: z34.string().max(16383),
+  type: RegistryValueType.default("REG_SZ"),
+  /** As reg.exe takes it: text, a number, hex for binary, \\0 between the strings of a multi-string. */
+  data: z34.string().max(1048576),
+  /** Remove the value instead of writing it. */
+  delete: z34.boolean().default(false)
+});
+var WindowsRegistryWriteResult = z34.strictObject({ key: z34.string(), name: z34.string(), deleted: z34.boolean() });
+var WindowsServicesParams = z34.strictObject({
+  /** Matched against the service's name and display name. */
+  filter: z34.string().min(1).max(256).optional(),
+  limit: z34.int().min(1).max(1e3).default(200)
+});
+var WindowsService = z34.strictObject({
+  name: z34.string(),
+  display_name: z34.string(),
+  /** Running, Stopped, Paused… as Windows says it. */
+  status: z34.string(),
+  /** Automatic, Manual, Disabled…; null where Windows does not say. */
+  start_type: z34.string().nullable()
+});
+var WindowsServicesResult = z34.strictObject({ services: z34.array(WindowsService) });
+var WindowsServiceControlParams = z34.strictObject({
+  name: z34.string().min(1).max(256),
+  action: z34.enum(["start", "stop", "restart"])
+});
+var WindowsServiceControlResult = z34.strictObject({ name: z34.string(), status: z34.string() });
+var WindowsEventLogParams = z34.strictObject({
+  log: z34.string().min(1).max(256).default("System"),
+  /** Only these levels; absent: all. */
+  levels: z34.array(z34.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
+  since_ms: epochMs.optional(),
+  limit: z34.int().min(1).max(500).default(50)
+});
+var WindowsEvent = z34.strictObject({
+  id: z34.int(),
+  level: z34.string(),
+  source: z34.string(),
+  at_ms: epochMs,
+  message: z34.string()
+});
+var WindowsEventLogResult = z34.strictObject({ log: z34.string(), events: z34.array(WindowsEvent) });
+var WindowsFeaturesParams = z34.strictObject({ filter: z34.string().min(1).max(256).optional() });
+var WindowsFeature = z34.strictObject({ name: z34.string(), state: z34.string() });
+var WindowsFeaturesResult = z34.strictObject({ features: z34.array(WindowsFeature) });
+
+// src/schema/schedule.ts
+import { z as z35 } from "zod";
+var OpRef = z35.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
+var ScheduleCreateParams = z35.strictObject({
+  name: z35.string().min(1).max(200),
+  op: OpRef,
+  /** The op's params, exactly as the op takes them; checked when the task is created. */
+  params: z35.record(z35.string(), z35.unknown()).default({}),
+  interval_s: z35.int().min(10).max(2592e3),
+  /** Stop after this many runs; absent: until cancelled. */
+  max_runs: z35.int().min(1).max(1e5).optional(),
+  /** Run once now, before the first interval. */
+  run_now: z35.boolean().default(false)
+});
+var ScheduleRun = z35.strictObject({
+  at_ms: epochMs,
+  ok: z35.boolean(),
+  elapsed_ms: nonNegInt,
+  /** The error's code and message when the run failed. */
+  error: z35.string().nullable(),
+  /** The start of the answer, as JSON (cut at 4 KiB). */
+  result_preview: z35.string().nullable()
+});
+var ScheduledTask = z35.strictObject({
+  id: z35.string(),
+  name: z35.string(),
+  op: z35.string(),
+  params: z35.record(z35.string(), z35.unknown()),
+  interval_s: nonNegInt,
+  max_runs: nonNegInt.nullable(),
+  runs: nonNegInt,
+  created_at_ms: epochMs,
+  next_run_at_ms: epochMs.nullable(),
+  /** active, done (ran max_runs), cancelled. */
+  state: z35.enum(["active", "done", "cancelled"]),
+  /** The newest runs, newest first (at most 10). */
+  recent: z35.array(ScheduleRun)
+});
+var ScheduleCreateResult = z35.strictObject({ task: ScheduledTask });
+var ScheduleListParams = z35.strictObject({ include_finished: z35.boolean().default(false) });
+var ScheduleListResult = z35.strictObject({ tasks: z35.array(ScheduledTask) });
+var ScheduleCancelParams = z35.strictObject({ id: z35.string().min(1).max(64) });
+var ScheduleCancelResult = z35.strictObject({ task: ScheduledTask });
+
+// src/schema/notes.ts
+import { z as z36 } from "zod";
+var NoteFolder = z36.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
+var NotePath = z36.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
+var NotesFoldersParams = z36.strictObject({});
+var NotesFolder = z36.strictObject({ folder: z36.string(), notes: nonNegInt });
+var NotesFoldersResult = z36.strictObject({
+  /** The notes root on this computer. */
+  root: z36.string(),
+  folders: z36.array(NotesFolder)
+});
+var NotesListParams = z36.strictObject({
+  folder: NoteFolder.optional(),
+  limit: z36.int().min(1).max(2e3).default(500)
+});
+var NoteEntry = z36.strictObject({
+  path: z36.string(),
+  label: z36.string(),
+  folder: z36.string(),
+  bytes: nonNegInt,
+  modified_at_ms: epochMs
+});
+var NotesListResult = z36.strictObject({ root: z36.string(), notes: z36.array(NoteEntry), total: nonNegInt });
+var NotesReadParams = z36.strictObject({ path: NotePath });
+var NotesReadResult = z36.strictObject({
+  path: z36.string(),
+  content: z36.string(),
+  bytes: nonNegInt,
+  modified_at_ms: epochMs,
+  /** SHA-256 of the content: pass it back as `if_hash` to write only over this version. */
+  hash: z36.string()
+});
+var NotesWriteParams = z36.strictObject({
+  folder: NoteFolder.default("General"),
+  /** The note's name, without ".md". */
+  label: z36.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
+  content: z36.string().max(10485760),
+  /** Write only when the note is still this version (notes.read's hash); a change since answers CONFLICT. */
+  if_hash: z36.string().length(64).optional()
+});
+var NotesWriteResult = z36.strictObject({ path: z36.string(), bytes: nonNegInt, created: z36.boolean(), hash: z36.string() });
+var NotesSearchParams = z36.strictObject({
+  query: z36.string().min(1).max(512),
+  limit: z36.int().min(1).max(200).default(50)
+});
+var NotesMatch = z36.strictObject({
+  path: z36.string(),
+  label: z36.string(),
+  folder: z36.string(),
+  /** The matching lines (at most five), trimmed. */
+  lines: z36.array(z36.string())
+});
+var NotesSearchResult = z36.strictObject({ matches: z36.array(NotesMatch), total: nonNegInt });
+
+// src/schema/documents.ts
+import { z as z37 } from "zod";
+var DOCUMENTS_MAX_TEXT_CHARS = 1048576;
+var DocumentsPdfTextParams = z37.strictObject({
+  path: AbsPath,
+  /** 1-based, inclusive. */
+  first_page: z37.int().min(1).optional(),
+  last_page: z37.int().min(1).optional(),
+  max_chars: z37.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
+});
+var DocumentsPdfPage = z37.strictObject({ page: z37.int().min(1), text: z37.string() });
+var DocumentsPdfTextResult = z37.strictObject({
+  pages: nonNegInt,
+  /** Each page read, in order (an image-only page has empty text: OCR it). */
+  read: z37.array(DocumentsPdfPage),
+  truncated: z37.boolean(),
+  title: z37.string().nullable(),
+  author: z37.string().nullable()
+});
+var DocumentsOcrParams = z37.strictObject({
+  path: AbsPath,
+  /** BCP-47 language hints ("en-US", "fr-FR"); absent: the OS's own choice. */
+  languages: z37.array(z37.string().min(2).max(16)).max(8).optional(),
+  /** Faster, less accurate. */
+  fast: z37.boolean().default(false)
+});
+var DocumentsOcrLine = z37.strictObject({
+  text: z37.string(),
+  /** 0–1; null where the engine does not say. */
+  confidence: z37.number().min(0).max(1).nullable()
+});
+var DocumentsOcrResult = z37.strictObject({
+  text: z37.string(),
+  lines: z37.array(DocumentsOcrLine),
+  truncated: z37.boolean(),
+  /** Which engine read it ("vision" on macOS, "windows-ocr", "tesseract"). */
+  engine: z37.string()
+});
+var DocumentsImageResizeParams = z37.strictObject({
+  path: AbsPath,
+  /** Where to write it; absent: next to the original, "<name>-resized.<ext>". */
+  out_path: AbsPath.optional(),
+  /** The longest side, kept in proportion; absent: the size stays (a format change only). */
+  max_size: z37.int().min(1).max(32768).optional(),
+  format: z37.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
+  overwrite: z37.boolean().default(false)
+});
+var DocumentsImageResizeResult = z37.strictObject({
+  path: z37.string(),
+  width: nonNegInt,
+  height: nonNegInt,
+  bytes: nonNegInt
+});
+var DocumentsParagraph = z37.strictObject({
+  style: z37.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
+  text: z37.string().max(1e5)
+});
+var DocumentsSheet = z37.strictObject({
+  name: z37.string().min(1).max(31),
+  /** Rows of cells; the first row is the header when `header` is true. */
+  rows: z37.array(z37.array(z37.union([z37.string().max(32767), z37.number(), z37.boolean(), z37.null()])).max(16384)).max(1e5),
+  header: z37.boolean().default(true)
+});
+var DocumentsOfficeGenerateParams = z37.strictObject({
+  kind: z37.enum(["docx", "xlsx"]),
+  path: AbsPath,
+  title: z37.string().max(1024).optional(),
+  /** docx: the document's paragraphs, in order. */
+  paragraphs: z37.array(DocumentsParagraph).max(5e4).optional(),
+  /** xlsx: the workbook's sheets, in order. */
+  sheets: z37.array(DocumentsSheet).min(1).max(64).optional(),
+  overwrite: z37.boolean().default(false)
+});
+var DocumentsOfficeGenerateResult = z37.strictObject({ path: z37.string(), bytes: nonNegInt });
+var EntitiesNerParams = z37.strictObject({
+  text: z37.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+  /** Which kinds to keep; absent: all three. */
+  labels: z37.array(z37.enum(["person", "place", "organization"])).min(1).max(3).optional()
+});
+var EntitySpan = z37.strictObject({
+  text: z37.string(),
+  label: z37.string(),
+  /** Character offsets into the text (UTF-16, as JavaScript counts). */
+  start: nonNegInt,
+  end: nonNegInt
+});
+var EntitiesNerResult = z37.strictObject({ entities: z37.array(EntitySpan), engine: z37.string() });
+var PiiKind = z37.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
+var EntitiesPiiParams = z37.strictObject({
+  text: z37.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+  kinds: z37.array(PiiKind).min(1).max(8).optional(),
+  /** Also answer the text with each finding replaced by its kind ("[email]"). */
+  redact: z37.boolean().default(false)
+});
+var EntitiesPiiResult = z37.strictObject({
+  findings: z37.array(z37.strictObject({ kind: PiiKind, text: z37.string(), start: nonNegInt, end: nonNegInt })),
+  redacted: z37.string().nullable()
+});
+
 // src/schema/registry.ts
 var FS_ERR = ["NOT_FOUND", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "RESOURCE_BUSY", "INTERNAL"];
 var OPS = {
@@ -2854,7 +3475,55 @@ var OPS = {
   "browser.set_enabled": { params: BrowserSetEnabledParams, result: BrowserSetEnabledResult, kind: "unary", since: "1.28", errors: ["AUTH_FORBIDDEN", "INTERNAL"] },
   "browser.pair_code": { params: BrowserPairCodeParams, result: BrowserPairCodeResult, kind: "unary", since: "1.28", errors: ["AUTH_FORBIDDEN", "INTERNAL"] },
   "browser.pair_reset": { params: BrowserPairResetParams, result: BrowserPairCodeResult, kind: "unary", since: "1.28", errors: ["AUTH_FORBIDDEN", "INTERNAL"] },
-  "browser.call": { params: BrowserCallParams, result: BrowserCallResult, kind: "unary", since: "1.28", errors: ["NOT_FOUND", "CONFLICT", "AUTH_FORBIDDEN", "INVALID_PARAMS", "TIMEOUT", "CANCELLED", "RESOURCE_GONE", "PAYLOAD_TOO_LARGE", "INTERNAL"] }
+  "browser.tool_metrics": { params: BrowserToolMetricsParams, result: BrowserToolMetricsResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS"] },
+  "browser.reset_counters": { params: BrowserResetCountersParams, result: BrowserResetCountersResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS"] },
+  "browser.log": { params: BrowserLogParams, result: BrowserLogResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS"] },
+  "browser.call": { params: BrowserCallParams, result: BrowserCallResult, kind: "unary", since: "1.28", errors: ["NOT_FOUND", "CONFLICT", "AUTH_FORBIDDEN", "INVALID_PARAMS", "TIMEOUT", "CANCELLED", "RESOURCE_GONE", "PAYLOAD_TOO_LARGE", "INTERNAL"] },
+  // 1.37: Matrx Local's remaining sidecar tools in the core (net, automation, the person's apps,
+  // Windows administration, schedules, local notes, documents and entities).
+  "net.info": { params: NetInfoParams, result: NetInfoResult, kind: "unary", since: "1.37", errors: ["PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "net.wifi": { params: NetWifiParams, result: NetWifiResult, kind: "unary", since: "1.37", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "net.bluetooth": { params: NetBluetoothParams, result: NetBluetoothResult, kind: "unary", since: "1.37", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "net.devices": { params: NetDevicesParams, result: NetDevicesResult, kind: "unary", since: "1.37", errors: ["PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "net.mdns": { params: NetMdnsParams, result: NetMdnsResult, kind: "unary", since: "1.37", errors: ["PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "net.scan": { params: NetScanParams, result: NetScanResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "AUTH_FORBIDDEN", "TIMEOUT", "INTERNAL"] },
+  "net.download": { params: NetDownloadParams, result: NetDownloadResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "CONFLICT", "PERMISSION_DENIED_OS", "PAYLOAD_TOO_LARGE", "TIMEOUT", "INTERNAL"] },
+  "automation.script": { params: AutomationScriptParams, result: AutomationScriptResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "mail.accounts": { params: MailAccountsParams, result: MailAccountsResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "mail.list": { params: MailListParams, result: MailListResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "mail.send": { params: MailSendParams, result: MailSendResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "messages.chats": { params: MessagesChatsParams, result: MessagesChatsResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "messages.list": { params: MessagesListParams, result: MessagesListResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "messages.send": { params: MessagesSendParams, result: MessagesSendResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "contacts.search": { params: ContactsSearchParams, result: ContactsSearchResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "contacts.get": { params: ContactsGetParams, result: ContactsGetResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "calendar.list": { params: CalendarListParams, result: CalendarListResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "calendar.create": { params: CalendarCreateParams, result: CalendarCreateResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "reminders.list": { params: RemindersListParams, result: RemindersListResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "reminders.create": { params: RemindersCreateParams, result: RemindersCreateResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "photos.search": { params: PhotosSearchParams, result: PhotosSearchResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "photos.get": { params: PhotosGetParams, result: PhotosGetResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "location.get": { params: LocationGetParams, result: LocationGetResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "windows.registry_read": { params: WindowsRegistryReadParams, result: WindowsRegistryReadResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "windows.registry_write": { params: WindowsRegistryWriteParams, result: WindowsRegistryWriteResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "windows.services": { params: WindowsServicesParams, result: WindowsServicesResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "windows.service_control": { params: WindowsServiceControlParams, result: WindowsServiceControlResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "windows.event_log": { params: WindowsEventLogParams, result: WindowsEventLogResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "windows.features": { params: WindowsFeaturesParams, result: WindowsFeaturesResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "schedule.create": { params: ScheduleCreateParams, result: ScheduleCreateResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "INTERNAL"] },
+  "schedule.list": { params: ScheduleListParams, result: ScheduleListResult, kind: "unary", since: "1.37", errors: ["INTERNAL"] },
+  "schedule.cancel": { params: ScheduleCancelParams, result: ScheduleCancelResult, kind: "unary", since: "1.37", errors: ["NOT_FOUND", "INTERNAL"] },
+  "notes.folders": { params: NotesFoldersParams, result: NotesFoldersResult, kind: "unary", since: "1.37", errors: ["INTERNAL"] },
+  "notes.list": { params: NotesListParams, result: NotesListResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "INTERNAL"] },
+  "notes.read": { params: NotesReadParams, result: NotesReadResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "INTERNAL"] },
+  "notes.write": { params: NotesWriteParams, result: NotesWriteResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "CONFLICT", "PERMISSION_DENIED_OS", "INTERNAL"] },
+  "notes.search": { params: NotesSearchParams, result: NotesSearchResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "INTERNAL"] },
+  "documents.pdf_text": { params: DocumentsPdfTextParams, result: DocumentsPdfTextResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "documents.ocr": { params: DocumentsOcrParams, result: DocumentsOcrResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "documents.image_resize": { params: DocumentsImageResizeParams, result: DocumentsImageResizeResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "documents.office_generate": { params: DocumentsOfficeGenerateParams, result: DocumentsOfficeGenerateResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "NOT_FOUND", "CONFLICT", "PERMISSION_DENIED_OS", "INTERNAL"] },
+  "entities.ner": { params: EntitiesNerParams, result: EntitiesNerResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "entities.pii": { params: EntitiesPiiParams, result: EntitiesPiiResult, kind: "unary", since: "1.37", errors: ["INVALID_PARAMS", "INTERNAL"] }
 };
 var EVENTS = {
   "fs.changed": FsChangedEvent,