@ai-matrx/desktop-protocol 0.21.38 → 0.21.39

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 = 46;
+var PROTOCOL_MINOR = 47;
 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_-]+$/);
@@ -1751,249 +1751,331 @@ var AppsWindowsUpdateAndReopenResult = z14.strictObject({
   installed_version: z14.string().max(64).nullable()
 });
 
-// src/schema/service.ts
+// src/schema/apps-instances.ts
 import { z as z15 } from "zod";
+var InstanceStatus = z15.enum(["open", "closed", "wrong_account", "update_waiting", "folder_missing"]);
+var AppInstall = z15.strictObject({
+  location: z15.string().max(1024),
+  version: z15.string().max(80).nullable()
+});
+var AppInstance = z15.strictObject({
+  app_key: AppKey,
+  /** "main", or the instance's name: the same key every window action takes. */
+  key: ChatPlace,
+  main: z15.boolean(),
+  status: InstanceStatus,
+  running: z15.boolean(),
+  /** Its process while open. */
+  pid: nonNegInt.nullable(),
+  /** Its data folder on this device. */
+  folder: z15.string().max(1024).nullable(),
+  folder_exists: z15.boolean(),
+  /** The provider's id of the account signed in there now, when the app records it. */
+  account_id: z15.string().max(200).nullable(),
+  /** That account's email, when known. */
+  account: z15.string().max(320).nullable(),
+  /** The account this instance is kept for (null for main: it signs into any). */
+  meant_for: z15.string().max(320).nullable(),
+  /** The version running in it now, or the one it last ran when closed. */
+  version: z15.string().max(80).nullable(),
+  installed_version: z15.string().max(80).nullable(),
+  /** Chats open in it now. */
+  open_chats: nonNegInt,
+  launched_ms: epochMs.nullable(),
+  quit_ms: epochMs.nullable(),
+  first_launch_ms: epochMs.nullable()
+});
+var AccountResetSource = z15.enum(["app", "usage_history", "your_list"]);
+var AccountGap = z15.enum(["email", "plan", "usage"]);
+var AppAccount = z15.strictObject({
+  app_key: AppKey,
+  /** The provider's own account id (Claude's account uuid, ChatGPT's account id); `org:<uuid>` when only its organization is known. */
+  account_id: z15.string().max(200),
+  email: z15.string().max(320).nullable(),
+  plan: z15.string().max(80).nullable(),
+  /** The provider organizations its readings are filed under. */
+  orgs: z15.array(z15.string().max(80)).max(20),
+  /** Weekly use in percent; 0 once the week reset after the reading. */
+  weekly: z15.number().nullable(),
+  weekly_reset_since: z15.boolean(),
+  weekly_resets_at_ms: epochMs.nullable(),
+  weekly_reset_source: AccountResetSource.nullable(),
+  /** 5-hour use in percent; 0 once the 5-hour window passed after the reading. */
+  five_hour: z15.number().nullable(),
+  five_hour_reset_since: z15.boolean(),
+  /** The latest the 5-hour window resets. */
+  five_hour_resets_at_ms: epochMs.nullable(),
+  /** Claude: extra-usage spend as a percent of its cap. */
+  extra_usage: z15.number().nullable(),
+  /** Codex: the credit balance. */
+  credits: z15.number().nullable(),
+  /** When the newest reading was taken, and in which instance. */
+  read_at_ms: epochMs.nullable(),
+  read_in: ChatPlace.nullable(),
+  /** Instances signed into it now. */
+  instances: z15.array(ChatPlace).max(200),
+  first_seen_ms: epochMs.nullable(),
+  last_seen_ms: epochMs.nullable(),
+  missing: z15.array(AccountGap).max(3)
+});
+var AppsInstancesListParams = z15.strictObject({ app_key: AppKey });
+var AppsInstancesListResult = z15.strictObject({
+  app_key: AppKey,
+  install: AppInstall.nullable(),
+  instances: z15.array(AppInstance).max(200),
+  /** The rows are right but something around them failed; shown, never hidden. */
+  problem: z15.string().max(400).optional()
+});
+var AppsAccountsListParams = z15.strictObject({ app_key: AppKey });
+var AppsAccountsListResult = z15.strictObject({
+  app_key: AppKey,
+  accounts: z15.array(AppAccount).max(500),
+  problem: z15.string().max(400).optional()
+});
+
+// src/schema/service.ts
+import { z as z16 } from "zod";
 var SERVICE_MAX_FRAME_BYTES = 16777216;
-var ServiceName = z15.enum(["ml", "coding", "tools"]);
-var ContractHash = z15.string().regex(/^[0-9a-f]{64}$/);
-var ServiceToken = z15.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var ServiceName = z16.enum(["ml", "coding", "tools"]);
+var ContractHash = z16.string().regex(/^[0-9a-f]{64}$/);
+var ServiceToken = z16.string().regex(/^[A-Za-z0-9_-]{43}$/);
 var ServiceRequestId = u32;
-var ServiceHello = z15.strictObject({ type: z15.literal("hello"), token: ServiceToken, contract: ContractHash });
-var ServiceWelcome = z15.strictObject({
-  type: z15.literal("welcome"),
+var ServiceHello = z16.strictObject({ type: z16.literal("hello"), token: ServiceToken, contract: ContractHash });
+var ServiceWelcome = z16.strictObject({
+  type: z16.literal("welcome"),
   service: ServiceName,
   contract: ContractHash,
   pid: nonNegInt,
   /** The interpreter's version, e.g. "3.13.15". */
-  python: z15.string().max(32),
+  python: z16.string().max(32),
   /** Every op this service serves; must equal SERVICES[service] exactly. */
-  ops: z15.array(z15.string().min(1).max(64)).max(64)
+  ops: z16.array(z16.string().min(1).max(64)).max(64)
 });
-var ServiceRequest = z15.strictObject({
-  type: z15.literal("request"),
+var ServiceRequest = z16.strictObject({
+  type: z16.literal("request"),
   id: ServiceRequestId,
-  op: z15.string().min(1).max(64),
-  params: z15.unknown()
+  op: z16.string().min(1).max(64),
+  params: z16.unknown()
   // validated by the service against SERVICES[service][op].params
 });
-var ServiceResponse = z15.strictObject({
-  type: z15.literal("response"),
+var ServiceResponse = z16.strictObject({
+  type: z16.literal("response"),
   id: ServiceRequestId,
-  result: z15.unknown()
+  result: z16.unknown()
   // validated by the core against SERVICES[service][op].result
 });
-var ServiceErrorMsg = z15.strictObject({ type: z15.literal("error"), id: ServiceRequestId, error: ProtocolErrorBody });
-var ServiceProgressMsg = z15.strictObject({ type: z15.literal("progress"), id: ServiceRequestId, progress: z15.unknown() });
-var ServiceCancel = z15.strictObject({ type: z15.literal("cancel"), id: ServiceRequestId });
-var ServicePing = z15.strictObject({ type: z15.literal("ping"), id: ServiceRequestId });
-var ServicePong = z15.strictObject({
-  type: z15.literal("pong"),
+var ServiceErrorMsg = z16.strictObject({ type: z16.literal("error"), id: ServiceRequestId, error: ProtocolErrorBody });
+var ServiceProgressMsg = z16.strictObject({ type: z16.literal("progress"), id: ServiceRequestId, progress: z16.unknown() });
+var ServiceCancel = z16.strictObject({ type: z16.literal("cancel"), id: ServiceRequestId });
+var ServicePing = z16.strictObject({ type: z16.literal("ping"), id: ServiceRequestId });
+var ServicePong = z16.strictObject({
+  type: z16.literal("pong"),
   id: ServiceRequestId,
   /** Requests running now. */
   busy: nonNegInt
 });
-var ServiceShutdown = z15.strictObject({ type: z15.literal("shutdown") });
-var CoreToServiceMsg = z15.discriminatedUnion("type", [ServiceHello, ServiceRequest, ServiceCancel, ServicePing, ServiceShutdown]);
-var ServiceToCoreMsg = z15.discriminatedUnion("type", [ServiceWelcome, ServiceResponse, ServiceErrorMsg, ServiceProgressMsg, ServicePong]);
+var ServiceShutdown = z16.strictObject({ type: z16.literal("shutdown") });
+var CoreToServiceMsg = z16.discriminatedUnion("type", [ServiceHello, ServiceRequest, ServiceCancel, ServicePing, ServiceShutdown]);
+var ServiceToCoreMsg = z16.discriminatedUnion("type", [ServiceWelcome, ServiceResponse, ServiceErrorMsg, ServiceProgressMsg, ServicePong]);
 
 // src/schema/tools.ts
-import { z as z16 } from "zod";
-var ToolLevel = z16.enum(["programmatic", "protocol", "chat"]);
-var ToolOutcome = z16.enum(["pass", "fail", "skip"]);
-var ToolPlatform = z16.enum(["darwin", "win32", "linux"]);
-var ToolTransport = z16.enum(["in_process", "localhost", "relay", "agent"]);
-var ToolName = z16.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/);
-var ToolLevelResult = z16.strictObject({
+import { z as z17 } from "zod";
+var ToolLevel = z17.enum(["programmatic", "protocol", "chat"]);
+var ToolOutcome = z17.enum(["pass", "fail", "skip"]);
+var ToolPlatform = z17.enum(["darwin", "win32", "linux"]);
+var ToolTransport = z17.enum(["in_process", "localhost", "relay", "agent"]);
+var ToolName = z17.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/);
+var ToolLevelResult = z17.strictObject({
   tool: ToolName,
   level: ToolLevel,
   platform: ToolPlatform,
   transport: ToolTransport,
   outcome: ToolOutcome,
   /** True when the caller sat on a different network from the device (a phone on cellular, CI). */
-  remote_network: z16.boolean(),
+  remote_network: z17.boolean(),
   /** One line: what was asserted, or why it failed. Never a token, a file's contents or a path under a real home. */
-  detail: z16.string().max(500),
+  detail: z17.string().max(500),
   /** The harness that produced it, e.g. `matrx-desktop test/tools/programmatic.test.ts`. */
-  suite: z16.string().min(1).max(200),
+  suite: z17.string().min(1).max(200),
   /** The test case inside the suite. */
-  test: z16.string().min(1).max(300),
-  run_at_ms: z16.int().min(0),
+  test: z17.string().min(1).max(300),
+  run_at_ms: z17.int().min(0),
   /**
    * Chat level: how many tool calls the agent's turn made, of any tool. `0` means the turn never
    * exercised a tool (the model answered in prose, or the chat request failed), so the result is
    * no evidence about the tool: it never turns a cell red. Absent on older results.
    */
-  calls_made: z16.int().min(0).optional()
+  calls_made: z17.int().min(0).optional()
 });
-var ToolResultsFile = z16.strictObject({
-  schema: z16.literal("matrx.tool-results.v1"),
+var ToolResultsFile = z17.strictObject({
+  schema: z17.literal("matrx.tool-results.v1"),
   /** The producing repo's commit (short or full SHA). */
-  commit: z16.string().min(4).max(64),
-  results: z16.array(ToolLevelResult).max(1e4)
+  commit: z17.string().min(4).max(64),
+  results: z17.array(ToolLevelResult).max(1e4)
 });
 
 // src/schema/proc.ts
-import { z as z17 } from "zod";
-var ProcSort = z17.enum(["cpu", "memory", "pid", "name"]);
-var ProcListParams = z17.strictObject({
+import { z as z18 } from "zod";
+var ProcSort = z18.enum(["cpu", "memory", "pid", "name"]);
+var ProcListParams = z18.strictObject({
   /** Case-insensitive substring of the process name or its command line. */
-  name: z17.string().min(1).max(128).optional(),
+  name: z18.string().min(1).max(128).optional(),
   sort: ProcSort.default("cpu"),
-  limit: z17.int().min(1).max(500).default(50)
+  limit: z18.int().min(1).max(500).default(50)
 });
-var ProcInfo = z17.strictObject({
-  pid: z17.int().min(0),
+var ProcInfo = z18.strictObject({
+  pid: z18.int().min(0),
   /** Parent process id; null where the OS does not report it. */
-  ppid: z17.int().min(0).nullable(),
-  name: z17.string().max(256),
+  ppid: z18.int().min(0).nullable(),
+  name: z18.string().max(256),
   /** The command line, cut to 1024 characters. */
-  command: z17.string().max(1024),
+  command: z18.string().max(1024),
   /** Share of one core, as `ps` and Task Manager report it; null where the OS does not say. */
-  cpu_percent: z17.number().min(0).nullable(),
+  cpu_percent: z18.number().min(0).nullable(),
   memory_bytes: nonNegInt.nullable(),
-  user: z17.string().max(128).nullable()
+  user: z18.string().max(128).nullable()
 });
-var ProcListResult = z17.strictObject({
-  processes: z17.array(ProcInfo).max(500),
+var ProcListResult = z18.strictObject({
+  processes: z18.array(ProcInfo).max(500),
   /** Processes that matched before `limit`. */
   total: nonNegInt,
-  truncated: z17.boolean()
+  truncated: z18.boolean()
 });
-var ProcPortsParams = z17.strictObject({
+var ProcPortsParams = z18.strictObject({
   /** Only this port. */
-  port: z17.int().min(1).max(65535).optional()
+  port: z18.int().min(1).max(65535).optional()
 });
-var ProcPort = z17.strictObject({
-  port: z17.int().min(1).max(65535),
-  protocol: z17.enum(["tcp", "udp"]),
+var ProcPort = z18.strictObject({
+  port: z18.int().min(1).max(65535),
+  protocol: z18.enum(["tcp", "udp"]),
   /** The local address it listens on ("127.0.0.1", "*", "::"). */
-  address: z17.string().max(64),
-  pid: z17.int().min(0).nullable(),
-  process: z17.string().max(256).nullable()
+  address: z18.string().max(64),
+  pid: z18.int().min(0).nullable(),
+  process: z18.string().max(256).nullable()
 });
-var ProcPortsResult = z17.strictObject({ ports: z17.array(ProcPort).max(4e3) });
-var ProcKillParams = z17.strictObject({
-  pid: z17.int().min(1),
+var ProcPortsResult = z18.strictObject({ ports: z18.array(ProcPort).max(4e3) });
+var ProcKillParams = z18.strictObject({
+  pid: z18.int().min(1),
   /** Kill outright (SIGKILL; on Windows the same /F) instead of asking it to quit. */
-  force: z17.boolean().default(false)
+  force: z18.boolean().default(false)
 });
-var ProcKillResult = z17.strictObject({
-  pid: z17.int().min(1),
-  signal: z17.enum(["SIGTERM", "SIGKILL"]),
+var ProcKillResult = z18.strictObject({
+  pid: z18.int().min(1),
+  signal: z18.enum(["SIGTERM", "SIGKILL"]),
   /** True when the process was gone within 3 s. */
-  exited: z17.boolean()
+  exited: z18.boolean()
 });
 
 // src/schema/clipboard.ts
-import { z as z18 } from "zod";
-var ClipboardReadParams = z18.strictObject({});
-var ClipboardReadResult = z18.strictObject({
+import { z as z19 } from "zod";
+var ClipboardReadParams = z19.strictObject({});
+var ClipboardReadResult = z19.strictObject({
   /** The clipboard's text ("" when it holds none), cut to 1 MiB. */
-  text: z18.string().max(1048576),
-  truncated: z18.boolean()
+  text: z19.string().max(1048576),
+  truncated: z19.boolean()
 });
-var ClipboardWriteParams = z18.strictObject({ text: z18.string().max(1048576) });
-var ClipboardWriteResult = z18.strictObject({ bytes: nonNegInt });
+var ClipboardWriteParams = z19.strictObject({ text: z19.string().max(1048576) });
+var ClipboardWriteResult = z19.strictObject({ bytes: nonNegInt });
 
 // src/schema/git.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var GIT_MAX_OUTPUT_CHARS = 262144;
-var GitText = z19.string().max(GIT_MAX_OUTPUT_CHARS);
-var GitName = z19.string().min(1).max(255).regex(/^[^-\s][^\s]*$/);
-var GitOutputResult = z19.strictObject({ output: GitText, truncated: z19.boolean() });
-var GitStatusParams = z19.strictObject({ cwd: AbsPath });
-var GitStatusFile = z19.strictObject({
-  path: z19.string(),
+var GitText = z20.string().max(GIT_MAX_OUTPUT_CHARS);
+var GitName = z20.string().min(1).max(255).regex(/^[^-\s][^\s]*$/);
+var GitOutputResult = z20.strictObject({ output: GitText, truncated: z20.boolean() });
+var GitStatusParams = z20.strictObject({ cwd: AbsPath });
+var GitStatusFile = z20.strictObject({
+  path: z20.string(),
   /** Porcelain v1 status letters: index (staged) and worktree; "?" for untracked. */
-  index: z19.string().length(1),
-  worktree: z19.string().length(1)
+  index: z20.string().length(1),
+  worktree: z20.string().length(1)
 });
-var GitStatusResult = z19.strictObject({
+var GitStatusResult = z20.strictObject({
   /** The checked-out branch; null when HEAD is detached. */
-  branch: z19.string().nullable(),
-  upstream: z19.string().nullable(),
+  branch: z20.string().nullable(),
+  upstream: z20.string().nullable(),
   ahead: nonNegInt,
   behind: nonNegInt,
-  files: z19.array(GitStatusFile).max(5e3),
-  clean: z19.boolean(),
+  files: z20.array(GitStatusFile).max(5e3),
+  clean: z20.boolean(),
   /** More than 5000 changed files: the list is cut. */
-  truncated: z19.boolean()
-});
-var GitDiffParams = z19.strictObject({ cwd: AbsPath, path: z19.string().max(4096).optional(), staged: z19.boolean().default(false) });
-var GitDiffResult = z19.strictObject({ diff: GitText, truncated: z19.boolean() });
-var GitLogParams = z19.strictObject({ cwd: AbsPath, limit: z19.int().min(1).max(500).default(50) });
-var GitLogCommit = z19.strictObject({ sha: z19.string(), short: z19.string(), author: z19.string(), date: z19.string(), subject: z19.string() });
-var GitLogResult = z19.strictObject({ commits: z19.array(GitLogCommit).max(500) });
-var GitAddParams = z19.strictObject({ cwd: AbsPath, paths: z19.array(z19.string().min(1).max(4096)).min(1).max(1e3) });
-var GitCommitParams = z19.strictObject({
+  truncated: z20.boolean()
+});
+var GitDiffParams = z20.strictObject({ cwd: AbsPath, path: z20.string().max(4096).optional(), staged: z20.boolean().default(false) });
+var GitDiffResult = z20.strictObject({ diff: GitText, truncated: z20.boolean() });
+var GitLogParams = z20.strictObject({ cwd: AbsPath, limit: z20.int().min(1).max(500).default(50) });
+var GitLogCommit = z20.strictObject({ sha: z20.string(), short: z20.string(), author: z20.string(), date: z20.string(), subject: z20.string() });
+var GitLogResult = z20.strictObject({ commits: z20.array(GitLogCommit).max(500) });
+var GitAddParams = z20.strictObject({ cwd: AbsPath, paths: z20.array(z20.string().min(1).max(4096)).min(1).max(1e3) });
+var GitCommitParams = z20.strictObject({
   cwd: AbsPath,
-  message: z19.string().min(1).max(65536),
-  amend: z19.boolean().default(false),
+  message: z20.string().min(1).max(65536),
+  amend: z20.boolean().default(false),
   /** "Name <email>"; absent = the computer's own git identity. */
-  author: z19.string().max(512).optional()
+  author: z20.string().max(512).optional()
 });
-var GitCommitResult = z19.strictObject({ sha: z19.string(), output: GitText, truncated: z19.boolean() });
-var GitPushParams = z19.strictObject({ cwd: AbsPath, remote: GitName.default("origin"), branch: GitName.optional(), force_with_lease: z19.boolean().default(false) });
-var GitPullParams = z19.strictObject({ cwd: AbsPath, remote: GitName.default("origin"), branch: GitName.optional(), rebase: z19.boolean().default(false) });
-var GitBranchParams = z19.strictObject({ cwd: AbsPath, action: z19.enum(["list", "create", "delete", "switch"]), name: GitName.optional() });
-var GitBranchResult = z19.strictObject({
+var GitCommitResult = z20.strictObject({ sha: z20.string(), output: GitText, truncated: z20.boolean() });
+var GitPushParams = z20.strictObject({ cwd: AbsPath, remote: GitName.default("origin"), branch: GitName.optional(), force_with_lease: z20.boolean().default(false) });
+var GitPullParams = z20.strictObject({ cwd: AbsPath, remote: GitName.default("origin"), branch: GitName.optional(), rebase: z20.boolean().default(false) });
+var GitBranchParams = z20.strictObject({ cwd: AbsPath, action: z20.enum(["list", "create", "delete", "switch"]), name: GitName.optional() });
+var GitBranchResult = z20.strictObject({
   /** The branch checked out after the action; null when detached. */
-  current: z19.string().nullable(),
+  current: z20.string().nullable(),
   /** Local branches (filled by `list`; empty otherwise). */
-  branches: z19.array(z19.string()).max(5e3),
+  branches: z20.array(z20.string()).max(5e3),
   output: GitText,
-  truncated: z19.boolean()
+  truncated: z20.boolean()
 });
-var GitStashParams = z19.strictObject({ cwd: AbsPath, action: z19.enum(["push", "pop", "list", "drop"]), message: z19.string().max(4096).optional() });
-var GitCloneParams = z19.strictObject({
-  url: z19.string().min(1).max(4096).regex(/^[^-]/),
+var GitStashParams = z20.strictObject({ cwd: AbsPath, action: z20.enum(["push", "pop", "list", "drop"]), message: z20.string().max(4096).optional() });
+var GitCloneParams = z20.strictObject({
+  url: z20.string().min(1).max(4096).regex(/^[^-]/),
   /** The folder to create; must not exist yet (or be empty). */
   dest: AbsPath,
   branch: GitName.optional(),
-  depth: z19.int().min(1).max(1e6).optional()
+  depth: z20.int().min(1).max(1e6).optional()
 });
 
 // src/schema/web.ts
 import { UUID_SHAPE_PATTERN as UUID_SHAPE_PATTERN4 } from "@ai-matrx/kit/uuid";
-import { z as z20 } from "zod";
+import { z as z21 } 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({
+var WebUrl = z21.string().min(1).max(8192).regex(/^https?:\/\//);
+var WebText = z21.string().max(WEB_MAX_TEXT_CHARS);
+var OrgId = z21.string().regex(UUID_SHAPE_PATTERN4);
+var WebHeader = z21.strictObject({ name: z21.string().min(1).max(256), value: z21.string().max(8192) });
+var WebFetchParams = z21.strictObject({
   url: WebUrl,
-  method: z20.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).default("GET"),
-  headers: z20.array(WebHeader).max(64).default([]),
-  body: z20.string().max(1048576).optional(),
-  follow_redirects: z20.boolean().default(true),
-  timeout_s: z20.int().min(1).max(300).default(30)
-});
-var WebFetchResult = z20.strictObject({
-  status: z20.int().min(100).max(999),
-  reason: z20.string(),
+  method: z21.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).default("GET"),
+  headers: z21.array(WebHeader).max(64).default([]),
+  body: z21.string().max(1048576).optional(),
+  follow_redirects: z21.boolean().default(true),
+  timeout_s: z21.int().min(1).max(300).default(30)
+});
+var WebFetchResult = z21.strictObject({
+  status: z21.int().min(100).max(999),
+  reason: z21.string(),
   /** The final URL after redirects. */
-  url: z20.string(),
-  content_type: z20.string().nullable(),
-  headers: z20.array(WebHeader),
+  url: z21.string(),
+  content_type: z21.string().nullable(),
+  headers: z21.array(WebHeader),
   body: WebText,
-  truncated: z20.boolean(),
+  truncated: z21.boolean(),
   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 WebAttachTarget = z21.strictObject({
+  entity_type: z21.string().min(1).max(64),
+  entity_id: z21.string().min(1).max(128),
+  label: z21.string().max(200).optional()
 });
-var WebLand = z20.strictObject({
+var WebLand = z21.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([])
+  keep: z21.boolean().default(false),
+  attach_to: z21.array(WebAttachTarget).max(8).default([])
 });
-var WebNotSavedReason = z20.enum([
+var WebNotSavedReason = z21.enum([
   /** Nobody is signed in on this computer. Saved on sign-in. */
   "signed_out",
   /** AI Matrx could not be reached. Retried on its own. */
@@ -2003,249 +2085,249 @@ var WebNotSavedReason = z20.enum([
   /** 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),
+var WebSourceNotice = z21.strictObject({ code: z21.string().max(120), message: z21.string().max(2e3), remedy: z21.string().max(120) });
+var WebSourceState = z21.discriminatedUnion("state", [
+  z21.strictObject({
+    state: z21.literal("saved"),
+    processed_document_id: z21.string().min(1).max(64),
+    source_id: z21.string().min(1).max(128),
     /** The page was already saved and nothing changed ("Already saved, no change"). */
-    reused_existing: z20.boolean(),
+    reused_existing: z21.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"]),
+    new_version_of: z21.string().max(64).nullable(),
+    kept: z21.boolean(),
+    intelligence: z21.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(),
+    original_file_id: z21.string().max(128).nullable(),
     /** The organization it was saved in. */
     organization_id: OrgId,
-    notices: z20.array(WebSourceNotice).max(20)
+    notices: z21.array(WebSourceNotice).max(20)
   }),
-  z20.strictObject({
-    state: z20.literal("not_saved"),
-    outbox_id: z20.string().min(1).max(64),
+  z21.strictObject({
+    state: z21.literal("not_saved"),
+    outbox_id: z21.string().min(1).max(64),
     reason: WebNotSavedReason,
-    message: z20.string().max(2e3)
+    message: z21.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),
+var WebScrapeParams = z21.strictObject({
+  urls: z21.array(WebUrl).min(1).max(20),
+  use_cache: z21.boolean().default(true),
+  get_links: z21.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(),
+  engine: z21.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(),
-  ok: z20.boolean(),
-  status: z20.int().min(0).max(999).nullable(),
-  title: z20.string().nullable(),
+var WebScrapePage = z21.strictObject({
+  url: z21.string(),
+  ok: z21.boolean(),
+  status: z21.int().min(0).max(999).nullable(),
+  title: z21.string().nullable(),
   /** The page's readable content (markdown-like text from the scraper's parse). */
   text: WebText,
-  truncated: z20.boolean(),
+  truncated: z21.boolean(),
   /** Links found on the page (only with get_links). */
-  links: z20.array(z20.string()).max(2e3),
+  links: z21.array(z21.string()).max(2e3),
   /** Why the page failed (blocked, timeout, not found…), in the scraper's words; null when ok. */
-  error: z20.string().nullable(),
+  error: z21.string().nullable(),
   /** How the page was fetched (http, browser, cache). */
-  via: z20.string().nullable(),
+  via: z21.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({
-  keywords: z20.array(z20.string().min(1).max(400)).min(1).max(5),
-  country: z20.string().min(2).max(2).default("us"),
-  count: z20.int().min(1).max(20).default(10),
-  freshness: z20.enum(["pd", "pw", "pm", "py"]).optional()
-});
-var WebSearchHit = z20.strictObject({ title: z20.string(), url: z20.string(), description: z20.string() });
-var WebSearchQueryResult = z20.strictObject({ keyword: z20.string(), hits: z20.array(WebSearchHit), error: z20.string().nullable() });
-var WebSearchResult = z20.strictObject({ queries: z20.array(WebSearchQueryResult), elapsed_ms: nonNegInt });
-var ToolsWebSearchParams = z20.strictObject({
-  keywords: z20.array(z20.string().min(1).max(400)).min(1).max(5),
-  country: z20.string().min(2).max(2).default("us"),
-  count: z20.int().min(1).max(20).default(10),
-  freshness: z20.enum(["pd", "pw", "pm", "py"]).optional()
-});
-var WebBrowserFetchParams = z20.strictObject({
+var WebScrapeResult = z21.strictObject({ pages: z21.array(WebScrapePage), elapsed_ms: nonNegInt });
+var WebSearchParams = z21.strictObject({
+  keywords: z21.array(z21.string().min(1).max(400)).min(1).max(5),
+  country: z21.string().min(2).max(2).default("us"),
+  count: z21.int().min(1).max(20).default(10),
+  freshness: z21.enum(["pd", "pw", "pm", "py"]).optional()
+});
+var WebSearchHit = z21.strictObject({ title: z21.string(), url: z21.string(), description: z21.string() });
+var WebSearchQueryResult = z21.strictObject({ keyword: z21.string(), hits: z21.array(WebSearchHit), error: z21.string().nullable() });
+var WebSearchResult = z21.strictObject({ queries: z21.array(WebSearchQueryResult), elapsed_ms: nonNegInt });
+var ToolsWebSearchParams = z21.strictObject({
+  keywords: z21.array(z21.string().min(1).max(400)).min(1).max(5),
+  country: z21.string().min(2).max(2).default("us"),
+  count: z21.int().min(1).max(20).default(10),
+  freshness: z21.enum(["pd", "pw", "pm", "py"]).optional()
+});
+var WebBrowserFetchParams = z21.strictObject({
   url: WebUrl,
   /** A CSS selector to wait for before reading the page. */
-  wait_for: z20.string().max(1024).optional(),
-  wait_timeout_ms: z20.int().min(100).max(12e4).default(3e4),
+  wait_for: z21.string().max(1024).optional(),
+  wait_timeout_ms: z21.int().min(100).max(12e4).default(3e4),
   /** true: readable text; false: the rendered HTML. */
-  extract_text: z20.boolean().default(true),
+  extract_text: z21.boolean().default(true),
   /** Since 1.38: where the rendered page is saved (see WebLand). */
   land: WebLand.optional()
 });
-var WebBrowserFetchResult = z20.strictObject({
-  url: z20.string(),
-  status: z20.int().min(0).max(999).nullable(),
-  title: z20.string().nullable(),
+var WebBrowserFetchResult = z21.strictObject({
+  url: z21.string(),
+  status: z21.int().min(0).max(999).nullable(),
+  title: z21.string().nullable(),
   content: WebText,
-  truncated: z20.boolean(),
+  truncated: z21.boolean(),
   elapsed_ms: nonNegInt,
   /** Since 1.38: the rendered page's Source (absent from a 1.37 core). */
   source: WebSourceState.optional()
 });
-var ToolsParseFile = z20.strictObject({
+var ToolsParseFile = z21.strictObject({
   /** Absolute path of the gzipped JSON the core reads, saves and then removes. */
-  path: z20.string().min(1).max(4096),
+  path: z21.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),
+var ToolsWebScrapeParams = z21.strictObject({
+  urls: z21.array(WebUrl).min(1).max(20),
+  use_cache: z21.boolean().default(true),
+  get_links: z21.boolean().default(false),
   /** `browser`: render every page in this computer's browser, then parse it. */
-  engine: z20.enum(["auto", "browser"]).default("auto"),
+  engine: z21.enum(["auto", "browser"]).default("auto"),
   /** Pages read at once (desktop.web/scrape_concurrency). */
-  concurrency: z20.int().min(1).max(20).default(5),
+  concurrency: z21.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),
+  delay_ms: z21.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)
+  spool_dir: z21.string().min(1).max(4096)
 });
-var ToolsWebScrapePage = z20.strictObject({
+var ToolsWebScrapePage = z21.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({
+var ToolsWebScrapeResult = z21.strictObject({ pages: z21.array(ToolsWebScrapePage), elapsed_ms: nonNegInt });
+var ToolsWebBrowserFetchParams = z21.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({
+  wait_for: z21.string().max(1024).optional(),
+  wait_timeout_ms: z21.int().min(100).max(12e4).default(3e4),
+  extract_text: z21.boolean().default(true),
+  spool_dir: z21.string().min(1).max(4096)
+});
+var ToolsWebBrowserFetchResult = z21.strictObject({ result: WebBrowserFetchResult, parse: ToolsParseFile.nullable() });
+var WebRuntimeStateName = z21.enum(["not_installed", "installing", "installed", "failed"]);
+var WebRuntimeParams = z21.strictObject({});
+var WebRuntimeState = z21.strictObject({
   state: WebRuntimeStateName,
   /** Why it failed, in the installer's words; null otherwise. */
-  error: z20.string().max(2e3).nullable(),
+  error: z21.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()
+  can_show_window: z21.boolean()
 });
-var WebOutboxItem = z20.strictObject({
-  outbox_id: z20.string().min(1).max(64),
-  url: z20.string().max(8192),
-  title: z20.string().max(500).nullable(),
+var WebOutboxItem = z21.strictObject({
+  outbox_id: z21.string().min(1).max(64),
+  url: z21.string().max(8192),
+  title: z21.string().max(500).nullable(),
   organization_id: OrgId.nullable(),
   reason: WebNotSavedReason,
-  message: z20.string().max(2e3),
+  message: z21.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),
+var WebOutboxListParams = z21.strictObject({});
+var WebOutboxListResult = z21.strictObject({
+  items: z21.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),
+var WebOutboxRetryParams = z21.strictObject({ outbox_id: z21.string().min(1).max(64).optional() });
+var WebOutboxRetryResult = z21.strictObject({ saved: nonNegInt, waiting: nonNegInt });
+var WebOutboxDiscardParams = z21.strictObject({ outbox_id: z21.string().min(1).max(64) });
+var WebOutboxDiscardResult = z21.strictObject({ discarded: z21.boolean() });
+var WebLogVia = z21.enum(["this_computer", "browser", "server"]);
+var WebLogCaller = z21.enum(["person", "agent", "research", "phone", "other"]);
+var WebLogResult = z21.enum(["saved", "not_saved", "failed", "blocked", "read"]);
+var WebLogEntry = z21.strictObject({
+  id: z21.string().min(1).max(64),
   at_ms: nonNegInt,
   caller: WebLogCaller,
-  url: z20.string().max(8192),
-  title: z20.string().max(500).nullable(),
+  url: z21.string().max(8192),
+  title: z21.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(),
+  detail: z21.string().max(1e3).nullable(),
   via: WebLogVia,
   duration_ms: nonNegInt,
-  processed_document_id: z20.string().max(64).nullable()
+  processed_document_id: z21.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({
+var WebLogListParams = z21.strictObject({ since_ms: nonNegInt.optional(), limit: z21.int().min(1).max(1e3).default(200) });
+var WebLogListResult = z21.strictObject({ entries: z21.array(WebLogEntry) });
+var WebLogClearParams = z21.strictObject({});
+var WebLogClearResult = z21.strictObject({ cleared: nonNegInt });
+var WebProgressEvent = z21.strictObject({
   request_id: RequestId,
-  phase: z20.enum(["installing", "fetching", "saving"]),
+  phase: z21.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(),
+var WebResearchItemState = z21.enum(["waiting", "fetching", "saved", "thin", "failed", "cannot_edit", "blocked"]);
+var WebResearchItem = z21.strictObject({
+  topic_id: z21.string().min(1).max(64),
+  topic_name: z21.string().max(500),
+  source_id: z21.string().min(1).max(64),
+  url: z21.string().max(8192),
+  title: z21.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(),
+  level: z21.int().min(1).max(4),
+  last_failure: z21.string().max(1e3).nullable(),
   state: WebResearchItemState,
   /** One sentence after a fetch: what happened. */
-  message: z20.string().max(1e3).nullable()
+  message: z21.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(),
+var WebResearchQueueParams = z21.strictObject({ topic_id: z21.string().min(1).max(64).optional() });
+var WebResearchQueueResult = z21.strictObject({
+  state: z21.enum(["ready", "signed_out", "unavailable"]),
+  problem: z21.string().max(1e3).nullable(),
   /** L1/L2 items on topics this person can edit: what this computer can fetch. */
-  items: z20.array(WebResearchItem),
+  items: z21.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 WebResearchFetchParams = z21.strictObject({
+  topic_id: z21.string().min(1).max(64).optional(),
+  source_ids: z21.array(z21.string().min(1).max(64)).max(200).optional()
 });
-var WebResearchFetchResult = z20.strictObject({
-  items: z20.array(WebResearchItem),
+var WebResearchFetchResult = z21.strictObject({
+  items: z21.array(WebResearchItem),
   saved: nonNegInt,
   thin: nonNegInt,
   failed: nonNegInt,
   cannot_edit: nonNegInt
 });
-var ToolsServiceProgress = z20.strictObject({ phase: z20.enum(["fetching", "installing"]), done: nonNegInt, total: nonNegInt });
+var ToolsServiceProgress = z21.strictObject({ phase: z21.enum(["fetching", "installing"]), done: nonNegInt, total: nonNegInt });
 
 // src/schema/system.ts
-import { z as z21 } from "zod";
-var SystemOpenUrlParams = z21.strictObject({
+import { z as z22 } from "zod";
+var SystemOpenUrlParams = z22.strictObject({
   /** http, https or mailto; opened in the person's default app for it. */
-  url: z21.string().min(1).max(4096)
+  url: z22.string().min(1).max(4096)
 });
-var SystemOpenUrlResult = z21.strictObject({ url: z21.string().max(4096) });
-var SystemOpenPathParams = z21.strictObject({
+var SystemOpenUrlResult = z22.strictObject({ url: z22.string().max(4096) });
+var SystemOpenPathParams = z22.strictObject({
   path: AbsPath,
   /** Show it in the file manager (Finder, Explorer) instead of opening it. */
-  reveal: z21.boolean().default(false)
+  reveal: z22.boolean().default(false)
 });
-var SystemOpenPathResult = z21.strictObject({ path: AbsPath, revealed: z21.boolean() });
-var SystemNotifyParams = z21.strictObject({
-  title: z21.string().min(1).max(128),
-  body: z21.string().max(1024).default("")
+var SystemOpenPathResult = z22.strictObject({ path: AbsPath, revealed: z22.boolean() });
+var SystemNotifyParams = z22.strictObject({
+  title: z22.string().min(1).max(128),
+  body: z22.string().max(1024).default("")
 });
-var SystemNotifyResult = z21.strictObject({
+var SystemNotifyResult = z22.strictObject({
   /** False when this computer has no notification service to show it (a bare Linux box). */
-  shown: z21.boolean()
+  shown: z22.boolean()
 });
-var SystemSettingsPane = z21.enum([
+var SystemSettingsPane = z22.enum([
   "displays",
   "night_shift",
   "sound",
@@ -2280,99 +2362,99 @@ var SystemSettingsPane = z21.enum([
   "messages",
   "mail"
 ]);
-var SystemOpenSettingsParams = z21.strictObject({ pane: SystemSettingsPane });
-var SystemOpenSettingsResult = z21.strictObject({ pane: SystemSettingsPane });
+var SystemOpenSettingsParams = z22.strictObject({ pane: SystemSettingsPane });
+var SystemOpenSettingsResult = z22.strictObject({ pane: SystemSettingsPane });
 
 // src/schema/screen.ts
-import { z as z22 } from "zod";
-var ScreenDisplay = z22.strictObject({
+import { z as z23 } from "zod";
+var ScreenDisplay = z23.strictObject({
   /** The OS's display id; pass it to screen.capture. */
   id: nonNegInt,
-  name: z22.string().max(128),
+  name: z23.string().max(128),
   /** Position and size in the OS's logical points (x and y may be negative left of or above the main display). */
-  x: z22.int(),
-  y: z22.int(),
-  width: z22.int().min(1),
-  height: z22.int().min(1),
+  x: z23.int(),
+  y: z23.int(),
+  width: z23.int().min(1),
+  height: z23.int().min(1),
   /** Pixels per point (2 on a Retina display). */
-  scale: z22.number().min(0.1).max(8),
-  primary: z22.boolean(),
+  scale: z23.number().min(0.1).max(8),
+  primary: z23.boolean(),
   /** (1.24) Clockwise rotation in degrees (Displays' Rotation: 0 is Standard). */
-  rotation: z22.int().min(0).max(359).optional(),
+  rotation: z23.int().min(0).max(359).optional(),
   /** (1.24) Refresh rate in hertz; absent where the OS does not say. */
-  refresh_hz: z22.number().min(0).max(1e3).optional(),
+  refresh_hz: z23.number().min(0).max(1e3).optional(),
   /** (1.24) The computer's own screen (a laptop's), not one plugged in. */
-  builtin: z22.boolean().optional()
+  builtin: z23.boolean().optional()
 });
-var ScreenListParams = z22.strictObject({});
-var ScreenListResult = z22.strictObject({ displays: z22.array(ScreenDisplay).max(32) });
-var ScreenCaptureParams = z22.strictObject({
+var ScreenListParams = z23.strictObject({});
+var ScreenListResult = z23.strictObject({ displays: z23.array(ScreenDisplay).max(32) });
+var ScreenCaptureParams = z23.strictObject({
   /** The display (from screen.list); the primary display when absent. */
   display_id: nonNegInt.optional(),
-  format: z22.enum(["jpeg", "png"]).default("jpeg"),
+  format: z23.enum(["jpeg", "png"]).default("jpeg"),
   /** Scale the picture down to at most this width in pixels (kept when already smaller). */
-  max_width: z22.int().min(160).max(7680).default(1600)
+  max_width: z23.int().min(160).max(7680).default(1600)
 });
-var ScreenCaptureResult = z22.strictObject({
+var ScreenCaptureResult = z23.strictObject({
   display_id: nonNegInt,
-  mime_type: z22.enum(["image/jpeg", "image/png"]),
-  width: z22.int().min(1),
-  height: z22.int().min(1),
+  mime_type: z23.enum(["image/jpeg", "image/png"]),
+  width: z23.int().min(1),
+  height: z23.int().min(1),
   /** The display's full resolution in pixels, before scaling. */
-  source_width: z22.int().min(1),
-  source_height: z22.int().min(1),
+  source_width: z23.int().min(1),
+  source_height: z23.int().min(1),
   /** The image, base64 (at most 6 MiB of text). */
-  data_base64: z22.string().max(6291456)
+  data_base64: z23.string().max(6291456)
 });
 
 // src/schema/window.ts
-import { z as z23 } from "zod";
-var WindowInfo = z23.strictObject({
+import { z as z24 } from "zod";
+var WindowInfo = z24.strictObject({
   /** The OS's window handle (macOS window number, Windows HWND, X11 window id). */
   id: nonNegInt,
-  title: z23.string().max(512),
+  title: z24.string().max(512),
   /** Position and size in logical points. */
-  x: z23.int(),
-  y: z23.int(),
-  width: z23.int().min(0),
-  height: z23.int().min(0),
+  x: z24.int(),
+  y: z24.int(),
+  width: z24.int().min(0),
+  height: z24.int().min(0),
   /**
    * The application that owns the window, by the name the OS shows people; absent when the OS does
    * not say. Optional (never null, the schema rule) because it was added in protocol 1.7: an older
    * app's answer has no such field (FIELDS_SINCE).
    */
-  app: z23.string().max(256).optional(),
+  app: z24.string().max(256).optional(),
   /** The owning process id; absent when the OS does not say. Added in protocol 1.7. */
-  pid: z23.int().min(0).optional()
+  pid: z24.int().min(0).optional()
 });
-var WindowListParams = z23.strictObject({
+var WindowListParams = z24.strictObject({
   /** Case-insensitive substring of the window title. */
-  title: z23.string().min(1).max(256).optional(),
-  limit: z23.int().min(1).max(500).default(100)
+  title: z24.string().min(1).max(256).optional(),
+  limit: z24.int().min(1).max(500).default(100)
 });
-var WindowListResult = z23.strictObject({
-  windows: z23.array(WindowInfo).max(500),
+var WindowListResult = z24.strictObject({
+  windows: z24.array(WindowInfo).max(500),
   total: nonNegInt,
-  truncated: z23.boolean()
+  truncated: z24.boolean()
 });
-var WindowFocusParams = z23.strictObject({ id: nonNegInt });
-var WindowFocusResult = z23.strictObject({ window: WindowInfo });
-var WindowMoveParams = z23.strictObject({
+var WindowFocusParams = z24.strictObject({ id: nonNegInt });
+var WindowFocusResult = z24.strictObject({ window: WindowInfo });
+var WindowMoveParams = z24.strictObject({
   id: nonNegInt,
   /** New top-left corner; unchanged when absent. */
-  x: z23.int().optional(),
-  y: z23.int().optional(),
+  x: z24.int().optional(),
+  y: z24.int().optional(),
   /** New size; unchanged when absent. */
-  width: z23.int().min(50).max(16384).optional(),
-  height: z23.int().min(50).max(16384).optional()
+  width: z24.int().min(50).max(16384).optional(),
+  height: z24.int().min(50).max(16384).optional()
 });
-var WindowMoveResult = z23.strictObject({ window: WindowInfo });
-var WindowMinimizeParams = z23.strictObject({ id: nonNegInt });
-var WindowMinimizeResult = z23.strictObject({ id: nonNegInt });
+var WindowMoveResult = z24.strictObject({ window: WindowInfo });
+var WindowMinimizeParams = z24.strictObject({ id: nonNegInt });
+var WindowMinimizeResult = z24.strictObject({ id: nonNegInt });
 
 // src/schema/input.ts
-import { z as z24 } from "zod";
-var InputKey = z24.enum([
+import { z as z25 } from "zod";
+var InputKey = z25.enum([
   "cmd",
   "ctrl",
   "alt",
@@ -2452,80 +2534,80 @@ var InputKey = z24.enum([
   "backslash",
   "grave"
 ]);
-var InputTypeTextParams = z24.strictObject({ text: z24.string().min(1).max(1e4) });
-var InputTypeTextResult = z24.strictObject({ characters: z24.int().min(1) });
-var InputHotkeyParams = z24.strictObject({
+var InputTypeTextParams = z25.strictObject({ text: z25.string().min(1).max(1e4) });
+var InputTypeTextResult = z25.strictObject({ characters: z25.int().min(1) });
+var InputHotkeyParams = z25.strictObject({
   /** Pressed together in order and released in reverse: ["cmd", "shift", "t"]. */
-  keys: z24.array(InputKey).min(1).max(6)
+  keys: z25.array(InputKey).min(1).max(6)
 });
-var InputHotkeyResult = z24.strictObject({ keys: z24.array(InputKey) });
-var InputPoint = z24.strictObject({ x: z24.int(), y: z24.int() });
-var InputMouseMoveParams = z24.strictObject({
+var InputHotkeyResult = z25.strictObject({ keys: z25.array(InputKey) });
+var InputPoint = z25.strictObject({ x: z25.int(), y: z25.int() });
+var InputMouseMoveParams = z25.strictObject({
   /** Screen position in logical points (the coordinates screen.list and window.list report). */
-  x: z24.int(),
-  y: z24.int()
+  x: z25.int(),
+  y: z25.int()
 });
-var InputMouseMoveResult = z24.strictObject({
+var InputMouseMoveResult = z25.strictObject({
   /** Where the pointer is now, read back from the OS. */
   position: InputPoint
 });
-var InputMouseClickParams = z24.strictObject({
+var InputMouseClickParams = z25.strictObject({
   /** Move here first; clicks where the pointer is when absent. */
-  x: z24.int().optional(),
-  y: z24.int().optional(),
-  button: z24.enum(["left", "right", "middle"]).default("left"),
-  double: z24.boolean().default(false)
+  x: z25.int().optional(),
+  y: z25.int().optional(),
+  button: z25.enum(["left", "right", "middle"]).default("left"),
+  double: z25.boolean().default(false)
 });
-var InputMouseClickResult = z24.strictObject({
+var InputMouseClickResult = z25.strictObject({
   position: InputPoint,
-  button: z24.enum(["left", "right", "middle"]),
-  double: z24.boolean()
+  button: z25.enum(["left", "right", "middle"]),
+  double: z25.boolean()
 });
-var InputKeyboardSettingsParams = z24.strictObject({});
-var InputKeyboardSettingsResult = z24.strictObject({
+var InputKeyboardSettingsParams = z25.strictObject({});
+var InputKeyboardSettingsResult = z25.strictObject({
   /** Key repeat is off (a held key types once). */
-  repeat_off: z24.boolean().nullable(),
+  repeat_off: z25.boolean().nullable(),
   /** Time between repeats while a key is held (Key repeat rate: shorter is faster). */
   repeat_interval_ms: nonNegInt.nullable(),
   /** Time a key is held before it starts repeating (Delay until repeat). */
   repeat_delay_ms: nonNegInt.nullable(),
   /** What the fn / globe key does alone. */
-  fn_key: z24.enum(["nothing", "input_source", "emoji", "dictation"]).nullable(),
+  fn_key: z25.enum(["nothing", "input_source", "emoji", "dictation"]).nullable(),
   /** Tab moves focus between every control. */
-  keyboard_navigation: z24.boolean().nullable(),
+  keyboard_navigation: z25.boolean().nullable(),
   /** The enabled input sources by name ("U.S.", "ABC – Extended"). */
-  input_sources: z24.array(z24.string().max(128)).max(64),
+  input_sources: z25.array(z25.string().max(128)).max(64),
   /** A key repeat change takes effect only after the person logs out and in again (macOS). */
-  applies_after_login: z24.boolean()
+  applies_after_login: z25.boolean()
 });
-var InputSetKeyboardSettingsParams = z24.strictObject({
-  repeat_off: z24.boolean().optional(),
-  repeat_interval_ms: z24.int().min(15).max(2e3).optional(),
-  repeat_delay_ms: z24.int().min(150).max(2e3).optional(),
-  keyboard_navigation: z24.boolean().optional()
+var InputSetKeyboardSettingsParams = z25.strictObject({
+  repeat_off: z25.boolean().optional(),
+  repeat_interval_ms: z25.int().min(15).max(2e3).optional(),
+  repeat_delay_ms: z25.int().min(150).max(2e3).optional(),
+  keyboard_navigation: z25.boolean().optional()
 });
 
 // src/schema/power.ts
-import { z as z25 } from "zod";
-var PowerEnergy = z25.strictObject({
+import { z as z26 } from "zod";
+var PowerEnergy = z26.strictObject({
   display_sleep_minutes: nonNegInt.nullable(),
   /** The computer itself sleeps after this long idle; null = never (Prevent automatic sleeping). */
   sleep_minutes: nonNegInt.nullable(),
   /** Hard disks sleep after this long; null = never. */
   disk_sleep_minutes: nonNegInt.nullable(),
-  wake_for_network: z25.boolean().nullable(),
-  restart_after_power_failure: z25.boolean().nullable(),
+  wake_for_network: z26.boolean().nullable(),
+  restart_after_power_failure: z26.boolean().nullable(),
   /** Low Power Mode (Energy Mode "Low Power"). */
-  low_power_mode: z25.boolean().nullable()
+  low_power_mode: z26.boolean().nullable()
 });
-var PowerStatusParams = z25.strictObject({});
-var PowerStatusResult = z25.strictObject({
-  has_battery: z25.boolean(),
+var PowerStatusParams = z26.strictObject({});
+var PowerStatusResult = z26.strictObject({
+  has_battery: z26.boolean(),
   /** 0–100; null without a battery. */
-  percent: z25.number().min(0).max(100).nullable(),
-  charging: z25.boolean().nullable(),
+  percent: z26.number().min(0).max(100).nullable(),
+  charging: z26.boolean().nullable(),
   /** On wall power; null where the OS does not say. */
-  plugged_in: z25.boolean().nullable(),
+  plugged_in: z26.boolean().nullable(),
   /** Minutes of battery left; null when charging, unknown or without a battery. */
   minutes_left: nonNegInt.nullable(),
   /** Matrx 2 is keeping the computer awake (power.prevent_sleep) until this time; null when it is not. */
@@ -2533,26 +2615,26 @@ var PowerStatusResult = z25.strictObject({
   /** (1.24) The OS's own energy settings; absent where it keeps none Matrx 2 can read. */
   energy: PowerEnergy.optional()
 });
-var PowerHistoryParams = z25.strictObject({});
-var PowerHistoryPoint = z25.strictObject({ at_ms: epochMs, percent: z25.number().min(0).max(100), plugged_in: z25.boolean() });
-var PowerHistoryResult = z25.strictObject({
+var PowerHistoryParams = z26.strictObject({});
+var PowerHistoryPoint = z26.strictObject({ at_ms: epochMs, percent: z26.number().min(0).max(100), plugged_in: z26.boolean() });
+var PowerHistoryResult = z26.strictObject({
   /** Oldest first; empty without a battery or where the OS keeps no log. */
-  points: z25.array(PowerHistoryPoint).max(5e3)
+  points: z26.array(PowerHistoryPoint).max(5e3)
 });
-var PowerPreventSleepParams = z25.strictObject({
+var PowerPreventSleepParams = z26.strictObject({
   /** Keep the computer awake this long; 0 lets it sleep again now. */
-  seconds: z25.int().min(0).max(86400),
+  seconds: z26.int().min(0).max(86400),
   /** Shown where the OS lists what keeps it awake. */
-  reason: z25.string().min(1).max(128).default("Matrx 2 is working")
+  reason: z26.string().min(1).max(128).default("Matrx 2 is working")
 });
-var PowerPreventSleepResult = z25.strictObject({
+var PowerPreventSleepResult = z26.strictObject({
   /** When it may sleep again; null after seconds 0. */
   awake_until_ms: epochMs.nullable()
 });
 
 // src/schema/diag.ts
-import { z as z26 } from "zod";
-var DiagProcess = z26.enum([
+import { z as z27 } from "zod";
+var DiagProcess = z27.enum([
   "main",
   "renderer",
   "hosted_page",
@@ -2565,7 +2647,7 @@ var DiagProcess = z26.enum([
   "coding_sessions",
   "claude_accounts"
 ]);
-var DiagErrorKind = z26.enum([
+var DiagErrorKind = z27.enum([
   "uncaught_exception",
   "unhandled_rejection",
   "renderer_crash",
@@ -2577,148 +2659,148 @@ var DiagErrorKind = z26.enum([
   "banner",
   "logged_error"
 ]);
-var DiagErrorStatus = z26.enum(["waiting", "sent", "resolved"]);
-var DiagErrorEntry = z26.strictObject({
+var DiagErrorStatus = z27.enum(["waiting", "sent", "resolved"]);
+var DiagErrorEntry = z27.strictObject({
   /** sha256 prefix over process, kind, source, code and the normalized message. */
-  signature: z26.string().regex(/^[0-9a-f]{32}$/),
+  signature: z27.string().regex(/^[0-9a-f]{32}$/),
   process: DiagProcess,
   kind: DiagErrorKind,
   /** Where: a cap.op, a log event, a screen or page name. */
-  source: z26.string().min(1).max(128),
+  source: z27.string().min(1).max(128),
   /** An ErrorCode, an exit code or signal, an error class; null when there is none. */
-  code: z26.string().max(64).nullable(),
+  code: z27.string().max(64).nullable(),
   /** The first occurrence's message, personal data removed. */
-  message: z26.string().max(500),
+  message: z27.string().max(500),
   count: nonNegInt,
   first_seen_ms: epochMs,
   last_seen_ms: epochMs,
   status: DiagErrorStatus,
   /** What the agent who resolved it wrote; null until resolved. */
-  resolution_note: z26.string().max(500).nullable(),
-  app_version: z26.string().max(64)
+  resolution_note: z27.string().max(500).nullable(),
+  app_version: z27.string().max(64)
 });
-var DiagErrorsListParams = z26.strictObject({
+var DiagErrorsListParams = z27.strictObject({
   /** open = waiting or sent; all includes resolved. */
-  status: z26.enum(["open", "all"]).default("open"),
-  limit: z26.int().min(1).max(500).default(200)
+  status: z27.enum(["open", "all"]).default("open"),
+  limit: z27.int().min(1).max(500).default(200)
 });
-var DiagErrorsListResult = z26.strictObject({
+var DiagErrorsListResult = z27.strictObject({
   /** Newest last_seen first. */
-  entries: z26.array(DiagErrorEntry).max(500),
+  entries: z27.array(DiagErrorEntry).max(500),
   total_signatures: nonNegInt,
   total_occurrences: nonNegInt,
   /** Signatures with occurrences not yet delivered. */
   waiting: nonNegInt,
   /** signed_out = kept until sign-in; ok = the last delivery worked; failing = the last delivery failed (kept, retried). */
-  delivery: z26.enum(["signed_out", "ok", "failing"]),
+  delivery: z27.enum(["signed_out", "ok", "failing"]),
   last_delivery_ms: epochMs.nullable()
 });
-var DiagErrorsReportParams = z26.strictObject({
-  process: z26.enum(["renderer", "hosted_page"]),
-  kind: z26.enum(["uncaught_exception", "unhandled_rejection", "console_error", "banner"]),
+var DiagErrorsReportParams = z27.strictObject({
+  process: z27.enum(["renderer", "hosted_page"]),
+  kind: z27.enum(["uncaught_exception", "unhandled_rejection", "console_error", "banner"]),
   /** The screen or page, e.g. "code.chats". */
-  source: z26.string().min(1).max(128),
-  message: z26.string().min(1).max(2e3),
-  code: z26.string().max(64).optional(),
-  stack: z26.string().max(8e3).optional()
+  source: z27.string().min(1).max(128),
+  message: z27.string().min(1).max(2e3),
+  code: z27.string().max(64).optional(),
+  stack: z27.string().max(8e3).optional()
 });
-var DiagErrorsReportResult = z26.strictObject({
-  signature: z26.string().regex(/^[0-9a-f]{32}$/)
+var DiagErrorsReportResult = z27.strictObject({
+  signature: z27.string().regex(/^[0-9a-f]{32}$/)
 });
-var DiagErrorsChangedEvent = z26.strictObject({
+var DiagErrorsChangedEvent = z27.strictObject({
   total_signatures: nonNegInt,
   waiting: nonNegInt
 });
 
 // src/schema/resources.ts
-import { z as z27 } from "zod";
-var ResourcesDisk = z27.strictObject({
+import { z as z28 } from "zod";
+var ResourcesDisk = z28.strictObject({
   /** Where it is mounted ("/", "C:"). */
-  mount: z27.string().max(512),
+  mount: z28.string().max(512),
   /** The volume's name as the file manager shows it ("Macintosh HD", "Local Disk (C:)"). Since 1.17. */
-  name: z27.string().max(256).optional(),
+  name: z28.string().max(256).optional(),
   /** The file system ("apfs", "NTFS", "ext4"). */
-  fs: z27.string().max(64),
+  fs: z28.string().max(64),
   size_bytes: nonNegInt,
   used_bytes: nonNegInt,
   available_bytes: nonNegInt
 });
-var ResourcesSnapshotParams = z27.strictObject({});
-var ResourcesSnapshotResult = z27.strictObject({
-  cpu: z27.strictObject({
+var ResourcesSnapshotParams = z28.strictObject({});
+var ResourcesSnapshotResult = z28.strictObject({
+  cpu: z28.strictObject({
     /** Busy share of all cores, 0–100, measured now. */
-    percent: z27.number().min(0).max(100),
-    cores: z27.int().min(1),
+    percent: z28.number().min(0).max(100),
+    cores: z28.int().min(1),
     /** 1, 5 and 15 minute load averages; null on Windows. */
-    load: z27.array(z27.number().min(0)).length(3).nullable()
+    load: z28.array(z28.number().min(0)).length(3).nullable()
   }),
-  memory: z27.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
-  swap: z27.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
-  disks: z27.array(ResourcesDisk).max(64),
+  memory: z28.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: z28.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: z28.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
-var ResourcesJobKind = z27.enum(["type-check", "tests", "build", "lint", "dev server", "language server", "search"]);
-var ResourcesStrain = z27.enum(["good", "strain", "overloaded"]);
-var ResourcesPressure = z27.enum(["normal", "warning", "critical"]);
-var ResourcesJob = z27.strictObject({
+var ResourcesJobKind = z28.enum(["type-check", "tests", "build", "lint", "dev server", "language server", "search"]);
+var ResourcesStrain = z28.enum(["good", "strain", "overloaded"]);
+var ResourcesPressure = z28.enum(["normal", "warning", "critical"]);
+var ResourcesJob = z28.strictObject({
   /** The job's root process (Stop takes its whole tree). */
-  pid: z27.int().min(0),
+  pid: z28.int().min(0),
   kind: ResourcesJobKind,
   /** Its heaviest process's command line, shortened ("…/lib/tsc --noEmit -p tsconfig.json"). */
-  command: z27.string().max(256),
+  command: z28.string().max(256),
   /** Who started it: "Claude Code", "Codex", "Cursor", "VS Code", "Terminal", "local stack", "detached"; null when unknown. */
-  started_by: z27.string().max(64).nullable(),
+  started_by: z28.string().max(64).nullable(),
   /** Whatever started it is gone and nothing waits for it. */
-  orphan: z27.boolean(),
+  orphan: z28.boolean(),
   /** A type-check queued for its turn (no compiler running yet). */
-  waiting: z27.boolean(),
+  waiting: z28.boolean(),
   /** The project folder it runs in ("matrx-frontend"); null when not in one. */
-  folder: z27.string().max(256).nullable(),
+  folder: z28.string().max(256).nullable(),
   /** The same command in the same folder, running this many times (1 = no duplicate). */
-  duplicates: z27.int().min(1),
-  processes: z27.int().min(1),
+  duplicates: z28.int().min(1),
+  processes: z28.int().min(1),
   /** Sum over the tree, as `ps` reports it: 100 = one full core. */
-  cpu_percent: z27.number().min(0),
+  cpu_percent: z28.number().min(0),
   /** Real memory (macOS: the physical footprint Activity Monitor shows, compressed included). */
   memory_bytes: nonNegInt,
   started_at_ms: epochMs.nullable(),
   /** False for an app, an agent session, a terminal, a system process, the local stack or Matrx 2 itself. */
-  stoppable: z27.boolean()
+  stoppable: z28.boolean()
 });
-var ResourcesProcess = z27.strictObject({
-  pid: z27.int().min(0),
+var ResourcesProcess = z28.strictObject({
+  pid: z28.int().min(0),
   /** The command line, shortened. */
-  name: z27.string().max(256),
-  cpu_percent: z27.number().min(0),
+  name: z28.string().max(256),
+  cpu_percent: z28.number().min(0),
   memory_bytes: nonNegInt,
-  started_by: z27.string().max(64).nullable(),
+  started_by: z28.string().max(64).nullable(),
   /** The job it belongs to ("type-check in aidream"); null when none. */
-  job: z27.string().max(256).nullable(),
+  job: z28.string().max(256).nullable(),
   started_at_ms: epochMs.nullable()
 });
-var ResourcesVerdict = z27.strictObject({
+var ResourcesVerdict = z28.strictObject({
   level: ResourcesStrain,
   /** One sentence ("Your Mac is under strain. 3 type-checks are running at once."). */
-  text: z27.string().max(256),
+  text: z28.string().max(256),
   /** The biggest jobs behind it; null when all is well. */
-  cause: z27.string().max(1024).nullable()
+  cause: z28.string().max(1024).nullable()
 });
-var ResourcesSample = z27.strictObject({
+var ResourcesSample = z28.strictObject({
   at_ms: epochMs,
   /** The 1-minute load average. */
-  load: z27.number().min(0),
+  load: z28.number().min(0),
   memory_used_bytes: nonNegInt,
   typechecks: nonNegInt
 });
-var ResourcesActivityParams = z27.strictObject({});
-var ResourcesActivityResult = z27.strictObject({
+var ResourcesActivityParams = z28.strictObject({});
+var ResourcesActivityResult = z28.strictObject({
   /** False until the first reading (a second or two after start). */
-  ready: z27.boolean(),
+  ready: z28.boolean(),
   sampled_at_ms: epochMs.nullable(),
-  cores: z27.int().min(1),
+  cores: z28.int().min(1),
   /** 1, 5 and 15 minute load averages. */
-  load: z27.array(z27.number().min(0)).length(3),
-  memory: z27.strictObject({
+  load: z28.array(z28.number().min(0)).length(3),
+  memory: z28.strictObject({
     total_bytes: nonNegInt,
     /** Activity Monitor's Memory Used: app memory + wired + compressed. */
     used_bytes: nonNegInt,
@@ -2729,269 +2811,269 @@ var ResourcesActivityResult = z27.strictObject({
     pressure: ResourcesPressure.nullable()
   }),
   verdict: ResourcesVerdict,
-  typechecks: z27.strictObject({ running: nonNegInt, waiting: nonNegInt, comfort: nonNegInt }),
+  typechecks: z28.strictObject({ running: nonNegInt, waiting: nonNegInt, comfort: nonNegInt }),
   /** Heaviest first (1 GB weighs as much as 16 % of a core). */
-  jobs: z27.array(ResourcesJob).max(200),
+  jobs: z28.array(ResourcesJob).max(200),
   /** The 15 heaviest by memory and the 15 busiest by CPU, together. */
-  top: z27.array(ResourcesProcess).max(30),
+  top: z28.array(ResourcesProcess).max(30),
   /** The last hour, oldest first. */
-  history: z27.array(ResourcesSample).max(1200)
+  history: z28.array(ResourcesSample).max(1200)
 });
-var ResourcesStopJobParams = z27.strictObject({ pid: z27.int().min(1) });
-var ResourcesStopJobResult = z27.strictObject({
+var ResourcesStopJobParams = z28.strictObject({ pid: z28.int().min(1) });
+var ResourcesStopJobResult = z28.strictObject({
   /** Processes signalled; whatever is still running 5 seconds later is force-stopped. */
   processes: nonNegInt,
   /** It had finished before the request arrived. */
-  already_finished: z27.boolean()
+  already_finished: z28.boolean()
 });
-var ResourcesIncident = z27.strictObject({
+var ResourcesIncident = z28.strictObject({
   at_ms: epochMs,
   verdict: ResourcesVerdict,
-  load: z27.number().min(0),
+  load: z28.number().min(0),
   memory_used_bytes: nonNegInt,
   compressed_bytes: nonNegInt,
   pressure: ResourcesPressure.nullable(),
-  jobs: z27.array(
-    z27.strictObject({
+  jobs: z28.array(
+    z28.strictObject({
       kind: ResourcesJobKind,
-      started_by: z27.string().max(64).nullable(),
-      folder: z27.string().max(256).nullable(),
-      command: z27.string().max(256),
-      cpu_percent: z27.number().min(0),
+      started_by: z28.string().max(64).nullable(),
+      folder: z28.string().max(256).nullable(),
+      command: z28.string().max(256),
+      cpu_percent: z28.number().min(0),
       memory_bytes: nonNegInt,
-      duplicates: z27.int().min(1)
+      duplicates: z28.int().min(1)
     })
   ).max(8)
 });
-var ResourcesIncidentsParams = z27.strictObject({ limit: z27.int().min(1).max(200).default(50) });
-var ResourcesIncidentsResult = z27.strictObject({
+var ResourcesIncidentsParams = z28.strictObject({ limit: z28.int().min(1).max(200).default(50) });
+var ResourcesIncidentsResult = z28.strictObject({
   /** Newest first; at most one a minute is written. */
-  incidents: z27.array(ResourcesIncident).max(200)
+  incidents: z28.array(ResourcesIncident).max(200)
 });
 
 // src/schema/stack.ts
-import { z as z28 } from "zod";
-var StackServerName = z28.string().regex(/^[a-z0-9_-]{1,64}$/);
-var StackTone = z28.enum(["good", "wait", "bad", "off"]);
-var StackServer = z28.strictObject({
+import { z as z29 } from "zod";
+var StackServerName = z29.string().regex(/^[a-z0-9_-]{1,64}$/);
+var StackTone = z29.enum(["good", "wait", "bad", "off"]);
+var StackServer = z29.strictObject({
   name: StackServerName,
   /** One word: Healthy, Starting, Unhealthy, Restarting, Stopping, Waiting, Stopped, Crashed, Off. */
-  label: z28.string().max(32),
+  label: z29.string().max(32),
   tone: StackTone,
   /** What is going on, in one or two plain sentences. */
-  sentence: z28.string().max(2e3),
+  sentence: z29.string().max(2e3),
   /** The config's own description of the server. */
-  description: z28.string().max(512),
+  description: z29.string().max(512),
   /** Where the server answers, when its description names an address. */
-  open_url: z28.string().max(2048).nullable(),
-  log_file: z28.string().max(4096),
+  open_url: z29.string().max(2048).nullable(),
+  log_file: z29.string().max(4096),
   /** When its log file was last written. */
   last_output_at_ms: epochMs.nullable(),
   started_at_ms: epochMs.nullable(),
   restarts: nonNegInt,
-  exit_code: z28.int().nullable(),
-  pid: z28.int().nullable(),
+  exit_code: z29.int().nullable(),
+  pid: z29.int().nullable(),
   /** (1.18) CPU of the server's process and everything under it, in percent of one core; absent when it is not running. */
-  cpu_percent: z28.number().min(0).optional(),
+  cpu_percent: z29.number().min(0).optional(),
   /** (1.18) Memory of the same processes: the physical footprint (Activity Monitor's Memory) summed; absent when it is not running. */
   memory_bytes: nonNegInt.optional()
 });
-var StackEvent = z28.strictObject({
+var StackEvent = z29.strictObject({
   at_ms: epochMs,
   /** A server name, or "stack" for the stack as a whole. */
-  server: z28.string().max(64),
+  server: z29.string().max(64),
   /** started · stopped · healthy · unhealthy · crashed · exited · restarting · stopping · action · action-done · action-failed · setup · error */
-  kind: z28.string().max(32),
-  text: z28.string().max(4e3)
+  kind: z29.string().max(32),
+  text: z29.string().max(4e3)
 });
-var StackStateParams = z28.strictObject({});
-var StackStateResult = z28.strictObject({
+var StackStateParams = z29.strictObject({});
+var StackStateResult = z29.strictObject({
   /** The stack's config file, when found. */
-  config_path: z28.string().max(4096).nullable(),
+  config_path: z29.string().max(4096).nullable(),
   /** Why the stack cannot be run from here (no config, no process-compose), else null. */
-  problem: z28.string().max(1e3).nullable(),
-  stack_up: z28.boolean(),
+  problem: z29.string().max(1e3).nullable(),
+  stack_up: z29.boolean(),
   stack_started_at_ms: epochMs.nullable(),
-  servers: z28.array(StackServer).max(64),
+  servers: z29.array(StackServer).max(64),
   /** One line about the one-shot setup steps ("Docker Desktop: running."), or null. */
-  setup_note: z28.string().max(500).nullable(),
+  setup_note: z29.string().max(500).nullable(),
   /** Start everything / Stop everything in flight. */
-  pending: z28.strictObject({ verb: z28.enum(["start", "stop"]), label: z28.string().max(64), since_ms: epochMs }).nullable(),
+  pending: z29.strictObject({ verb: z29.enum(["start", "stop"]), label: z29.string().max(64), since_ms: epochMs }).nullable(),
   /** The newest entries last. */
-  events: z28.array(StackEvent).max(300)
+  events: z29.array(StackEvent).max(300)
 });
-var StackStartParams = z28.strictObject({});
-var StackStopParams = z28.strictObject({});
-var StackRunResult = z28.strictObject({ accepted: z28.boolean() });
-var StackServerActionParams = z28.strictObject({
+var StackStartParams = z29.strictObject({});
+var StackStopParams = z29.strictObject({});
+var StackRunResult = z29.strictObject({ accepted: z29.boolean() });
+var StackServerActionParams = z29.strictObject({
   name: StackServerName,
-  verb: z28.enum(["start", "stop", "restart"])
+  verb: z29.enum(["start", "stop", "restart"])
 });
-var StackServerActionResult = z28.strictObject({ message: z28.string().max(1e3) });
-var StackLogsParams = z28.strictObject({
+var StackServerActionResult = z29.strictObject({ message: z29.string().max(1e3) });
+var StackLogsParams = z29.strictObject({
   name: StackServerName,
   /** Without `offset`: the last this-many complete lines. With it: new lines after it, at most this many. */
-  lines: z28.int().min(1).max(2e5).default(2e3),
+  lines: z29.int().min(1).max(2e5).default(2e3),
   /** Byte offset the last read ended at: answer only what was written after it (follow). */
   offset: nonNegInt.optional(),
   /** A "Clear" point: the lines written after this byte offset (no `offset`). */
   since: nonNegInt.optional(),
   /** With `offset`: wait up to this long for a new line when none is waiting (0 answers at once). */
-  wait_ms: z28.int().min(0).max(25e3).default(0)
+  wait_ms: z29.int().min(0).max(25e3).default(0)
 });
-var StackLogsResult = z28.strictObject({
+var StackLogsResult = z29.strictObject({
   /** Complete lines, colour codes removed. */
-  lines: z28.array(z28.string().max(65536)).max(2e5),
+  lines: z29.array(z29.string().max(65536)).max(2e5),
   /** Where these lines end: pass it back as `offset` to follow. */
   offset: nonNegInt,
   /** False when `since` no longer exists (the log rotated): the lines are the plain tail instead. */
-  since_valid: z28.boolean(),
+  since_valid: z29.boolean(),
   /** The log was rotated or truncated since `offset`: these lines start the file again. */
-  reset: z28.boolean(),
-  log_file: z28.string().max(4096)
+  reset: z29.boolean(),
+  log_file: z29.string().max(4096)
 });
-var StackErrorsParams = z28.strictObject({
-  window_minutes: z28.int().min(1).max(1440).default(60)
+var StackErrorsParams = z29.strictObject({
+  window_minutes: z29.int().min(1).max(1440).default(60)
 });
-var StackErrorsResult = z28.strictObject({
+var StackErrorsResult = z29.strictObject({
   /** Per server: a heading line ("=== aidream — errors in the last 60 minutes (<file>) ===") and each error with the 10 lines after it. */
-  sections: z28.array(z28.strictObject({ name: StackServerName, heading: z28.string().max(4096), lines: z28.array(z28.string().max(65536)).max(5e3) })).max(64),
-  window_minutes: z28.int().min(1).max(1440)
+  sections: z29.array(z29.strictObject({ name: StackServerName, heading: z29.string().max(4096), lines: z29.array(z29.string().max(65536)).max(5e3) })).max(64),
+  window_minutes: z29.int().min(1).max(1440)
 });
 
 // src/schema/audio.ts
-import { z as z29 } from "zod";
-var AudioDevice = z29.strictObject({
+import { z as z30 } from "zod";
+var AudioDevice = z30.strictObject({
   /** The OS's name for it, as audio.record takes it. */
-  id: z29.string().min(1).max(256),
-  name: z29.string().max(256),
-  default: z29.boolean(),
+  id: z30.string().min(1).max(256),
+  name: z30.string().max(256),
+  default: z30.boolean(),
   /** (1.24) How it is connected, as Sound's Type column says it: "Built-in", "USB", "Bluetooth",
    *  "DisplayPort", "HDMI", "AirPlay", "Virtual". Absent where the OS does not say. */
-  kind: z29.string().max(64).optional()
+  kind: z30.string().max(64).optional()
 });
-var AudioDevicesParams = z29.strictObject({});
-var AudioDevicesResult = z29.strictObject({
-  inputs: z29.array(AudioDevice).max(64),
-  outputs: z29.array(AudioDevice).max(64)
+var AudioDevicesParams = z30.strictObject({});
+var AudioDevicesResult = z30.strictObject({
+  inputs: z30.array(AudioDevice).max(64),
+  outputs: z30.array(AudioDevice).max(64)
 });
-var AudioRecordParams = z29.strictObject({
-  seconds: z29.number().min(0.5).max(600),
+var AudioRecordParams = z30.strictObject({
+  seconds: z30.number().min(0.5).max(600),
   /** The microphone (from audio.devices); the default input when absent. */
-  device_id: z29.string().min(1).max(256).optional(),
+  device_id: z30.string().min(1).max(256).optional(),
   /** Where the WAV file goes; a new file in the temp folder when absent. */
   path: AbsPath.optional()
 });
-var AudioRecordResult = z29.strictObject({
+var AudioRecordResult = z30.strictObject({
   path: AbsPath,
-  seconds: z29.number().min(0),
+  seconds: z30.number().min(0),
   bytes: nonNegInt,
   /** Loudest sample, 0–1: 0 means the device gave silence. */
-  peak: z29.number().min(0).max(1)
-});
-var AudioPlayParams = z29.strictObject({ path: AbsPath });
-var AudioPlayResult = z29.strictObject({ path: AbsPath, seconds: z29.number().min(0) });
-var AudioLevelsParams = z29.strictObject({});
-var AudioLevelsResult = z29.strictObject({
-  output_volume: z29.number().min(0).max(100).nullable(),
-  output_muted: z29.boolean().nullable(),
-  input_volume: z29.number().min(0).max(100).nullable(),
+  peak: z30.number().min(0).max(1)
+});
+var AudioPlayParams = z30.strictObject({ path: AbsPath });
+var AudioPlayResult = z30.strictObject({ path: AbsPath, seconds: z30.number().min(0) });
+var AudioLevelsParams = z30.strictObject({});
+var AudioLevelsResult = z30.strictObject({
+  output_volume: z30.number().min(0).max(100).nullable(),
+  output_muted: z30.boolean().nullable(),
+  input_volume: z30.number().min(0).max(100).nullable(),
   /** The alert (beep) volume, a share of the output volume. */
-  alert_volume: z29.number().min(0).max(100).nullable()
+  alert_volume: z30.number().min(0).max(100).nullable()
 });
-var AudioSetLevelsParams = z29.strictObject({
-  output_volume: z29.number().min(0).max(100).optional(),
-  output_muted: z29.boolean().optional(),
-  input_volume: z29.number().min(0).max(100).optional(),
-  alert_volume: z29.number().min(0).max(100).optional()
+var AudioSetLevelsParams = z30.strictObject({
+  output_volume: z30.number().min(0).max(100).optional(),
+  output_muted: z30.boolean().optional(),
+  input_volume: z30.number().min(0).max(100).optional(),
+  alert_volume: z30.number().min(0).max(100).optional()
 });
 
 // src/schema/fs-watch.ts
-import { z as z30 } from "zod";
-var FsWatchId = z30.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = z30.strictObject({
+import { z as z31 } from "zod";
+var FsWatchId = z31.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = z31.strictObject({
   path: AbsPath,
-  recursive: z30.boolean().default(true),
+  recursive: z31.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: z30.array(z30.string().max(256)).max(64).default([])
+  ignore: z31.array(z31.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = z30.strictObject({
+var FsWatchStartResult = z31.strictObject({
   watch_id: FsWatchId,
   path: AbsPath,
   /** The watch ends by itself if nobody reads it for 30 minutes. */
   expires_at_ms: epochMs
 });
-var FsWatchEventsParams = z30.strictObject({
+var FsWatchEventsParams = z31.strictObject({
   watch_id: FsWatchId,
   /** Wait up to this long for a first change when none is waiting (0 answers at once). */
-  wait_ms: z30.int().min(0).max(25e3).default(0)
+  wait_ms: z31.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = z30.strictObject({
+var FsWatchEventsResult = z31.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: z30.array(FsChange).max(1e3),
+  changes: z31.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: z30.boolean(),
+  overflow: z31.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = z30.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = z30.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = z31.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = z31.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-import { z as z31 } from "zod";
-var ExecJobId = z31.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = z31.strictObject({
-  command: z31.string().min(1).max(131072),
+import { z as z32 } from "zod";
+var ExecJobId = z32.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = z32.strictObject({
+  command: z32.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: z31.record(z31.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z31.string().max(32768)).optional()
+  env: z32.record(z32.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z32.string().max(32768)).optional()
 });
-var ExecJobStartResult = z31.strictObject({ job_id: ExecJobId, pid: z31.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = z31.strictObject({
+var ExecJobStartResult = z32.strictObject({ job_id: ExecJobId, pid: z32.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = z32.strictObject({
   job_id: ExecJobId,
   /** Byte offset into the job's output to read from (next_offset of the last read; 0 = the start). */
   offset: nonNegInt.default(0),
   /** Wait up to this long for new output or the exit when none is waiting (0 answers at once). */
-  wait_ms: z31.int().min(0).max(25e3).default(0),
-  max_bytes: z31.int().min(1024).max(1048576).default(65536)
+  wait_ms: z32.int().min(0).max(25e3).default(0),
+  max_bytes: z32.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = z31.strictObject({
+var ExecJobOutputResult = z32.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: z31.string(),
+  output: z32.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: z31.boolean(),
-  exit_code: z31.int().nullable()
+  running: z32.boolean(),
+  exit_code: z32.int().nullable()
 });
-var ExecJobStopParams = z31.strictObject({
+var ExecJobStopParams = z32.strictObject({
   job_id: ExecJobId,
   /** End it at once (SIGKILL; on Windows the whole tree with /F) instead of asking it to quit. */
-  force: z31.boolean().default(false)
+  force: z32.boolean().default(false)
 });
-var ExecJobStopResult = z31.strictObject({ job_id: ExecJobId, exited: z31.boolean(), exit_code: z31.int().nullable() });
-var ExecJobInfo = z31.strictObject({
+var ExecJobStopResult = z32.strictObject({ job_id: ExecJobId, exited: z32.boolean(), exit_code: z32.int().nullable() });
+var ExecJobInfo = z32.strictObject({
   job_id: ExecJobId,
-  command: z31.string().max(1024),
-  pid: z31.int().min(1),
+  command: z32.string().max(1024),
+  pid: z32.int().min(1),
   cwd: AbsPath,
-  running: z31.boolean(),
-  exit_code: z31.int().nullable(),
+  running: z32.boolean(),
+  exit_code: z32.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = z31.strictObject({});
-var ExecJobListResult = z31.strictObject({ jobs: z31.array(ExecJobInfo).max(64) });
+var ExecJobListParams = z32.strictObject({});
+var ExecJobListResult = z32.strictObject({ jobs: z32.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 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_PATTERN5),
+var CodingServiceCredentials = z33.strictObject({
+  access_token: z33.string().min(16).max(16384),
+  user_id: z33.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?#]*)?$/)
+  server_url: z33.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = z32.enum([
+var CodingHistoryBlocked = z33.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -2999,11 +3081,11 @@ var CodingHistoryBlocked = z32.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = z32.strictObject({
-  session_id: z32.string().max(64),
-  reason: z32.string().max(300)
+var CodingHistoryFailure = z33.strictObject({
+  session_id: z33.string().max(64),
+  reason: z33.string().max(300)
 });
-var CodingHistoryRun = z32.strictObject({
+var CodingHistoryRun = z33.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -3018,39 +3100,39 @@ var CodingHistoryRun = z32.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: z32.array(CodingHistoryFailure).max(20),
+  failures: z33.array(CodingHistoryFailure).max(20),
   /** Candidates not reached yet. */
   remaining: nonNegInt,
   /** The one line a person reads, e.g. "Imported 12 of 14 sessions. 140 already in AI Matrx." */
-  summary: z32.string().max(400)
+  summary: z33.string().max(400)
 });
-var CodingHistoryStep = z32.strictObject({
+var CodingHistoryStep = z33.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: z32.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: z32.boolean(),
+  plan_id: z33.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: z33.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = z32.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = z32.strictObject({
-  plan_id: z32.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = z33.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = z33.strictObject({
+  plan_id: z33.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = z32.strictObject({
-  phase: z32.enum(["checking", "importing"]),
+var CodingServiceProgress = z33.strictObject({
+  phase: z33.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = z32.strictObject({});
-var CodingHistoryImportMissingResult = z32.strictObject({
-  state: z32.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = z33.strictObject({});
+var CodingHistoryImportMissingResult = z33.strictObject({
+  state: z33.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = z32.strictObject({
+var CodingHistoryProgressEvent = z33.strictObject({
   request_id: RequestId,
-  phase: z32.enum(["checking", "importing"]),
+  phase: z33.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -3059,386 +3141,386 @@ var CodingHistoryProgressEvent = z32.strictObject({
 });
 
 // src/schema/coding-sessions.ts
-import { z as z33 } from "zod";
-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({
+import { z as z34 } from "zod";
+var CodingProviderName = z34.enum(["claude", "codex"]);
+var CodingRunStatus = z34.enum(["starting", "running", "completed", "stopped", "failed"]);
+var SessionKey = z34.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var IsoTime = z34.string().min(10).max(40);
+var LocalPath = z34.string().min(1).max(4096);
+var CodingClientRequestId = z34.string().regex(/^[A-Za-z0-9_-]{8,64}$/);
+var ShortText = z34.string().max(500);
+var CodingRunUsage = z34.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 CodingStartedBy = z34.strictObject({
+  kind: z34.enum(["this_computer", "web", "phone", "agent", "other"]),
+  label: z34.string().min(1).max(80)
 });
-var CodingRunRecord = z33.strictObject({
-  runId: z33.string().min(1).max(64),
+var CodingRunRecord = z34.strictObject({
+  runId: z34.string().min(1).max(64),
   sessionId: SessionKey,
   provider: CodingProviderName,
   cwd: LocalPath,
-  prompt: z33.string().max(1048576),
-  model: z33.string().max(200).nullable(),
+  prompt: z34.string().max(1048576),
+  model: z34.string().max(200).nullable(),
   status: CodingRunStatus,
   startedAt: IsoTime,
   endedAt: IsoTime.nullable(),
-  error: z33.string().max(65536).nullable(),
+  error: z34.string().max(65536).nullable(),
   usage: CodingRunUsage.nullable(),
-  costUsd: z33.number().nullable(),
-  billing: z33.enum(["subscription", "api", "unknown"]).nullable(),
+  costUsd: z34.number().nullable(),
+  billing: z34.enum(["subscription", "api", "unknown"]).nullable(),
   startedBy: CodingStartedBy.nullable()
 });
-var CodingSessionAgentPart = z33.strictObject({
-  part: z33.enum(["instructions", "skills", "tools"]),
+var CodingSessionAgentPart = z34.strictObject({
+  part: z34.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(),
+var CodingSessionAgent = z34.strictObject({
+  agentId: z34.string().min(1).max(64),
+  versionId: z34.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(),
+  name: z34.string().max(300),
+  definitionHash: z34.string().max(200),
+  loaded: z34.array(CodingSessionAgentPart).max(3),
+  unavailable: z34.array(z34.strictObject({ kind: z34.string().max(60), name: z34.string().max(300), reason: ShortText })).max(500),
+  skills: z34.array(z34.string().max(300)).max(500),
+  tools: z34.array(z34.string().max(300)).max(500),
+  variables: z34.record(z34.string().max(200), z34.unknown()),
+  blockDue: z34.boolean(),
   deliveredAt: IsoTime.nullable(),
-  replaces: z33.string().max(300).nullable()
+  replaces: z34.string().max(300).nullable()
 });
-var CodingSessionRecord = z33.strictObject({
+var CodingSessionRecord = z34.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"]),
+  title: z34.string().max(500),
+  model: z34.string().max(200).nullable(),
+  effort: z34.string().max(40).nullable(),
+  origin: z34.enum(["started", "takeover"]),
   createdAt: IsoTime,
   updatedAt: IsoTime,
-  lastRunId: z33.string().max(64).nullable(),
+  lastRunId: z34.string().max(64).nullable(),
   lastRunStatus: CodingRunStatus.nullable(),
-  queued: z33.array(z33.string().max(1048576)).max(100),
+  queued: z34.array(z34.string().max(1048576)).max(100),
   agent: CodingSessionAgent.nullable(),
-  agentRemovedDue: z33.boolean()
+  agentRemovedDue: z34.boolean()
 });
-var CodingActiveElsewhere = z33.strictObject({
-  reason: z33.enum(["process", "recent-write", "open-tool-call", "open"]),
+var CodingActiveElsewhere = z34.strictObject({
+  reason: z34.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()
+  pid: z34.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({
+var CodingTitleSource = z34.enum(["app", "app-remembered", "custom-title", "ai-title", "agent-name", "summary", "first-prompt", "last-prompt", "unknown"]);
+var CodingDiscoveredChat = z34.strictObject({
   provider: CodingProviderName,
   providerSessionId: SessionKey,
   cwd: LocalPath.nullable(),
-  title: z33.string().max(500),
+  title: z34.string().max(500),
   titleSource: CodingTitleSource.optional(),
-  titlePending: z33.boolean().optional(),
-  archived: z33.boolean().optional(),
-  scheduled: z33.boolean().optional(),
-  unlisted: z33.boolean().optional(),
+  titlePending: z34.boolean().optional(),
+  archived: z34.boolean().optional(),
+  scheduled: z34.boolean().optional(),
+  unlisted: z34.boolean().optional(),
   unavailable: ShortText.nullable(),
   updatedAt: IsoTime,
-  source: z33.string().max(60).nullable(),
+  source: z34.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(),
+var CodingTranscriptItem = z34.discriminatedUnion("kind", [
+  z34.strictObject({ kind: z34.literal("user"), id: z34.string().max(200), text: z34.string(), at: IsoTime.nullable() }),
+  z34.strictObject({ kind: z34.literal("text"), id: z34.string().max(200), text: z34.string() }),
+  z34.strictObject({ kind: z34.literal("text-delta"), id: z34.string().max(200), text: z34.string() }),
+  z34.strictObject({ kind: z34.literal("reasoning"), id: z34.string().max(200), text: z34.string() }),
+  z34.strictObject({ kind: z34.literal("tool-call"), id: z34.string().max(200), name: z34.string().max(300), input: z34.unknown() }),
+  z34.strictObject({
+    kind: z34.literal("tool-result"),
+    id: z34.string().max(200),
+    output: z34.string(),
+    isError: z34.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() })
+  z34.strictObject({ kind: z34.literal("usage"), usage: CodingRunUsage, costUsd: z34.number().nullable() }),
+  z34.strictObject({ kind: z34.literal("notice"), id: z34.string().max(200), level: z34.enum(["info", "warning"]), text: z34.string() }),
+  z34.strictObject({ kind: z34.literal("error"), id: z34.string().max(200), text: z34.string() })
 ]);
-var CodingHistoryRecord = z33.strictObject({
-  items: z33.array(CodingTranscriptItem),
+var CodingHistoryRecord = z34.strictObject({
+  items: z34.array(CodingTranscriptItem),
   /** Only the end of the chat is here; "Show earlier" reads more (a bigger `max_bytes`). */
-  truncated: z33.boolean(),
+  truncated: z34.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 CodingQuotaWindow = z34.strictObject({
+  label: z34.string().max(120),
+  usedPercent: z34.number().nullable(),
+  resetsAt: z34.string().max(80).nullable(),
+  valueLabel: z34.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(),
+var CodingProviderProblem = z34.strictObject({
+  kind: z34.enum(["usage-limit", "signed-out"]),
+  message: z34.string().max(2e3),
+  until: z34.string().max(120).nullable(),
   at: IsoTime
 });
-var CodingProviderBinary = z33.strictObject({
+var CodingProviderBinary = z34.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()
+  version: z34.string().max(80).nullable(),
+  source: z34.enum(["desktop-app", "path", "npm-global", "configured"]),
+  sourceLabel: z34.string().max(120),
+  newer: z34.strictObject({ path: LocalPath, version: z34.string().max(80), sourceLabel: z34.string().max(120) }).nullable()
 });
-var CodingProviderStatus = z33.strictObject({
+var CodingProviderStatus = z34.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(),
+  label: z34.string().max(60),
+  installed: z34.boolean(),
+  version: z34.string().max(80).nullable(),
+  loggedIn: z34.boolean(),
+  billing: z34.enum(["subscription", "api", "unknown"]),
+  plan: z34.string().max(80).nullable(),
+  account: z34.string().max(320).nullable(),
   problem: ShortText.nullable(),
   fix: ShortText.nullable(),
-  ready: z33.boolean(),
+  ready: z34.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(),
+  quota: z34.array(CodingQuotaWindow).max(20),
+  models: z34.array(z34.strictObject({ id: z34.string().max(200), label: z34.string().max(200) })).max(200),
+  efforts: z34.array(z34.string().max(40)).max(20),
+  defaultModel: z34.strictObject({ id: z34.string().max(200), source: z34.enum(["settings", "driver"]) }).nullable(),
+  defaultEffort: z34.string().max(40).nullable(),
   binary: CodingProviderBinary.nullable()
 });
-var CodingChatPreference = z33.strictObject({
-  title: z33.string().max(500).nullable(),
-  pinned: z33.boolean(),
-  hidden: z33.boolean(),
+var CodingChatPreference = z34.strictObject({
+  title: z34.string().max(500).nullable(),
+  pinned: z34.boolean(),
+  hidden: z34.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(),
+var CodingTitleStatus = z34.strictObject({
+  owner: z34.boolean(),
+  pending: z34.boolean(),
   problem: ShortText.nullable(),
   renames: ShortText.nullable()
 });
-var CodingRecentRow = z33.strictObject({
-  target: z33.string().min(3).max(200),
-  title: z33.string().max(500),
+var CodingRecentRow = z34.strictObject({
+  target: z34.string().min(3).max(200),
+  title: z34.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(),
+  state: z34.enum(["running", "needs_attention", "new_output", "elsewhere", "idle"]),
+  stateLabel: z34.string().max(120).nullable(),
+  pinned: z34.boolean(),
   startedBy: CodingStartedBy.nullable()
 });
-var CodingFolderCheck = z33.strictObject({
-  path: z33.string().max(4096),
-  exists: z33.boolean(),
-  isDirectory: z33.boolean()
+var CodingFolderCheck = z34.strictObject({
+  path: z34.string().max(4096),
+  exists: z34.boolean(),
+  isDirectory: z34.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 CodingRecentFolder = z34.strictObject({ path: LocalPath, lastUsedAt: IsoTime, exists: z34.boolean() });
+var CodingAgentSelectionParams = z34.strictObject({
+  agent_id: z34.string().min(1).max(64),
+  version_id: z34.string().min(1).max(64).optional(),
+  variables: z34.record(z34.string().max(200), z34.unknown()).optional()
 });
-var CodingSendResult = z33.strictObject({
+var CodingSendResult = z34.strictObject({
   session: CodingSessionRecord,
   run: CodingRunRecord.nullable(),
   /** The prompt waits behind a live run (it shows as a queued bubble). */
-  queued: z33.boolean()
+  queued: z34.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),
+var CodingProvidersParams = z34.strictObject({});
+var CodingProvidersResult = z34.strictObject({ providers: z34.array(CodingProviderStatus).max(4) });
+var CodingSessionsListParams = z34.strictObject({});
+var CodingSessionsListResult = z34.strictObject({
+  sessions: z34.array(CodingSessionRecord),
   /** The latest run of each session, by session id. */
-  runs: z33.record(z33.string().max(128), CodingRunRecord),
-  recent: z33.array(CodingRecentRow),
+  runs: z34.record(z34.string().max(128), CodingRunRecord),
+  recent: z34.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 CodingDiscoverParams = z34.strictObject({ limit: z34.int().min(1).max(1e3).optional() });
+var CodingDiscoverResult = z34.strictObject({ chats: z34.array(CodingDiscoveredChat) });
+var CodingRunsListParams = z34.strictObject({ session_id: SessionKey });
+var CodingRunsListResult = z34.strictObject({ runs: z34.array(CodingRunRecord) });
+var CodingHistoryParams = z34.strictObject({ session_id: SessionKey, max_bytes: z34.int().min(1024).max(209715200).optional() });
 var CodingHistoryResult = CodingHistoryRecord;
-var CodingTranscriptReadParams = z33.strictObject({
+var CodingTranscriptReadParams = z34.strictObject({
   provider: CodingProviderName,
   provider_session_id: SessionKey,
-  max_bytes: z33.int().min(1024).max(209715200).optional()
+  max_bytes: z34.int().min(1024).max(209715200).optional()
 });
 var CodingTranscriptReadResult = CodingHistoryRecord;
-var CodingItemFullParams = z33.strictObject({
+var CodingItemFullParams = z34.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) });
+  item_id: z34.string().min(1).max(200)
+});
+var CodingItemFullResult = z34.strictObject({ output: z34.string(), bytes: nonNegInt });
+var CodingActivityParams = z34.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingActivityResult = z34.strictObject({ active: CodingActiveElsewhere.nullable() });
+var CodingFoldersRecentParams = z34.strictObject({});
+var CodingFoldersRecentResult = z34.strictObject({ folders: z34.array(CodingRecentFolder).max(100) });
+var CodingFoldersCheckParams = z34.strictObject({ path: z34.string().min(1).max(4096) });
 var CodingFoldersCheckResult = CodingFolderCheck;
-var CodingFoldersCreateParams = z33.strictObject({ path: z33.string().min(1).max(4096) });
+var CodingFoldersCreateParams = z34.strictObject({ path: z34.string().min(1).max(4096) });
 var CodingFoldersCreateResult = CodingFolderCheck;
-var CodingStartParams = z33.strictObject({
+var CodingStartParams = z34.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(),
+  cwd: z34.string().min(1).max(4096),
+  prompt: z34.string().min(1).max(1048576),
+  model: z34.string().min(1).max(200).optional(),
+  effort: z34.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(),
+  account_profile_id: z34.string().min(1).max(64).optional(),
   client_request_id: CodingClientRequestId
 });
 var CodingStartResult = CodingSendResult;
-var CodingTakeoverParams = z33.strictObject({
+var CodingTakeoverParams = z34.strictObject({
   provider: CodingProviderName,
   provider_session_id: SessionKey,
-  cwd: z33.string().min(1).max(4096),
-  title: z33.string().max(500).optional(),
+  cwd: z34.string().min(1).max(4096),
+  title: z34.string().max(500).optional(),
   agent: CodingAgentSelectionParams.optional(),
-  confirm_elsewhere: z33.boolean().optional()
+  confirm_elsewhere: z34.boolean().optional()
 });
-var CodingTakeoverResult = z33.strictObject({ session: CodingSessionRecord });
-var CodingSendParams = z33.strictObject({
+var CodingTakeoverResult = z34.strictObject({ session: CodingSessionRecord });
+var CodingSendParams = z34.strictObject({
   session_id: SessionKey,
-  prompt: z33.string().min(1).max(1048576),
+  prompt: z34.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({
+var CodingStopParams = z34.strictObject({ run_id: z34.string().min(1).max(64) });
+var CodingStopResult = z34.strictObject({ run: CodingRunRecord.nullable() });
+var CodingStopElsewhereParams = z34.strictObject({
   provider: CodingProviderName,
   provider_session_id: SessionKey,
-  pid: z33.int().min(1)
+  pid: z34.int().min(1)
 });
-var CodingStopElsewhereResult = z33.strictObject({ stopped: z33.boolean(), message: ShortText });
-var CodingOptionsSetParams = z33.strictObject({
+var CodingStopElsewhereResult = z34.strictObject({ stopped: z34.boolean(), message: ShortText });
+var CodingOptionsSetParams = z34.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({});
+  model: z34.string().max(200).optional(),
+  effort: z34.string().max(40).optional()
+});
+var CodingOptionsSetResult = z34.strictObject({ session: CodingSessionRecord });
+var CodingAgentSetParams = z34.strictObject({ session_id: SessionKey, agent: CodingAgentSelectionParams.optional() });
+var CodingAgentSetResult = z34.strictObject({ session: CodingSessionRecord });
+var CodingAgentsAccessParams = z34.strictObject({});
+var CodingAgentsAccessResult = z34.strictObject({
+  signedIn: z34.boolean(),
+  userId: z34.string().max(64).nullable(),
+  organizationId: z34.string().max(64).nullable(),
+  configured: z34.boolean()
+});
+var CodingTitlesStatusParams = z34.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 CodingPrefsListParams = z34.strictObject({});
+var CodingPrefsListResult = z34.strictObject({ preferences: z34.record(z34.string().max(200), CodingChatPreference) });
+var CodingPrefsSetParams = z34.strictObject({
+  key: z34.string().min(1).max(200),
+  title: z34.string().min(1).max(500).optional(),
+  clear_title: z34.boolean().optional(),
+  pinned: z34.boolean().optional(),
+  hidden: z34.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),
+var CodingRecentSeenParams = z34.strictObject({ target: z34.string().min(3).max(200) });
+var CodingRecentSeenResult = z34.strictObject({ recent: z34.array(CodingRecentRow) });
+var CodingSearchParams = z34.strictObject({
+  query: z34.string().min(1).max(500),
   cursor: nonNegInt.optional(),
-  limit: z33.int().min(1).max(100).optional()
+  limit: z34.int().min(1).max(100).optional()
 });
-var CodingSearchResult = z33.strictObject({
-  query: z33.string().max(500),
-  hits: z33.array(
-    z33.strictObject({
+var CodingSearchResult = z34.strictObject({
+  query: z34.string().max(500),
+  hits: z34.array(
+    z34.strictObject({
       provider: CodingProviderName,
       providerSessionId: SessionKey,
-      title: z33.string().max(500),
+      title: z34.string().max(500),
       cwd: LocalPath.nullable(),
       updatedAt: IsoTime,
-      where: z33.enum(["title", "content"]),
-      snippet: z33.string().max(2e3).nullable()
+      where: z34.enum(["title", "content"]),
+      snippet: z34.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 CodingReconcileParams = z34.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingReconcileResult = z34.strictObject({
+  state: z34.enum(["done", "blocked", "nothing_to_do"]),
+  summary: z34.string().max(400)
 });
-var CodingTranscriptRawParams = z33.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
-var CodingTranscriptRawResult = z33.strictObject({
-  available: z33.boolean(),
+var CodingTranscriptRawParams = z34.strictObject({ provider: CodingProviderName, provider_session_id: SessionKey });
+var CodingTranscriptRawResult = z34.strictObject({
+  available: z34.boolean(),
   reason: ShortText.nullable(),
-  file_name: z33.string().max(300).nullable(),
+  file_name: z34.string().max(300).nullable(),
   bytes: nonNegInt,
   /** The opt-in cloud backup was refreshed (false: off, unchanged, or signed out). */
-  backup_refreshed: z33.boolean(),
+  backup_refreshed: z34.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({
+var CodingWatchParams = z34.strictObject({});
+var CodingWatchResult = z34.strictObject({ resource_id: ResourceId });
+var CodingSessionWatchParams = z34.strictObject({ session_id: SessionKey, since_seq: nonNegInt.optional() });
+var CodingSessionWatchResult = z34.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 CodingChangedEvent = z34.discriminatedUnion("kind", [
+  z34.strictObject({ kind: z34.literal("session"), session: CodingSessionRecord }),
+  z34.strictObject({ kind: z34.literal("run"), run: CodingRunRecord }),
+  z34.strictObject({ kind: z34.literal("preferences"), preferences: z34.record(z34.string().max(200), CodingChatPreference) }),
+  z34.strictObject({ kind: z34.literal("titles") }),
+  z34.strictObject({ kind: z34.literal("recent"), recent: z34.array(CodingRecentRow) })
 ]);
-var CodingWatchStateEvent = z33.strictObject({ live: z33.boolean(), reason: ShortText.nullable(), beat_ms: z33.int().min(1e3) });
-var CodingItemEvent = z33.strictObject({
+var CodingWatchStateEvent = z34.strictObject({ live: z34.boolean(), reason: ShortText.nullable(), beat_ms: z34.int().min(1e3) });
+var CodingItemEvent = z34.strictObject({
   session_id: SessionKey,
-  run_id: z33.string().min(1).max(64),
+  run_id: z34.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) });
+var CodingGapEvent = z34.strictObject({ session_id: SessionKey, since_seq: nonNegInt, seq: nonNegInt });
+var SessionIdentifyParams = z34.strictObject({ label: z34.string().min(1).max(60) });
+var SessionIdentifyResult = z34.strictObject({ label: z34.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({
+import { z as z35 } from "zod";
+var BrowserClientInstance = z35.string().min(1).max(64).regex(/^[A-Za-z0-9_.:-]+$/);
+var BrowserKind = z35.enum(["chrome", "edge", "brave", "arc", "opera", "vivaldi", "chromium", "firefox", "other"]);
+var BrowserSessionState = z35.enum(["connected", "different_account", "extension_signed_out", "device_signed_out", "unverified"]);
+var BrowserSession = z35.strictObject({
   client_instance: BrowserClientInstance,
   /** What the person sees ("Chrome — Work"), set by the extension. */
-  client_label: z34.string().min(1).max(128),
+  client_label: z35.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z34.string().min(1).max(32),
+  extension_version: z35.string().min(1).max(32),
   state: BrowserSessionState,
   /** True only for `connected`: an agent's call can reach this session. */
-  routable: z34.boolean(),
+  routable: z35.boolean(),
   /** The extension's account email from its token (null when signed out or unknown). */
-  account_email: z34.string().max(320).nullable(),
+  account_email: z35.string().max(320).nullable(),
   connected_at_ms: epochMs,
   last_call_at_ms: epochMs.nullable(),
   calls: nonNegInt,
@@ -3447,119 +3529,119 @@ var BrowserSession = z34.strictObject({
   p50_ms: nonNegInt.nullable(),
   p95_ms: nonNegInt.nullable(),
   /** A call is waiting for the person to confirm it in the browser. */
-  awaiting_confirmation: z34.boolean()
+  awaiting_confirmation: z35.boolean()
 });
-var BrowserRegisterParams = z34.strictObject({
+var BrowserRegisterParams = z35.strictObject({
   client_instance: BrowserClientInstance,
-  client_label: z34.string().min(1).max(128),
+  client_label: z35.string().min(1).max(128),
   browser: BrowserKind,
-  extension_version: z34.string().min(1).max(32),
+  extension_version: z35.string().min(1).max(32),
   /** The extension's current AI Matrx access token, checked against the device owner; null when signed out. */
-  account_token: z34.string().min(16).max(8192).nullable()
+  account_token: z35.string().min(16).max(8192).nullable()
 });
-var BrowserRegisterResult = z34.strictObject({ session: BrowserSession });
-var BrowserCallError = z34.strictObject({
-  message: z34.string().max(1e3),
+var BrowserRegisterResult = z35.strictObject({ session: BrowserSession });
+var BrowserCallError = z35.strictObject({
+  message: z35.string().max(1e3),
   /** The extension's own error code, when it has one ("tool_not_found", "denied"). */
-  code: z34.string().max(64).nullable()
+  code: z35.string().max(64).nullable()
 });
-var BrowserResultParams = z34.strictObject({
-  call_id: z34.string().min(1).max(64),
-  ok: z34.boolean(),
+var BrowserResultParams = z35.strictObject({
+  call_id: z35.string().min(1).max(64),
+  ok: z35.boolean(),
   /** The tool's result when ok (any JSON). */
-  result: z34.unknown(),
+  result: z35.unknown(),
   error: BrowserCallError.nullable()
 });
-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({
+var BrowserResultResult = z35.strictObject({ accepted: z35.boolean() });
+var BrowserCallPhase = z35.enum(["awaiting_confirmation", "running"]);
+var BrowserProgressParams = z35.strictObject({ call_id: z35.string().min(1).max(64), phase: BrowserCallPhase });
+var BrowserProgressResult = z35.strictObject({ accepted: z35.boolean() });
+var BrowserSessionsParams = z35.strictObject({});
+var BrowserSessionsResult = z35.strictObject({
   /** The person's Browser connection switch. Off: no pairing, no extension sessions. */
-  enabled: z34.boolean(),
+  enabled: z35.boolean(),
   /** Whether Matrx 2 is signed in (without an owner no session is routable). */
-  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()),
+  owner_signed_in: z35.boolean(),
+  sessions: z35.array(BrowserSession).max(64)
+});
+var BrowserDisconnectParams = z35.strictObject({ client_instance: BrowserClientInstance });
+var BrowserDisconnectResult = z35.strictObject({ disconnected: z35.boolean() });
+var BrowserSetEnabledParams = z35.strictObject({ enabled: z35.boolean() });
+var BrowserSetEnabledResult = z35.strictObject({ enabled: z35.boolean() });
+var BrowserPairCodeParams = z35.strictObject({});
+var BrowserPairCodeResult = z35.strictObject({ code: z35.string().min(16).max(128) });
+var BrowserPairResetParams = z35.strictObject({});
+var BrowserCallParams = z35.strictObject({
+  tool: z35.string().min(1).max(96).regex(/^[a-z][a-z0-9_]*$/),
+  args: z35.record(z35.string(), z35.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: z34.int().min(1e3).max(6e5).optional()
+  timeout_ms: z35.int().min(1e3).max(6e5).optional()
 });
-var BrowserCallResult = z34.strictObject({
+var BrowserCallResult = z35.strictObject({
   client_instance: BrowserClientInstance,
-  result: z34.unknown(),
+  result: z35.unknown(),
   duration_ms: nonNegInt
 });
-var BrowserToolMetricsParams = z34.strictObject({ client_instance: BrowserClientInstance });
-var BrowserToolMetric = z34.strictObject({
-  tool: z34.string().max(256),
+var BrowserToolMetricsParams = z35.strictObject({ client_instance: BrowserClientInstance });
+var BrowserToolMetric = z35.strictObject({
+  tool: z35.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: z34.string().max(2048).nullable()
+  last_error: z35.string().max(2048).nullable()
 });
-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({
+var BrowserToolMetricsResult = z35.strictObject({ client_instance: z35.string(), tools: z35.array(BrowserToolMetric) });
+var BrowserResetCountersParams = z35.strictObject({ client_instance: BrowserClientInstance });
+var BrowserResetCountersResult = z35.strictObject({ reset: z35.boolean() });
+var BrowserLogParams = z35.strictObject({
   /** Only messages after this seq (0: from the oldest kept; the core keeps the last 500). */
   after_seq: nonNegInt.default(0),
-  limit: z34.int().min(1).max(500).default(500)
+  limit: z35.int().min(1).max(500).default(500)
 });
-var BrowserLogMessage = z34.strictObject({
+var BrowserLogMessage = z35.strictObject({
   seq: nonNegInt,
   at_ms: epochMs,
-  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),
+  direction: z35.enum(["to_browser", "from_browser", "core"]),
+  client_instance: z35.string(),
+  kind: z35.enum(["register", "invoke", "result", "progress", "timeout", "closed"]),
+  tool: z35.string().nullable(),
+  call_id: z35.string().nullable(),
+  ok: z35.boolean().nullable(),
+  detail: z35.string().max(1024)
+});
+var BrowserLogResult = z35.strictObject({
+  messages: z35.array(BrowserLogMessage),
   /** The newest seq the core has written (pass it back as after_seq to follow the log). */
   last_seq: nonNegInt
 });
-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()),
+var BrowserInvokeEvent = z35.strictObject({
+  call_id: z35.string().min(1).max(64),
+  tool: z35.string().min(1).max(96),
+  args: z35.record(z35.string(), z35.unknown()),
   deadline_ms: epochMs
 });
-var BrowserSessionsChangedEvent = z34.strictObject({ count: nonNegInt, enabled: z34.boolean() });
-var BrowserProgressEvent = z34.strictObject({
-  call_id: z34.string().min(1).max(64),
+var BrowserSessionsChangedEvent = z35.strictObject({ count: nonNegInt, enabled: z35.boolean() });
+var BrowserProgressEvent = z35.strictObject({
+  call_id: z35.string().min(1).max(64),
   client_instance: BrowserClientInstance,
   phase: BrowserCallPhase
 });
-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 DesktopHealth = z35.strictObject({
+  status: z35.literal("ok"),
+  service: z35.literal("matrx-desktop"),
+  version: z35.string().max(32),
+  protocol_version: z35.string().max(16),
+  ws_path: z35.literal("/v1/connect"),
+  device_id: z35.string().max(64),
+  browser_connection: z35.enum(["on", "off"])
+});
+var BrowserPairRequest = z35.strictObject({ client_instance: BrowserClientInstance });
+var BrowserPairResult = z35.strictObject({ pair_token: z35.string().min(16).max(128), ws_path: z35.literal("/v1/connect") });
 var MATRX_EXTENSION_IDS = {
   store: "hnfolienncfklkgmdjjmhhegglimlamg",
   development: "cihdmkcdjjckfhjpgoedmgfpoljebaml"
@@ -3567,641 +3649,641 @@ var MATRX_EXTENSION_IDS = {
 var DISCOVERY_FILE = { live: "matrx2.json", development: "matrx2-dev.json" };
 
 // src/schema/net.ts
-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(),
+import { z as z36 } from "zod";
+var NetInfoParams = z36.strictObject({});
+var NetAddress = z36.strictObject({
+  address: z36.string(),
+  family: z36.enum(["ipv4", "ipv6"]),
+  netmask: z36.string().nullable(),
   /** CIDR form ("192.168.1.20/24"); null where the OS gives no prefix. */
-  cidr: z35.string().nullable()
+  cidr: z36.string().nullable()
 });
-var NetInterface = z35.strictObject({
-  name: z35.string(),
-  mac: z35.string().nullable(),
+var NetInterface = z36.strictObject({
+  name: z36.string(),
+  mac: z36.string().nullable(),
   /** Loopback and other internal interfaces. */
-  internal: z35.boolean(),
-  addresses: z35.array(NetAddress)
+  internal: z36.boolean(),
+  addresses: z36.array(NetAddress)
 });
-var NetInfoResult = z35.strictObject({
-  hostname: z35.string(),
-  interfaces: z35.array(NetInterface),
+var NetInfoResult = z36.strictObject({
+  hostname: z36.string(),
+  interfaces: z36.array(NetInterface),
   /** The default route's gateway; null when the OS does not say (or there is none). */
-  gateway: z35.string().nullable(),
+  gateway: z36.string().nullable(),
   /** The DNS servers the OS uses; empty when it does not say. */
-  dns: z35.array(z35.string())
+  dns: z36.array(z36.string())
 });
-var NetWifiParams = z35.strictObject({});
-var NetWifiNetwork = z35.strictObject({
+var NetWifiParams = z36.strictObject({});
+var NetWifiNetwork = z36.strictObject({
   /** null: the OS hides the name (macOS without Location Services for this app). */
-  ssid: z35.string().nullable(),
+  ssid: z36.string().nullable(),
   /** dBm; null where the OS does not say. */
-  rssi: z35.int().nullable(),
-  channel: z35.string().nullable(),
-  security: z35.string().nullable()
+  rssi: z36.int().nullable(),
+  channel: z36.string().nullable(),
+  security: z36.string().nullable()
 });
-var NetWifiResult = z35.strictObject({
+var NetWifiResult = z36.strictObject({
   /** Whether the computer has a Wi-Fi interface at all. */
-  available: z35.boolean(),
+  available: z36.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: z35.array(NetWifiNetwork)
+  networks: z36.array(NetWifiNetwork)
 });
-var NetBluetoothParams = z35.strictObject({});
-var NetBluetoothDevice = z35.strictObject({
-  name: z35.string(),
-  address: z35.string().nullable(),
-  connected: z35.boolean(),
+var NetBluetoothParams = z36.strictObject({});
+var NetBluetoothDevice = z36.strictObject({
+  name: z36.string(),
+  address: z36.string().nullable(),
+  connected: z36.boolean(),
   /** What it is, in the OS's words ("Headphones", "Keyboard"); null where it does not say. */
-  kind: z35.string().nullable(),
+  kind: z36.string().nullable(),
   /** Battery percent, where the OS reports it. */
-  battery: z35.int().min(0).max(100).nullable()
+  battery: z36.int().min(0).max(100).nullable()
 });
-var NetBluetoothResult = z35.strictObject({
+var NetBluetoothResult = z36.strictObject({
   /** Bluetooth is on; null where the OS does not say. */
-  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(),
+  powered: z36.boolean().nullable(),
+  devices: z36.array(NetBluetoothDevice)
+});
+var NetDevicesParams = z36.strictObject({});
+var NetDevice = z36.strictObject({
+  ip: z36.string(),
+  mac: z36.string().nullable(),
+  interface: z36.string().nullable(),
   /** The name the local network gives it (reverse DNS / mDNS), when the table carries one. */
-  hostname: z35.string().nullable()
+  hostname: z36.string().nullable()
 });
-var NetDevicesResult = z35.strictObject({ devices: z35.array(NetDevice) });
-var NetMdnsParams = z35.strictObject({
+var NetDevicesResult = z36.strictObject({ devices: z36.array(NetDevice) });
+var NetMdnsParams = z36.strictObject({
   /** A service type ("_http._tcp"); absent lists the service types found. */
-  service_type: z35.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
+  service_type: z36.string().min(1).max(64).regex(/^_[A-Za-z0-9-]+\._(tcp|udp)$/).optional(),
   /** How long to listen. */
-  timeout_s: z35.int().min(1).max(30).default(3)
+  timeout_s: z36.int().min(1).max(30).default(3)
 });
-var NetMdnsService = z35.strictObject({
-  name: z35.string(),
-  type: z35.string(),
-  domain: z35.string(),
-  interface: z35.string().nullable()
+var NetMdnsService = z36.strictObject({
+  name: z36.string(),
+  type: z36.string(),
+  domain: z36.string(),
+  interface: z36.string().nullable()
 });
-var NetMdnsResult = z35.strictObject({ services: z35.array(NetMdnsService) });
-var NetScanParams = z35.strictObject({
+var NetMdnsResult = z36.strictObject({ services: z36.array(NetMdnsService) });
+var NetScanParams = z36.strictObject({
   /** A host name or address; a private or loopback address unless `allow_public`. */
-  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),
+  host: z36.string().min(1).max(253),
+  ports: z36.array(z36.int().min(1).max(65535)).min(1).max(1024),
+  timeout_ms: z36.int().min(50).max(1e4).default(800),
   /** Scanning a host on the public internet needs saying so. */
-  allow_public: z35.boolean().default(false)
+  allow_public: z36.boolean().default(false)
 });
-var NetScanResult = z35.strictObject({
-  host: z35.string(),
+var NetScanResult = z36.strictObject({
+  host: z36.string(),
   /** The address the host resolved to. */
-  address: z35.string(),
-  open: z35.array(z35.int().min(1).max(65535)),
+  address: z36.string(),
+  open: z36.array(z36.int().min(1).max(65535)),
   closed: nonNegInt,
   elapsed_ms: nonNegInt
 });
-var NetDownloadParams = z35.strictObject({
-  url: z35.string().min(1).max(8192).regex(/^https?:\/\//),
+var NetDownloadParams = z36.strictObject({
+  url: z36.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: z35.boolean().default(false),
-  timeout_s: z35.int().min(1).max(3600).default(300),
+  overwrite: z36.boolean().default(false),
+  timeout_s: z36.int().min(1).max(3600).default(300),
   /** Refuse anything larger. */
-  max_bytes: z35.int().min(1).max(10737418240).default(2147483648)
+  max_bytes: z36.int().min(1).max(10737418240).default(2147483648)
 });
-var NetDownloadResult = z35.strictObject({
-  path: z35.string(),
+var NetDownloadResult = z36.strictObject({
+  path: z36.string(),
   bytes: nonNegInt,
-  content_type: z35.string().nullable(),
+  content_type: z36.string().nullable(),
   /** The final URL after redirects. */
-  url: z35.string(),
+  url: z36.string(),
   elapsed_ms: nonNegInt
 });
 
 // src/schema/personal.ts
-import { z as z36 } from "zod";
-var Text = z36.string().max(65536);
-var AutomationScriptParams = z36.strictObject({
+import { z as z37 } from "zod";
+var Text = z37.string().max(65536);
+var AutomationScriptParams = z37.strictObject({
   /** applescript and jxa: macOS (osascript); powershell: Windows (and pwsh where installed). */
-  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(),
+  language: z37.enum(["applescript", "jxa", "powershell"]),
+  script: z37.string().min(1).max(262144),
+  timeout_s: z37.int().min(1).max(600).default(60)
+});
+var AutomationScriptResult = z37.strictObject({
+  stdout: z37.string(),
+  stderr: z37.string(),
+  exit_code: z37.int(),
+  timed_out: z37.boolean(),
   /** stdout or stderr was cut at 1 MiB. */
-  truncated: z36.boolean(),
+  truncated: z37.boolean(),
   elapsed_ms: nonNegInt
 });
-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({
+var MailAccountsParams = z37.strictObject({});
+var MailAccount = z37.strictObject({ name: z37.string(), emails: z37.array(z37.string()), enabled: z37.boolean() });
+var MailAccountsResult = z37.strictObject({ accounts: z37.array(MailAccount) });
+var MailListParams = z37.strictObject({
   /** The account's name in Mail; absent: every account. */
-  account: z36.string().min(1).max(256).optional(),
+  account: z37.string().min(1).max(256).optional(),
   /** The mailbox's name ("INBOX", "Sent Messages"). */
-  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(),
+  mailbox: z37.string().min(1).max(256).default("INBOX"),
+  unread_only: z37.boolean().default(false),
+  limit: z37.int().min(1).max(200).default(25)
+});
+var MailMessage = z37.strictObject({
+  id: z37.string(),
+  subject: z37.string(),
+  sender: z37.string(),
   received_at_ms: epochMs.nullable(),
-  read: z36.boolean(),
-  account: z36.string(),
-  mailbox: z36.string(),
+  read: z37.boolean(),
+  account: z37.string(),
+  mailbox: z37.string(),
   /** The first lines of the message's text. */
-  preview: z36.string()
+  preview: z37.string()
 });
-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),
+var MailListResult = z37.strictObject({ messages: z37.array(MailMessage) });
+var MailSendParams = z37.strictObject({
+  to: z37.array(z37.string().min(3).max(320)).min(1).max(50),
+  cc: z37.array(z37.string().min(3).max(320)).max(50).default([]),
+  subject: z37.string().max(998),
   body: Text,
   /** The sending account's address; absent: Mail's default. */
-  from: z36.string().min(3).max(320).optional(),
+  from: z37.string().min(3).max(320).optional(),
   /** false leaves it open in Mail as a draft for the person to send. */
-  send: z36.boolean().default(true)
+  send: z37.boolean().default(true)
 });
-var MailSendResult = z36.strictObject({ sent: z36.boolean() });
-var OutlookStatusParams = z36.strictObject({});
-var OutlookAccount = z36.strictObject({ name: z36.string(), email: z36.string().nullable() });
-var OutlookStatusResult = z36.strictObject({
+var MailSendResult = z37.strictObject({ sent: z37.boolean() });
+var OutlookStatusParams = z37.strictObject({});
+var OutlookAccount = z37.strictObject({ name: z37.string(), email: z37.string().nullable() });
+var OutlookStatusResult = z37.strictObject({
   /** classic_windows: scriptable. new_windows / mac: installed, not scriptable. none: not found. */
-  client: z36.enum(["classic_windows", "new_windows", "mac", "none"]),
-  scriptable: z36.boolean(),
-  version: z36.string().nullable(),
-  accounts: z36.array(OutlookAccount),
+  client: z37.enum(["classic_windows", "new_windows", "mac", "none"]),
+  scriptable: z37.boolean(),
+  version: z37.string().nullable(),
+  accounts: z37.array(OutlookAccount),
   /** Why it is not scriptable here, in a sentence the person can act on; null when it is. */
-  reason: z36.string().nullable()
-});
-var Address = z36.string().min(3).max(320);
-var OutlookDraftParams = z36.strictObject({
-  to: z36.array(Address).max(100).default([]),
-  cc: z36.array(Address).max(100).default([]),
-  bcc: z36.array(Address).max(100).default([]),
-  subject: z36.string().max(998).default(""),
-  body: z36.string().max(1048576).default(""),
-  body_format: z36.enum(["text", "html"]).default("text"),
+  reason: z37.string().nullable()
+});
+var Address = z37.string().min(3).max(320);
+var OutlookDraftParams = z37.strictObject({
+  to: z37.array(Address).max(100).default([]),
+  cc: z37.array(Address).max(100).default([]),
+  bcc: z37.array(Address).max(100).default([]),
+  subject: z37.string().max(998).default(""),
+  body: z37.string().max(1048576).default(""),
+  body_format: z37.enum(["text", "html"]).default("text"),
   /** Files on this computer to attach (absolute paths). */
-  attachments: z36.array(z36.string().min(1).max(4096)).max(50).default([]),
+  attachments: z37.array(z37.string().min(1).max(4096)).max(50).default([]),
   /** The sending account's address (one of outlook.status's accounts); absent: Outlook's default. */
   account: Address.optional(),
   /** true also opens the draft in a window for the person. */
-  display: z36.boolean().default(false)
+  display: z37.boolean().default(false)
 });
-var OutlookDraftResult = z36.strictObject({
+var OutlookDraftResult = z37.strictObject({
   /** The draft's id in Outlook (outlook.read takes it). */
-  id: z36.string(),
-  account: z36.string().nullable(),
-  folder: z36.string(),
+  id: z37.string(),
+  account: z37.string().nullable(),
+  folder: z37.string(),
   attachments: nonNegInt,
-  displayed: z36.boolean()
+  displayed: z37.boolean()
 });
-var OutlookListParams = z36.strictObject({
-  folder: z36.enum(["inbox", "sent", "drafts"]).default("inbox"),
+var OutlookListParams = z37.strictObject({
+  folder: z37.enum(["inbox", "sent", "drafts"]).default("inbox"),
   /** The account's address; absent: the default account. */
   account: Address.optional(),
-  unread_only: z36.boolean().default(false),
-  limit: z36.int().min(1).max(200).default(25)
+  unread_only: z37.boolean().default(false),
+  limit: z37.int().min(1).max(200).default(25)
 });
-var OutlookMessage = z36.strictObject({
-  id: z36.string(),
-  subject: z36.string(),
-  sender: z36.string(),
+var OutlookMessage = z37.strictObject({
+  id: z37.string(),
+  subject: z37.string(),
+  sender: z37.string(),
   received_at_ms: epochMs.nullable(),
-  read: z36.boolean(),
-  has_attachments: z36.boolean(),
+  read: z37.boolean(),
+  has_attachments: z37.boolean(),
   /** The first lines of the message's text. */
-  preview: z36.string()
-});
-var OutlookListResult = z36.strictObject({ folder: z36.string(), messages: z36.array(OutlookMessage) });
-var OutlookReadParams = z36.strictObject({ id: z36.string().min(1).max(1024) });
-var OutlookReadResult = z36.strictObject({
-  id: z36.string(),
-  subject: z36.string(),
-  sender: z36.string(),
-  to: z36.array(z36.string()),
-  cc: z36.array(z36.string()),
+  preview: z37.string()
+});
+var OutlookListResult = z37.strictObject({ folder: z37.string(), messages: z37.array(OutlookMessage) });
+var OutlookReadParams = z37.strictObject({ id: z37.string().min(1).max(1024) });
+var OutlookReadResult = z37.strictObject({
+  id: z37.string(),
+  subject: z37.string(),
+  sender: z37.string(),
+  to: z37.array(z37.string()),
+  cc: z37.array(z37.string()),
   received_at_ms: epochMs.nullable(),
   /** The plain text body, cut at 1 MiB. */
-  body: z36.string(),
-  attachments: z36.array(z36.strictObject({ name: z36.string(), size: nonNegInt }))
-});
-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()),
+  body: z37.string(),
+  attachments: z37.array(z37.strictObject({ name: z37.string(), size: nonNegInt }))
+});
+var MessagesChatsParams = z37.strictObject({ limit: z37.int().min(1).max(200).default(25) });
+var MessagesChat = z37.strictObject({
+  chat_id: z37.string(),
+  name: z37.string().nullable(),
+  participants: z37.array(z37.string()),
   last_message_at_ms: epochMs.nullable(),
-  service: z36.string().nullable()
+  service: z37.string().nullable()
 });
-var MessagesChatsResult = z36.strictObject({ chats: z36.array(MessagesChat) });
-var MessagesListParams = z36.strictObject({
+var MessagesChatsResult = z37.strictObject({ chats: z37.array(MessagesChat) });
+var MessagesListParams = z37.strictObject({
   /** One chat (messages.chats' chat_id); absent: the newest across all. */
-  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(),
+  chat_id: z37.string().min(1).max(512).optional(),
+  limit: z37.int().min(1).max(500).default(50)
+});
+var MessagesMessage = z37.strictObject({
+  id: z37.string(),
+  chat_id: z37.string().nullable(),
+  text: z37.string(),
+  from_me: z37.boolean(),
   /** The other person's handle (phone or email); null for the person's own messages. */
-  sender: z36.string().nullable(),
+  sender: z37.string().nullable(),
   sent_at_ms: epochMs.nullable()
 });
-var MessagesListResult = z36.strictObject({ messages: z36.array(MessagesMessage) });
-var MessagesSendParams = z36.strictObject({
+var MessagesListResult = z37.strictObject({ messages: z37.array(MessagesMessage) });
+var MessagesSendParams = z37.strictObject({
   /** A phone number or email the person can message. */
-  to: z36.string().min(3).max(320),
-  text: z36.string().min(1).max(2e4),
+  to: z37.string().min(3).max(320),
+  text: z37.string().min(1).max(2e4),
   /**
    * Send only over this service (Matrx Local's SendMessage `service`). Absent: iMessage first, and
    * SMS when the recipient has no iMessage (since 1.42).
    */
-  service: z36.enum(["iMessage", "SMS"]).optional()
+  service: z37.enum(["iMessage", "SMS"]).optional()
 });
-var MessagesSendResult = z36.strictObject({ sent: z36.boolean() });
-var ContactsSearchParams = z36.strictObject({
+var MessagesSendResult = z37.strictObject({ sent: z37.boolean() });
+var ContactsSearchParams = z37.strictObject({
   /** Matched against names, organizations, emails and phone numbers. */
-  query: z36.string().min(1).max(256),
-  limit: z36.int().min(1).max(200).default(25)
+  query: z37.string().min(1).max(256),
+  limit: z37.int().min(1).max(200).default(25)
 });
-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({
+var ContactLabeled = z37.strictObject({ label: z37.string().nullable(), value: z37.string() });
+var ContactSummary = z37.strictObject({
+  id: z37.string(),
+  name: z37.string(),
+  organization: z37.string().nullable(),
+  emails: z37.array(ContactLabeled),
+  phones: z37.array(ContactLabeled)
+});
+var ContactsSearchResult = z37.strictObject({ contacts: z37.array(ContactSummary) });
+var ContactsGetParams = z37.strictObject({ id: z37.string().min(1).max(256) });
+var ContactDetail = z37.strictObject({
+  id: z37.string(),
+  name: z37.string(),
+  organization: z37.string().nullable(),
+  job_title: z37.string().nullable(),
+  emails: z37.array(ContactLabeled),
+  phones: z37.array(ContactLabeled),
+  addresses: z37.array(ContactLabeled),
+  birthday: z37.string().nullable(),
+  note: z37.string().nullable()
+});
+var ContactsGetResult = z37.strictObject({ contact: ContactDetail });
+var CalendarListParams = z37.strictObject({
   from_ms: epochMs,
   to_ms: epochMs,
   /** One calendar's name; absent: every calendar. */
-  calendar: z36.string().min(1).max(256).optional(),
-  limit: z36.int().min(1).max(500).default(100)
+  calendar: z37.string().min(1).max(256).optional(),
+  limit: z37.int().min(1).max(500).default(100)
 });
-var CalendarEvent = z36.strictObject({
-  id: z36.string(),
-  title: z36.string(),
+var CalendarEvent = z37.strictObject({
+  id: z37.string(),
+  title: z37.string(),
   start_ms: epochMs,
   end_ms: epochMs,
-  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),
+  all_day: z37.boolean(),
+  calendar: z37.string(),
+  location: z37.string().nullable(),
+  notes: z37.string().nullable()
+});
+var CalendarListResult = z37.strictObject({ events: z37.array(CalendarEvent) });
+var CalendarCreateParams = z37.strictObject({
+  title: z37.string().min(1).max(1024),
   start_ms: epochMs,
   end_ms: epochMs,
-  all_day: z36.boolean().default(false),
+  all_day: z37.boolean().default(false),
   /** The calendar's name; absent: the first writable calendar. */
-  calendar: z36.string().min(1).max(256).optional(),
-  location: z36.string().max(1024).optional(),
+  calendar: z37.string().min(1).max(256).optional(),
+  location: z37.string().max(1024).optional(),
   notes: Text.optional()
 });
-var CalendarCreateResult = z36.strictObject({ id: z36.string(), calendar: z36.string() });
-var RemindersListParams = z36.strictObject({
+var CalendarCreateResult = z37.strictObject({ id: z37.string(), calendar: z37.string() });
+var RemindersListParams = z37.strictObject({
   /** One list's name; absent: every list. */
-  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(),
+  list: z37.string().min(1).max(256).optional(),
+  include_completed: z37.boolean().default(false),
+  limit: z37.int().min(1).max(500).default(100)
+});
+var Reminder = z37.strictObject({
+  id: z37.string(),
+  title: z37.string(),
+  list: z37.string(),
   due_ms: epochMs.nullable(),
-  completed: z36.boolean(),
-  notes: z36.string().nullable()
+  completed: z37.boolean(),
+  notes: z37.string().nullable()
 });
-var RemindersListResult = z36.strictObject({ reminders: z36.array(Reminder) });
-var RemindersCreateParams = z36.strictObject({
-  title: z36.string().min(1).max(1024),
+var RemindersListResult = z37.strictObject({ reminders: z37.array(Reminder) });
+var RemindersCreateParams = z37.strictObject({
+  title: z37.string().min(1).max(1024),
   due_ms: epochMs.optional(),
-  list: z36.string().min(1).max(256).optional(),
+  list: z37.string().min(1).max(256).optional(),
   notes: Text.optional()
 });
-var RemindersCreateResult = z36.strictObject({ id: z36.string(), list: z36.string() });
-var PhotosSearchParams = z36.strictObject({
+var RemindersCreateResult = z37.strictObject({ id: z37.string(), list: z37.string() });
+var PhotosSearchParams = z37.strictObject({
   /** Matched against file names, titles, descriptions and keywords; absent: the newest. */
-  query: z36.string().min(1).max(256).optional(),
+  query: z37.string().min(1).max(256).optional(),
   from_ms: epochMs.optional(),
   to_ms: epochMs.optional(),
-  favorites_only: z36.boolean().default(false),
-  limit: z36.int().min(1).max(200).default(25)
+  favorites_only: z37.boolean().default(false),
+  limit: z37.int().min(1).max(200).default(25)
 });
-var Photo = z36.strictObject({
-  id: z36.string(),
-  filename: z36.string(),
+var Photo = z37.strictObject({
+  id: z37.string(),
+  filename: z37.string(),
   taken_at_ms: epochMs.nullable(),
   width: nonNegInt.nullable(),
   height: nonNegInt.nullable(),
-  favorite: z36.boolean(),
-  title: z36.string().nullable()
+  favorite: z37.boolean(),
+  title: z37.string().nullable()
 });
-var PhotosSearchResult = z36.strictObject({ photos: z36.array(Photo) });
-var PhotosGetParams = z36.strictObject({
-  id: z36.string().min(1).max(256),
+var PhotosSearchResult = z37.strictObject({ photos: z37.array(Photo) });
+var PhotosGetParams = z37.strictObject({
+  id: z37.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: z36.boolean().default(false)
+  export: z37.boolean().default(false)
 });
-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),
+var PhotosGetResult = z37.strictObject({ photo: Photo, path: z37.string().nullable() });
+var LocationGetParams = z37.strictObject({ timeout_s: z37.int().min(1).max(60).default(15) });
+var LocationGetResult = z37.strictObject({
+  latitude: z37.number().min(-90).max(90),
+  longitude: z37.number().min(-180).max(180),
   /** Metres; null where the OS does not say. */
-  accuracy_m: z36.number().min(0).nullable(),
+  accuracy_m: z37.number().min(0).nullable(),
   at_ms: epochMs,
   /** Who answered: the OS's own location service. */
-  source: z36.enum(["corelocation", "windows", "geoclue"])
+  source: z37.enum(["corelocation", "windows", "geoclue"])
 });
 
 // src/schema/windows.ts
-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({
+import { z as z38 } from "zod";
+var RegistryKey = z38.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 = z38.enum(["REG_SZ", "REG_EXPAND_SZ", "REG_MULTI_SZ", "REG_DWORD", "REG_QWORD", "REG_BINARY", "REG_NONE"]);
+var WindowsRegistryReadParams = z38.strictObject({
   key: RegistryKey,
   /** One value's name ("" is the key's default value); absent: every value and the subkeys. */
-  name: z37.string().max(16383).optional()
+  name: z38.string().max(16383).optional()
 });
-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 RegistryValue = z38.strictObject({ name: z38.string(), type: RegistryValueType, data: z38.string() });
+var WindowsRegistryReadResult = z38.strictObject({
+  key: z38.string(),
+  exists: z38.boolean(),
+  values: z38.array(RegistryValue),
+  subkeys: z38.array(z38.string())
 });
-var WindowsRegistryWriteParams = z37.strictObject({
+var WindowsRegistryWriteParams = z38.strictObject({
   key: RegistryKey,
-  name: z37.string().max(16383),
+  name: z38.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: z37.string().max(1048576),
+  data: z38.string().max(1048576),
   /** Remove the value instead of writing it. */
-  delete: z37.boolean().default(false)
+  delete: z38.boolean().default(false)
 });
-var WindowsRegistryWriteResult = z37.strictObject({ key: z37.string(), name: z37.string(), deleted: z37.boolean() });
-var WindowsServicesParams = z37.strictObject({
+var WindowsRegistryWriteResult = z38.strictObject({ key: z38.string(), name: z38.string(), deleted: z38.boolean() });
+var WindowsServicesParams = z38.strictObject({
   /** Matched against the service's name and display name. */
-  filter: z37.string().min(1).max(256).optional(),
-  limit: z37.int().min(1).max(1e3).default(200)
+  filter: z38.string().min(1).max(256).optional(),
+  limit: z38.int().min(1).max(1e3).default(200)
 });
-var WindowsService = z37.strictObject({
-  name: z37.string(),
-  display_name: z37.string(),
+var WindowsService = z38.strictObject({
+  name: z38.string(),
+  display_name: z38.string(),
   /** Running, Stopped, Paused… as Windows says it. */
-  status: z37.string(),
+  status: z38.string(),
   /** Automatic, Manual, Disabled…; null where Windows does not say. */
-  start_type: z37.string().nullable()
+  start_type: z38.string().nullable()
 });
-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 WindowsServicesResult = z38.strictObject({ services: z38.array(WindowsService) });
+var WindowsServiceControlParams = z38.strictObject({
+  name: z38.string().min(1).max(256),
+  action: z38.enum(["start", "stop", "restart"])
 });
-var WindowsServiceControlResult = z37.strictObject({ name: z37.string(), status: z37.string() });
-var WindowsEventLogParams = z37.strictObject({
-  log: z37.string().min(1).max(256).default("System"),
+var WindowsServiceControlResult = z38.strictObject({ name: z38.string(), status: z38.string() });
+var WindowsEventLogParams = z38.strictObject({
+  log: z38.string().min(1).max(256).default("System"),
   /** Only these levels; absent: all. */
-  levels: z37.array(z37.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
+  levels: z38.array(z38.enum(["critical", "error", "warning", "information", "verbose"])).max(5).optional(),
   since_ms: epochMs.optional(),
-  limit: z37.int().min(1).max(500).default(50)
+  limit: z38.int().min(1).max(500).default(50)
 });
-var WindowsEvent = z37.strictObject({
-  id: z37.int(),
-  level: z37.string(),
-  source: z37.string(),
+var WindowsEvent = z38.strictObject({
+  id: z38.int(),
+  level: z38.string(),
+  source: z38.string(),
   at_ms: epochMs,
-  message: z37.string()
+  message: z38.string()
 });
-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) });
+var WindowsEventLogResult = z38.strictObject({ log: z38.string(), events: z38.array(WindowsEvent) });
+var WindowsFeaturesParams = z38.strictObject({ filter: z38.string().min(1).max(256).optional() });
+var WindowsFeature = z38.strictObject({ name: z38.string(), state: z38.string() });
+var WindowsFeaturesResult = z38.strictObject({ features: z38.array(WindowsFeature) });
 
 // src/schema/schedule.ts
-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),
+import { z as z39 } from "zod";
+var OpRef = z39.string().min(3).max(128).regex(/^[a-z_]+(\.[a-z_]+)+$/);
+var ScheduleCreateParams = z39.strictObject({
+  name: z39.string().min(1).max(200),
   op: OpRef,
   /** The op's params, exactly as the op takes them; checked when the task is created. */
-  params: z38.record(z38.string(), z38.unknown()).default({}),
-  interval_s: z38.int().min(10).max(2592e3),
+  params: z39.record(z39.string(), z39.unknown()).default({}),
+  interval_s: z39.int().min(10).max(2592e3),
   /** Stop after this many runs; absent: until cancelled. */
-  max_runs: z38.int().min(1).max(1e5).optional(),
+  max_runs: z39.int().min(1).max(1e5).optional(),
   /** Run once now, before the first interval. */
-  run_now: z38.boolean().default(false)
+  run_now: z39.boolean().default(false)
 });
-var ScheduleRun = z38.strictObject({
+var ScheduleRun = z39.strictObject({
   at_ms: epochMs,
-  ok: z38.boolean(),
+  ok: z39.boolean(),
   elapsed_ms: nonNegInt,
   /** The error's code and message when the run failed. */
-  error: z38.string().nullable(),
+  error: z39.string().nullable(),
   /** The start of the answer, as JSON (cut at 4 KiB). */
-  result_preview: z38.string().nullable()
+  result_preview: z39.string().nullable()
 });
-var ScheduledTask = z38.strictObject({
-  id: z38.string(),
-  name: z38.string(),
-  op: z38.string(),
-  params: z38.record(z38.string(), z38.unknown()),
+var ScheduledTask = z39.strictObject({
+  id: z39.string(),
+  name: z39.string(),
+  op: z39.string(),
+  params: z39.record(z39.string(), z39.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: z38.enum(["active", "done", "cancelled"]),
+  state: z39.enum(["active", "done", "cancelled"]),
   /** The newest runs, newest first (at most 10). */
-  recent: z38.array(ScheduleRun)
+  recent: z39.array(ScheduleRun)
 });
-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 });
+var ScheduleCreateResult = z39.strictObject({ task: ScheduledTask });
+var ScheduleListParams = z39.strictObject({ include_finished: z39.boolean().default(false) });
+var ScheduleListResult = z39.strictObject({ tasks: z39.array(ScheduledTask) });
+var ScheduleCancelParams = z39.strictObject({ id: z39.string().min(1).max(64) });
+var ScheduleCancelResult = z39.strictObject({ task: ScheduledTask });
 
 // src/schema/notes.ts
-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({
+import { z as z40 } from "zod";
+var NoteFolder = z40.string().min(1).max(512).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*$/);
+var NotePath = z40.string().min(4).max(1024).regex(/^[^/\\:*?"<>|][^\\:*?"<>|]*\.md$/);
+var NotesFoldersParams = z40.strictObject({});
+var NotesFolder = z40.strictObject({ folder: z40.string(), notes: nonNegInt });
+var NotesFoldersResult = z40.strictObject({
   /** The notes root on this computer. */
-  root: z39.string(),
-  folders: z39.array(NotesFolder)
+  root: z40.string(),
+  folders: z40.array(NotesFolder)
 });
-var NotesListParams = z39.strictObject({
+var NotesListParams = z40.strictObject({
   folder: NoteFolder.optional(),
-  limit: z39.int().min(1).max(2e3).default(500)
+  limit: z40.int().min(1).max(2e3).default(500)
 });
-var NoteEntry = z39.strictObject({
-  path: z39.string(),
-  label: z39.string(),
-  folder: z39.string(),
+var NoteEntry = z40.strictObject({
+  path: z40.string(),
+  label: z40.string(),
+  folder: z40.string(),
   bytes: nonNegInt,
   modified_at_ms: epochMs
 });
-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(),
+var NotesListResult = z40.strictObject({ root: z40.string(), notes: z40.array(NoteEntry), total: nonNegInt });
+var NotesReadParams = z40.strictObject({ path: NotePath });
+var NotesReadResult = z40.strictObject({
+  path: z40.string(),
+  content: z40.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: z39.string()
+  hash: z40.string()
 });
-var NotesWriteParams = z39.strictObject({
+var NotesWriteParams = z40.strictObject({
   folder: NoteFolder.default("General"),
   /** The note's name, without ".md". */
-  label: z39.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
-  content: z39.string().max(10485760),
+  label: z40.string().min(1).max(200).regex(/^[^/\\:*?"<>|]+$/),
+  content: z40.string().max(10485760),
   /** Write only when the note is still this version (notes.read's hash); a change since answers CONFLICT. */
-  if_hash: z39.string().length(64).optional()
+  if_hash: z40.string().length(64).optional()
 });
-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 NotesWriteResult = z40.strictObject({ path: z40.string(), bytes: nonNegInt, created: z40.boolean(), hash: z40.string() });
+var NotesSearchParams = z40.strictObject({
+  query: z40.string().min(1).max(512),
+  limit: z40.int().min(1).max(200).default(50)
 });
-var NotesMatch = z39.strictObject({
-  path: z39.string(),
-  label: z39.string(),
-  folder: z39.string(),
+var NotesMatch = z40.strictObject({
+  path: z40.string(),
+  label: z40.string(),
+  folder: z40.string(),
   /** The matching lines (at most five), trimmed. */
-  lines: z39.array(z39.string())
+  lines: z40.array(z40.string())
 });
-var NotesSearchResult = z39.strictObject({ matches: z39.array(NotesMatch), total: nonNegInt });
+var NotesSearchResult = z40.strictObject({ matches: z40.array(NotesMatch), total: nonNegInt });
 
 // src/schema/documents.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var DOCUMENTS_MAX_TEXT_CHARS = 1048576;
-var DocumentsPdfTextParams = z40.strictObject({
+var DocumentsPdfTextParams = z41.strictObject({
   path: AbsPath,
   /** 1-based, inclusive. */
-  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)
+  first_page: z41.int().min(1).optional(),
+  last_page: z41.int().min(1).optional(),
+  max_chars: z41.int().min(1).max(DOCUMENTS_MAX_TEXT_CHARS).default(2e5)
 });
-var DocumentsPdfPage = z40.strictObject({ page: z40.int().min(1), text: z40.string() });
-var DocumentsPdfTextResult = z40.strictObject({
+var DocumentsPdfPage = z41.strictObject({ page: z41.int().min(1), text: z41.string() });
+var DocumentsPdfTextResult = z41.strictObject({
   pages: nonNegInt,
   /** Each page read, in order (an image-only page has empty text: OCR it). */
-  read: z40.array(DocumentsPdfPage),
-  truncated: z40.boolean(),
-  title: z40.string().nullable(),
-  author: z40.string().nullable()
+  read: z41.array(DocumentsPdfPage),
+  truncated: z41.boolean(),
+  title: z41.string().nullable(),
+  author: z41.string().nullable()
 });
-var DocumentsOcrParams = z40.strictObject({
+var DocumentsOcrParams = z41.strictObject({
   path: AbsPath,
   /** BCP-47 language hints ("en-US", "fr-FR"); absent: the OS's own choice. */
-  languages: z40.array(z40.string().min(2).max(16)).max(8).optional(),
+  languages: z41.array(z41.string().min(2).max(16)).max(8).optional(),
   /** Faster, less accurate. */
-  fast: z40.boolean().default(false)
+  fast: z41.boolean().default(false)
 });
-var DocumentsOcrLine = z40.strictObject({
-  text: z40.string(),
+var DocumentsOcrLine = z41.strictObject({
+  text: z41.string(),
   /** 0–1; null where the engine does not say. */
-  confidence: z40.number().min(0).max(1).nullable()
+  confidence: z41.number().min(0).max(1).nullable()
 });
-var DocumentsOcrResult = z40.strictObject({
-  text: z40.string(),
-  lines: z40.array(DocumentsOcrLine),
-  truncated: z40.boolean(),
+var DocumentsOcrResult = z41.strictObject({
+  text: z41.string(),
+  lines: z41.array(DocumentsOcrLine),
+  truncated: z41.boolean(),
   /** Which engine read it ("vision" on macOS, "windows-ocr", "tesseract"). */
-  engine: z40.string()
+  engine: z41.string()
 });
-var DocumentsImageResizeParams = z40.strictObject({
+var DocumentsImageResizeParams = z41.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: z40.int().min(1).max(32768).optional(),
-  format: z40.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
-  overwrite: z40.boolean().default(false)
+  max_size: z41.int().min(1).max(32768).optional(),
+  format: z41.enum(["png", "jpeg", "tiff", "heic", "bmp", "gif"]).optional(),
+  overwrite: z41.boolean().default(false)
 });
-var DocumentsImageResizeResult = z40.strictObject({
-  path: z40.string(),
+var DocumentsImageResizeResult = z41.strictObject({
+  path: z41.string(),
   width: nonNegInt,
   height: nonNegInt,
   bytes: nonNegInt
 });
-var DocumentsParagraph = z40.strictObject({
-  style: z40.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
-  text: z40.string().max(1e5)
+var DocumentsParagraph = z41.strictObject({
+  style: z41.enum(["title", "heading1", "heading2", "heading3", "body", "bullet", "numbered", "quote", "code"]).default("body"),
+  text: z41.string().max(1e5)
 });
-var DocumentsSheet = z40.strictObject({
-  name: z40.string().min(1).max(31),
+var DocumentsSheet = z41.strictObject({
+  name: z41.string().min(1).max(31),
   /** Rows of cells; the first row is the header when `header` is 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)
+  rows: z41.array(z41.array(z41.union([z41.string().max(32767), z41.number(), z41.boolean(), z41.null()])).max(16384)).max(1e5),
+  header: z41.boolean().default(true)
 });
-var DocumentsOfficeGenerateParams = z40.strictObject({
-  kind: z40.enum(["docx", "xlsx"]),
+var DocumentsOfficeGenerateParams = z41.strictObject({
+  kind: z41.enum(["docx", "xlsx"]),
   path: AbsPath,
-  title: z40.string().max(1024).optional(),
+  title: z41.string().max(1024).optional(),
   /** docx: the document's paragraphs, in order. */
-  paragraphs: z40.array(DocumentsParagraph).max(5e4).optional(),
+  paragraphs: z41.array(DocumentsParagraph).max(5e4).optional(),
   /** xlsx: the workbook's sheets, in order. */
-  sheets: z40.array(DocumentsSheet).min(1).max(64).optional(),
-  overwrite: z40.boolean().default(false)
+  sheets: z41.array(DocumentsSheet).min(1).max(64).optional(),
+  overwrite: z41.boolean().default(false)
 });
-var DocumentsOfficeGenerateResult = z40.strictObject({ path: z40.string(), bytes: nonNegInt });
-var EntitiesNerParams = z40.strictObject({
-  text: z40.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+var DocumentsOfficeGenerateResult = z41.strictObject({ path: z41.string(), bytes: nonNegInt });
+var EntitiesNerParams = z41.strictObject({
+  text: z41.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
   /** Which kinds to keep; absent: all three. */
-  labels: z40.array(z40.enum(["person", "place", "organization"])).min(1).max(3).optional()
+  labels: z41.array(z41.enum(["person", "place", "organization"])).min(1).max(3).optional()
 });
-var EntitySpan = z40.strictObject({
-  text: z40.string(),
-  label: z40.string(),
+var EntitySpan = z41.strictObject({
+  text: z41.string(),
+  label: z41.string(),
   /** Character offsets into the text (UTF-16, as JavaScript counts). */
   start: nonNegInt,
   end: nonNegInt
 });
-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(),
+var EntitiesNerResult = z41.strictObject({ entities: z41.array(EntitySpan), engine: z41.string() });
+var PiiKind = z41.enum(["email", "phone", "credit_card", "us_ssn", "iban", "ip_address", "url", "api_key"]);
+var EntitiesPiiParams = z41.strictObject({
+  text: z41.string().min(1).max(DOCUMENTS_MAX_TEXT_CHARS),
+  kinds: z41.array(PiiKind).min(1).max(8).optional(),
   /** Also answer the text with each finding replaced by its kind ("[email]"). */
-  redact: z40.boolean().default(false)
+  redact: z41.boolean().default(false)
 });
-var EntitiesPiiResult = z40.strictObject({
-  findings: z40.array(z40.strictObject({ kind: PiiKind, text: z40.string(), start: nonNegInt, end: nonNegInt })),
-  redacted: z40.string().nullable()
+var EntitiesPiiResult = z41.strictObject({
+  findings: z41.array(z41.strictObject({ kind: PiiKind, text: z41.string(), start: nonNegInt, end: nonNegInt })),
+  redacted: z41.string().nullable()
 });
 
 // src/schema/registry.ts
@@ -4268,6 +4350,9 @@ var OPS = {
   "apps.windows.refresh_usage": { params: AppsWindowsRefreshUsageParams, result: AppsWindowActionResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "TIMEOUT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.accounts.usage": { params: AppsAccountsUsageParams, result: AppsAccountsUsageResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.accounts.resets": { params: AppsAccountsResetsParams, result: AppsAccountsResetsResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  // 1.47: instances and accounts kept apart — an account's usage is the account's, every instance shows it by id.
+  "apps.instances.list": { params: AppsInstancesListParams, result: AppsInstancesListResult, kind: "unary", since: "1.47", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.accounts.list": { params: AppsAccountsListParams, result: AppsAccountsListResult, kind: "unary", since: "1.47", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.projects.move": { params: AppsProjectsMoveParams, result: AppsProjectsMoveResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.projects.create": { params: AppsProjectsCreateParams, result: AppsProjectsCreateResult, kind: "unary", since: "1.10", errors: ["INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "apps.projects.import_pins": { params: AppsProjectsImportPinsParams, result: AppsProjectsImportPinsResult, kind: "unary", since: "1.10", errors: ["CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
@@ -4528,6 +4613,16 @@ var SERVICES = {
   }
 };
 var NAMED_SCHEMAS = {
+  InstanceStatus,
+  AppInstall,
+  AppInstance,
+  AccountResetSource,
+  AccountGap,
+  AppAccount,
+  AppsInstancesListParams,
+  AppsInstancesListResult,
+  AppsAccountsListParams,
+  AppsAccountsListResult,
   ProtocolVersion,
   RequestId,
   ResourceId,
@@ -5489,7 +5584,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 = "017953b60f9c7e60376f18d993d10bc22debd8a6e9e4bf76d76e6f95e11acf26";
+var CONTRACT_SHA256 = "502c8718b1d2fd0fde43daed047da5a7b158f81ffa3846c7d73cda879777fe37";
 
 // src/close-policy.ts
 var CLOSE_RULES = {
@@ -5900,16 +5995,21 @@ export {
   AccountAgentsListResult,
   AccountAgentsRunsParams,
   AccountAgentsRunsResult,
+  AccountGap,
   AccountReadState,
   AccountReset,
+  AccountResetSource,
   AccountRowId,
   AccountUsage,
   AccountVaultCopyParams,
   AccountVaultCopyResult,
   AccountVaultListParams,
   AccountVaultListResult,
+  AppAccount,
   AppFeatureStatus,
   AppInfo,
+  AppInstall,
+  AppInstance,
   AppKey,
   AppProfile,
   AppProfileId,
@@ -5917,6 +6017,8 @@ export {
   AppSupport,
   AppUsageReading,
   AppWindowInfo,
+  AppsAccountsListParams,
+  AppsAccountsListResult,
   AppsAccountsResetsParams,
   AppsAccountsResetsResult,
   AppsAccountsUsageParams,
@@ -5938,6 +6040,8 @@ export {
   AppsChatsWatchParams,
   AppsChatsWatchResult,
   AppsChatsWatchStateEvent,
+  AppsInstancesListParams,
+  AppsInstancesListResult,
   AppsListParams,
   AppsListResult,
   AppsOpenParams,
@@ -6331,6 +6435,7 @@ export {
   InputSetKeyboardSettingsParams,
   InputTypeTextParams,
   InputTypeTextResult,
+  InstanceStatus,
   LEGACY_ACTIONS,
   LEGACY_DISPATCHERS,
   Limits,