@ai-matrx/desktop-protocol 0.17.3 → 0.17.5

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/schema/primitives.ts
 import { z } from "zod";
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 7;
+var PROTOCOL_MINOR = 9;
 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_-]+$/);
@@ -891,250 +891,394 @@ var AppsOpenResult = z11.strictObject({
   folder: AbsPath.nullable()
 });
 
-// src/schema/service.ts
+// src/schema/apps-chats.ts
 import { z as z12 } from "zod";
+var ChatId = z12.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/);
+var ChatPlace = z12.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/);
+var ChatProjectId = z12.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+var ChatWindow = z12.strictObject({
+  key: ChatPlace,
+  /** The app's default profile (Claude: the main window, which lists every account's chats). */
+  main: z12.boolean(),
+  /** The account the window is signed into, when known. */
+  account: z12.string().max(320).nullable()
+});
+var ChatProject = z12.strictObject({
+  id: ChatProjectId,
+  name: z12.string().min(1).max(200),
+  archived: z12.boolean(),
+  /** Chats in it. */
+  count: nonNegInt
+});
+var ChatPin = z12.strictObject({
+  /** The window whose account pins it; an account with no window of its own is named by its email. */
+  window: z12.string().min(1).max(320),
+  /** When that account's pin list was last read; null when the reading has no time. */
+  observed_at_ms: epochMs.nullable()
+});
+var ChatRunning = z12.strictObject({
+  window: ChatPlace,
+  /** process: a live process resumed this chat there (exact); activity: that window's own record moved in the last 3 minutes. */
+  how: z12.enum(["process", "activity"])
+});
+var ChatHidden = z12.strictObject({
+  window: ChatPlace,
+  reason: z12.string().max(200)
+});
+var ChatLastUse = z12.strictObject({
+  /** The conversation's last reply. */
+  at_ms: epochMs,
+  window: ChatPlace.nullable(),
+  account: z12.string().max(320).nullable(),
+  /** How the window was decided (one short line). */
+  how: z12.string().max(120).nullable(),
+  /** The account's 1-hour prompt cache is still warm. */
+  cache_warm: z12.boolean(),
+  cache_minutes_left: nonNegInt
+});
+var ChatRow = z12.strictObject({
+  id: ChatId,
+  /** The short id people see (the listing's first 8 characters). */
+  short_id: z12.string().max(16),
+  /** The listing's own name (Claude: local_<id>), null for a chat only in the holder. */
+  record: z12.string().max(160).nullable(),
+  title: z12.string().max(1e3),
+  last_active_ms: epochMs.nullable(),
+  created_ms: epochMs.nullable(),
+  projects: z12.array(ChatProjectId).max(500),
+  starred: z12.boolean(),
+  pinned_in: z12.array(ChatPin).max(200),
+  /** Every place it is listed now: window keys, plus "holder". */
+  places: z12.array(ChatPlace).max(200),
+  held: z12.boolean(),
+  running: z12.array(ChatRunning).max(200),
+  hidden_in: z12.array(ChatHidden).max(200),
+  /** Kept out of the main window on purpose. */
+  hidden_from_main: z12.boolean(),
+  /** Listed in a side window and not yet copied into main. */
+  main_pending: z12.boolean(),
+  /** A scheduled routine's run (its task id). */
+  scheduled: z12.string().max(200).nullable(),
+  /** Created recently and in no project: offered for filing. */
+  new_unfiled: z12.boolean(),
+  warnings: z12.array(z12.string().max(400)).max(20),
+  last_use: ChatLastUse.nullable()
+});
+var AppsChatsListParams = z12.strictObject({
+  app_key: AppKey,
+  /** Only these chats (a live update re-reads just what changed). */
+  ids: z12.array(ChatId).max(500).optional()
+});
+var AppsChatsListResult = z12.strictObject({
+  app_key: AppKey,
+  /** Bumps on every change the index sees; `apps.chats.changed` carries the same number. */
+  version: nonNegInt,
+  windows: z12.array(ChatWindow).max(200),
+  projects: z12.array(ChatProject).max(5e3),
+  chats: z12.array(ChatRow).max(2e4),
+  /** How long a chat in no project counts as new. */
+  new_window_ms: nonNegInt,
+  /** 1.9: this is the copy saved at the last read, shown while everything is read again. */
+  updating: z12.boolean().optional(),
+  /** 1.9: false while the folder watches are down (changes are not arriving); `apps.chats.watch_state` says when it changes. */
+  live: z12.boolean().optional()
+});
+var AppsChatsWatchParams = z12.strictObject({ app_key: AppKey });
+var AppsChatsWatchResult = z12.strictObject({ resource_id: ResourceId, version: nonNegInt });
+var AppsChatsChangedEvent = z12.strictObject({
+  app_key: AppKey,
+  version: nonNegInt,
+  ids: z12.array(ChatId).max(1e3),
+  all: z12.boolean()
+});
+var AppsChatsWatchStateEvent = z12.strictObject({
+  app_key: AppKey,
+  live: z12.boolean(),
+  updating: z12.boolean(),
+  reason: z12.string().max(300).nullable()
+});
+var AppsChatsPlaceParams = z12.strictObject({
+  app_key: AppKey,
+  chat_id: ChatId,
+  action: z12.enum(["place", "take_off", "hold"]),
+  /** The window (for place and take_off). */
+  window: ChatPlace.optional(),
+  /** take_off where it is open: stop it there first (the person confirmed). */
+  stop_if_open: z12.boolean().default(false)
+});
+var AppsChatsPlaceResult = z12.strictObject({ chat: ChatRow, message: z12.string().max(400) });
+var AppsProjectsFileManyParams = z12.strictObject({
+  app_key: AppKey,
+  chat_ids: z12.array(ChatId).min(1).max(500),
+  project_id: ChatProjectId.optional(),
+  new_project_name: z12.string().min(1).max(200).optional()
+});
+var AppsProjectsFileManyResult = z12.strictObject({ chats: z12.array(ChatRow).max(500), project: ChatProject });
+var AppsProjectsUpdateParams = z12.strictObject({
+  app_key: AppKey,
+  project_id: ChatProjectId,
+  name: z12.string().min(1).max(200).optional(),
+  archived: z12.boolean().optional()
+});
+var AppsProjectsUpdateResult = z12.strictObject({ project: ChatProject });
+var AppsProjectsCopyParams = z12.strictObject({ app_key: AppKey, project_id: ChatProjectId, new_project_name: z12.string().min(1).max(200) });
+var AppsProjectsCopyResult = z12.strictObject({ project: ChatProject });
+var AppsProjectsFileParams = z12.strictObject({
+  app_key: AppKey,
+  chat_id: ChatId,
+  project_id: ChatProjectId.optional(),
+  new_project_name: z12.string().min(1).max(200).optional()
+});
+var AppsProjectsFileResult = z12.strictObject({ chat: ChatRow, project: ChatProject });
+var AppsProjectsUnfileParams = z12.strictObject({ app_key: AppKey, chat_id: ChatId, project_id: ChatProjectId });
+var AppsProjectsUnfileResult = z12.strictObject({ chat: ChatRow });
+var AppsChatsStarParams = z12.strictObject({ app_key: AppKey, chat_id: ChatId, starred: z12.boolean() });
+var AppsChatsStarResult = z12.strictObject({ chat: ChatRow });
+
+// src/schema/service.ts
+import { z as z13 } from "zod";
 var SERVICE_MAX_FRAME_BYTES = 16777216;
-var ServiceName = z12.enum(["ml", "coding"]);
-var ContractHash = z12.string().regex(/^[0-9a-f]{64}$/);
-var ServiceToken = z12.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var ServiceName = z13.enum(["ml", "coding"]);
+var ContractHash = z13.string().regex(/^[0-9a-f]{64}$/);
+var ServiceToken = z13.string().regex(/^[A-Za-z0-9_-]{43}$/);
 var ServiceRequestId = u32;
-var ServiceHello = z12.strictObject({ type: z12.literal("hello"), token: ServiceToken, contract: ContractHash });
-var ServiceWelcome = z12.strictObject({
-  type: z12.literal("welcome"),
+var ServiceHello = z13.strictObject({ type: z13.literal("hello"), token: ServiceToken, contract: ContractHash });
+var ServiceWelcome = z13.strictObject({
+  type: z13.literal("welcome"),
   service: ServiceName,
   contract: ContractHash,
   pid: nonNegInt,
   /** The interpreter's version, e.g. "3.13.15". */
-  python: z12.string().max(32),
+  python: z13.string().max(32),
   /** Every op this service serves; must equal SERVICES[service] exactly. */
-  ops: z12.array(z12.string().min(1).max(64)).max(64)
+  ops: z13.array(z13.string().min(1).max(64)).max(64)
 });
-var ServiceRequest = z12.strictObject({
-  type: z12.literal("request"),
+var ServiceRequest = z13.strictObject({
+  type: z13.literal("request"),
   id: ServiceRequestId,
-  op: z12.string().min(1).max(64),
-  params: z12.unknown()
+  op: z13.string().min(1).max(64),
+  params: z13.unknown()
   // validated by the service against SERVICES[service][op].params
 });
-var ServiceResponse = z12.strictObject({
-  type: z12.literal("response"),
+var ServiceResponse = z13.strictObject({
+  type: z13.literal("response"),
   id: ServiceRequestId,
-  result: z12.unknown()
+  result: z13.unknown()
   // validated by the core against SERVICES[service][op].result
 });
-var ServiceErrorMsg = z12.strictObject({ type: z12.literal("error"), id: ServiceRequestId, error: ProtocolErrorBody });
-var ServiceProgressMsg = z12.strictObject({ type: z12.literal("progress"), id: ServiceRequestId, progress: z12.unknown() });
-var ServiceCancel = z12.strictObject({ type: z12.literal("cancel"), id: ServiceRequestId });
-var ServicePing = z12.strictObject({ type: z12.literal("ping"), id: ServiceRequestId });
-var ServicePong = z12.strictObject({
-  type: z12.literal("pong"),
+var ServiceErrorMsg = z13.strictObject({ type: z13.literal("error"), id: ServiceRequestId, error: ProtocolErrorBody });
+var ServiceProgressMsg = z13.strictObject({ type: z13.literal("progress"), id: ServiceRequestId, progress: z13.unknown() });
+var ServiceCancel = z13.strictObject({ type: z13.literal("cancel"), id: ServiceRequestId });
+var ServicePing = z13.strictObject({ type: z13.literal("ping"), id: ServiceRequestId });
+var ServicePong = z13.strictObject({
+  type: z13.literal("pong"),
   id: ServiceRequestId,
   /** Requests running now. */
   busy: nonNegInt
 });
-var ServiceShutdown = z12.strictObject({ type: z12.literal("shutdown") });
-var CoreToServiceMsg = z12.discriminatedUnion("type", [ServiceHello, ServiceRequest, ServiceCancel, ServicePing, ServiceShutdown]);
-var ServiceToCoreMsg = z12.discriminatedUnion("type", [ServiceWelcome, ServiceResponse, ServiceErrorMsg, ServiceProgressMsg, ServicePong]);
+var ServiceShutdown = z13.strictObject({ type: z13.literal("shutdown") });
+var CoreToServiceMsg = z13.discriminatedUnion("type", [ServiceHello, ServiceRequest, ServiceCancel, ServicePing, ServiceShutdown]);
+var ServiceToCoreMsg = z13.discriminatedUnion("type", [ServiceWelcome, ServiceResponse, ServiceErrorMsg, ServiceProgressMsg, ServicePong]);
 
 // src/schema/tools.ts
-import { z as z13 } from "zod";
-var ToolLevel = z13.enum(["programmatic", "protocol", "chat"]);
-var ToolOutcome = z13.enum(["pass", "fail", "skip"]);
-var ToolPlatform = z13.enum(["darwin", "win32", "linux"]);
-var ToolTransport = z13.enum(["in_process", "localhost", "relay", "agent"]);
-var ToolName = z13.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/);
-var ToolLevelResult = z13.strictObject({
+import { z as z14 } from "zod";
+var ToolLevel = z14.enum(["programmatic", "protocol", "chat"]);
+var ToolOutcome = z14.enum(["pass", "fail", "skip"]);
+var ToolPlatform = z14.enum(["darwin", "win32", "linux"]);
+var ToolTransport = z14.enum(["in_process", "localhost", "relay", "agent"]);
+var ToolName = z14.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/);
+var ToolLevelResult = z14.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: z13.boolean(),
+  remote_network: z14.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: z13.string().max(500),
+  detail: z14.string().max(500),
   /** The harness that produced it, e.g. `matrx-desktop test/tools/programmatic.test.ts`. */
-  suite: z13.string().min(1).max(200),
+  suite: z14.string().min(1).max(200),
   /** The test case inside the suite. */
-  test: z13.string().min(1).max(300),
-  run_at_ms: z13.int().min(0)
+  test: z14.string().min(1).max(300),
+  run_at_ms: z14.int().min(0)
 });
-var ToolResultsFile = z13.strictObject({
-  schema: z13.literal("matrx.tool-results.v1"),
+var ToolResultsFile = z14.strictObject({
+  schema: z14.literal("matrx.tool-results.v1"),
   /** The producing repo's commit (short or full SHA). */
-  commit: z13.string().min(4).max(64),
-  results: z13.array(ToolLevelResult).max(1e4)
+  commit: z14.string().min(4).max(64),
+  results: z14.array(ToolLevelResult).max(1e4)
 });
 
 // src/schema/proc.ts
-import { z as z14 } from "zod";
-var ProcSort = z14.enum(["cpu", "memory", "pid", "name"]);
-var ProcListParams = z14.strictObject({
+import { z as z15 } from "zod";
+var ProcSort = z15.enum(["cpu", "memory", "pid", "name"]);
+var ProcListParams = z15.strictObject({
   /** Case-insensitive substring of the process name or its command line. */
-  name: z14.string().min(1).max(128).optional(),
+  name: z15.string().min(1).max(128).optional(),
   sort: ProcSort.default("cpu"),
-  limit: z14.int().min(1).max(500).default(50)
+  limit: z15.int().min(1).max(500).default(50)
 });
-var ProcInfo = z14.strictObject({
-  pid: z14.int().min(0),
+var ProcInfo = z15.strictObject({
+  pid: z15.int().min(0),
   /** Parent process id; null where the OS does not report it. */
-  ppid: z14.int().min(0).nullable(),
-  name: z14.string().max(256),
+  ppid: z15.int().min(0).nullable(),
+  name: z15.string().max(256),
   /** The command line, cut to 1024 characters. */
-  command: z14.string().max(1024),
+  command: z15.string().max(1024),
   /** Share of one core, as `ps` and Task Manager report it; null where the OS does not say. */
-  cpu_percent: z14.number().min(0).nullable(),
+  cpu_percent: z15.number().min(0).nullable(),
   memory_bytes: nonNegInt.nullable(),
-  user: z14.string().max(128).nullable()
+  user: z15.string().max(128).nullable()
 });
-var ProcListResult = z14.strictObject({
-  processes: z14.array(ProcInfo).max(500),
+var ProcListResult = z15.strictObject({
+  processes: z15.array(ProcInfo).max(500),
   /** Processes that matched before `limit`. */
   total: nonNegInt,
-  truncated: z14.boolean()
+  truncated: z15.boolean()
 });
-var ProcPortsParams = z14.strictObject({
+var ProcPortsParams = z15.strictObject({
   /** Only this port. */
-  port: z14.int().min(1).max(65535).optional()
+  port: z15.int().min(1).max(65535).optional()
 });
-var ProcPort = z14.strictObject({
-  port: z14.int().min(1).max(65535),
-  protocol: z14.enum(["tcp", "udp"]),
+var ProcPort = z15.strictObject({
+  port: z15.int().min(1).max(65535),
+  protocol: z15.enum(["tcp", "udp"]),
   /** The local address it listens on ("127.0.0.1", "*", "::"). */
-  address: z14.string().max(64),
-  pid: z14.int().min(0).nullable(),
-  process: z14.string().max(256).nullable()
+  address: z15.string().max(64),
+  pid: z15.int().min(0).nullable(),
+  process: z15.string().max(256).nullable()
 });
-var ProcPortsResult = z14.strictObject({ ports: z14.array(ProcPort).max(4e3) });
-var ProcKillParams = z14.strictObject({
-  pid: z14.int().min(1),
+var ProcPortsResult = z15.strictObject({ ports: z15.array(ProcPort).max(4e3) });
+var ProcKillParams = z15.strictObject({
+  pid: z15.int().min(1),
   /** Kill outright (SIGKILL; on Windows the same /F) instead of asking it to quit. */
-  force: z14.boolean().default(false)
+  force: z15.boolean().default(false)
 });
-var ProcKillResult = z14.strictObject({
-  pid: z14.int().min(1),
-  signal: z14.enum(["SIGTERM", "SIGKILL"]),
+var ProcKillResult = z15.strictObject({
+  pid: z15.int().min(1),
+  signal: z15.enum(["SIGTERM", "SIGKILL"]),
   /** True when the process was gone within 3 s. */
-  exited: z14.boolean()
+  exited: z15.boolean()
 });
 
 // src/schema/clipboard.ts
-import { z as z15 } from "zod";
-var ClipboardReadParams = z15.strictObject({});
-var ClipboardReadResult = z15.strictObject({
+import { z as z16 } from "zod";
+var ClipboardReadParams = z16.strictObject({});
+var ClipboardReadResult = z16.strictObject({
   /** The clipboard's text ("" when it holds none), cut to 1 MiB. */
-  text: z15.string().max(1048576),
-  truncated: z15.boolean()
+  text: z16.string().max(1048576),
+  truncated: z16.boolean()
 });
-var ClipboardWriteParams = z15.strictObject({ text: z15.string().max(1048576) });
-var ClipboardWriteResult = z15.strictObject({ bytes: nonNegInt });
+var ClipboardWriteParams = z16.strictObject({ text: z16.string().max(1048576) });
+var ClipboardWriteResult = z16.strictObject({ bytes: nonNegInt });
 
 // src/schema/system.ts
-import { z as z16 } from "zod";
-var SystemOpenUrlParams = z16.strictObject({
+import { z as z17 } from "zod";
+var SystemOpenUrlParams = z17.strictObject({
   /** http, https or mailto; opened in the person's default app for it. */
-  url: z16.string().min(1).max(4096)
+  url: z17.string().min(1).max(4096)
 });
-var SystemOpenUrlResult = z16.strictObject({ url: z16.string().max(4096) });
-var SystemOpenPathParams = z16.strictObject({
+var SystemOpenUrlResult = z17.strictObject({ url: z17.string().max(4096) });
+var SystemOpenPathParams = z17.strictObject({
   path: AbsPath,
   /** Show it in the file manager (Finder, Explorer) instead of opening it. */
-  reveal: z16.boolean().default(false)
+  reveal: z17.boolean().default(false)
 });
-var SystemOpenPathResult = z16.strictObject({ path: AbsPath, revealed: z16.boolean() });
-var SystemNotifyParams = z16.strictObject({
-  title: z16.string().min(1).max(128),
-  body: z16.string().max(1024).default("")
+var SystemOpenPathResult = z17.strictObject({ path: AbsPath, revealed: z17.boolean() });
+var SystemNotifyParams = z17.strictObject({
+  title: z17.string().min(1).max(128),
+  body: z17.string().max(1024).default("")
 });
-var SystemNotifyResult = z16.strictObject({
+var SystemNotifyResult = z17.strictObject({
   /** False when this computer has no notification service to show it (a bare Linux box). */
-  shown: z16.boolean()
+  shown: z17.boolean()
 });
 
 // src/schema/screen.ts
-import { z as z17 } from "zod";
-var ScreenDisplay = z17.strictObject({
+import { z as z18 } from "zod";
+var ScreenDisplay = z18.strictObject({
   /** The OS's display id; pass it to screen.capture. */
   id: nonNegInt,
-  name: z17.string().max(128),
+  name: z18.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: z17.int(),
-  y: z17.int(),
-  width: z17.int().min(1),
-  height: z17.int().min(1),
+  x: z18.int(),
+  y: z18.int(),
+  width: z18.int().min(1),
+  height: z18.int().min(1),
   /** Pixels per point (2 on a Retina display). */
-  scale: z17.number().min(0.1).max(8),
-  primary: z17.boolean()
+  scale: z18.number().min(0.1).max(8),
+  primary: z18.boolean()
 });
-var ScreenListParams = z17.strictObject({});
-var ScreenListResult = z17.strictObject({ displays: z17.array(ScreenDisplay).max(32) });
-var ScreenCaptureParams = z17.strictObject({
+var ScreenListParams = z18.strictObject({});
+var ScreenListResult = z18.strictObject({ displays: z18.array(ScreenDisplay).max(32) });
+var ScreenCaptureParams = z18.strictObject({
   /** The display (from screen.list); the primary display when absent. */
   display_id: nonNegInt.optional(),
-  format: z17.enum(["jpeg", "png"]).default("jpeg"),
+  format: z18.enum(["jpeg", "png"]).default("jpeg"),
   /** Scale the picture down to at most this width in pixels (kept when already smaller). */
-  max_width: z17.int().min(160).max(7680).default(1600)
+  max_width: z18.int().min(160).max(7680).default(1600)
 });
-var ScreenCaptureResult = z17.strictObject({
+var ScreenCaptureResult = z18.strictObject({
   display_id: nonNegInt,
-  mime_type: z17.enum(["image/jpeg", "image/png"]),
-  width: z17.int().min(1),
-  height: z17.int().min(1),
+  mime_type: z18.enum(["image/jpeg", "image/png"]),
+  width: z18.int().min(1),
+  height: z18.int().min(1),
   /** The display's full resolution in pixels, before scaling. */
-  source_width: z17.int().min(1),
-  source_height: z17.int().min(1),
+  source_width: z18.int().min(1),
+  source_height: z18.int().min(1),
   /** The image, base64 (at most 6 MiB of text). */
-  data_base64: z17.string().max(6291456)
+  data_base64: z18.string().max(6291456)
 });
 
 // src/schema/window.ts
-import { z as z18 } from "zod";
-var WindowInfo = z18.strictObject({
+import { z as z19 } from "zod";
+var WindowInfo = z19.strictObject({
   /** The OS's window handle (macOS window number, Windows HWND, X11 window id). */
   id: nonNegInt,
-  title: z18.string().max(512),
+  title: z19.string().max(512),
   /** Position and size in logical points. */
-  x: z18.int(),
-  y: z18.int(),
-  width: z18.int().min(0),
-  height: z18.int().min(0),
+  x: z19.int(),
+  y: z19.int(),
+  width: z19.int().min(0),
+  height: z19.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: z18.string().max(256).optional(),
+  app: z19.string().max(256).optional(),
   /** The owning process id; absent when the OS does not say. Added in protocol 1.7. */
-  pid: z18.int().min(0).optional()
+  pid: z19.int().min(0).optional()
 });
-var WindowListParams = z18.strictObject({
+var WindowListParams = z19.strictObject({
   /** Case-insensitive substring of the window title. */
-  title: z18.string().min(1).max(256).optional(),
-  limit: z18.int().min(1).max(500).default(100)
+  title: z19.string().min(1).max(256).optional(),
+  limit: z19.int().min(1).max(500).default(100)
 });
-var WindowListResult = z18.strictObject({
-  windows: z18.array(WindowInfo).max(500),
+var WindowListResult = z19.strictObject({
+  windows: z19.array(WindowInfo).max(500),
   total: nonNegInt,
-  truncated: z18.boolean()
+  truncated: z19.boolean()
 });
-var WindowFocusParams = z18.strictObject({ id: nonNegInt });
-var WindowFocusResult = z18.strictObject({ window: WindowInfo });
-var WindowMoveParams = z18.strictObject({
+var WindowFocusParams = z19.strictObject({ id: nonNegInt });
+var WindowFocusResult = z19.strictObject({ window: WindowInfo });
+var WindowMoveParams = z19.strictObject({
   id: nonNegInt,
   /** New top-left corner; unchanged when absent. */
-  x: z18.int().optional(),
-  y: z18.int().optional(),
+  x: z19.int().optional(),
+  y: z19.int().optional(),
   /** New size; unchanged when absent. */
-  width: z18.int().min(50).max(16384).optional(),
-  height: z18.int().min(50).max(16384).optional()
+  width: z19.int().min(50).max(16384).optional(),
+  height: z19.int().min(50).max(16384).optional()
 });
-var WindowMoveResult = z18.strictObject({ window: WindowInfo });
-var WindowMinimizeParams = z18.strictObject({ id: nonNegInt });
-var WindowMinimizeResult = z18.strictObject({ id: nonNegInt });
+var WindowMoveResult = z19.strictObject({ window: WindowInfo });
+var WindowMinimizeParams = z19.strictObject({ id: nonNegInt });
+var WindowMinimizeResult = z19.strictObject({ id: nonNegInt });
 
 // src/schema/input.ts
-import { z as z19 } from "zod";
-var InputKey = z19.enum([
+import { z as z20 } from "zod";
+var InputKey = z20.enum([
   "cmd",
   "ctrl",
   "alt",
@@ -1214,203 +1358,203 @@ var InputKey = z19.enum([
   "backslash",
   "grave"
 ]);
-var InputTypeTextParams = z19.strictObject({ text: z19.string().min(1).max(1e4) });
-var InputTypeTextResult = z19.strictObject({ characters: z19.int().min(1) });
-var InputHotkeyParams = z19.strictObject({
+var InputTypeTextParams = z20.strictObject({ text: z20.string().min(1).max(1e4) });
+var InputTypeTextResult = z20.strictObject({ characters: z20.int().min(1) });
+var InputHotkeyParams = z20.strictObject({
   /** Pressed together in order and released in reverse: ["cmd", "shift", "t"]. */
-  keys: z19.array(InputKey).min(1).max(6)
+  keys: z20.array(InputKey).min(1).max(6)
 });
-var InputHotkeyResult = z19.strictObject({ keys: z19.array(InputKey) });
-var InputPoint = z19.strictObject({ x: z19.int(), y: z19.int() });
-var InputMouseMoveParams = z19.strictObject({
+var InputHotkeyResult = z20.strictObject({ keys: z20.array(InputKey) });
+var InputPoint = z20.strictObject({ x: z20.int(), y: z20.int() });
+var InputMouseMoveParams = z20.strictObject({
   /** Screen position in logical points (the coordinates screen.list and window.list report). */
-  x: z19.int(),
-  y: z19.int()
+  x: z20.int(),
+  y: z20.int()
 });
-var InputMouseMoveResult = z19.strictObject({
+var InputMouseMoveResult = z20.strictObject({
   /** Where the pointer is now, read back from the OS. */
   position: InputPoint
 });
-var InputMouseClickParams = z19.strictObject({
+var InputMouseClickParams = z20.strictObject({
   /** Move here first; clicks where the pointer is when absent. */
-  x: z19.int().optional(),
-  y: z19.int().optional(),
-  button: z19.enum(["left", "right", "middle"]).default("left"),
-  double: z19.boolean().default(false)
+  x: z20.int().optional(),
+  y: z20.int().optional(),
+  button: z20.enum(["left", "right", "middle"]).default("left"),
+  double: z20.boolean().default(false)
 });
-var InputMouseClickResult = z19.strictObject({
+var InputMouseClickResult = z20.strictObject({
   position: InputPoint,
-  button: z19.enum(["left", "right", "middle"]),
-  double: z19.boolean()
+  button: z20.enum(["left", "right", "middle"]),
+  double: z20.boolean()
 });
 
 // src/schema/power.ts
-import { z as z20 } from "zod";
-var PowerStatusParams = z20.strictObject({});
-var PowerStatusResult = z20.strictObject({
-  has_battery: z20.boolean(),
+import { z as z21 } from "zod";
+var PowerStatusParams = z21.strictObject({});
+var PowerStatusResult = z21.strictObject({
+  has_battery: z21.boolean(),
   /** 0–100; null without a battery. */
-  percent: z20.number().min(0).max(100).nullable(),
-  charging: z20.boolean().nullable(),
+  percent: z21.number().min(0).max(100).nullable(),
+  charging: z21.boolean().nullable(),
   /** On wall power; null where the OS does not say. */
-  plugged_in: z20.boolean().nullable(),
+  plugged_in: z21.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. */
   awake_until_ms: epochMs.nullable()
 });
-var PowerPreventSleepParams = z20.strictObject({
+var PowerPreventSleepParams = z21.strictObject({
   /** Keep the computer awake this long; 0 lets it sleep again now. */
-  seconds: z20.int().min(0).max(86400),
+  seconds: z21.int().min(0).max(86400),
   /** Shown where the OS lists what keeps it awake. */
-  reason: z20.string().min(1).max(128).default("Matrx 2 is working")
+  reason: z21.string().min(1).max(128).default("Matrx 2 is working")
 });
-var PowerPreventSleepResult = z20.strictObject({
+var PowerPreventSleepResult = z21.strictObject({
   /** When it may sleep again; null after seconds 0. */
   awake_until_ms: epochMs.nullable()
 });
 
 // src/schema/resources.ts
-import { z as z21 } from "zod";
-var ResourcesDisk = z21.strictObject({
+import { z as z22 } from "zod";
+var ResourcesDisk = z22.strictObject({
   /** Where it is mounted ("/", "C:"). */
-  mount: z21.string().max(512),
+  mount: z22.string().max(512),
   /** The file system ("apfs", "NTFS", "ext4"). */
-  fs: z21.string().max(64),
+  fs: z22.string().max(64),
   size_bytes: nonNegInt,
   used_bytes: nonNegInt,
   available_bytes: nonNegInt
 });
-var ResourcesSnapshotParams = z21.strictObject({});
-var ResourcesSnapshotResult = z21.strictObject({
-  cpu: z21.strictObject({
+var ResourcesSnapshotParams = z22.strictObject({});
+var ResourcesSnapshotResult = z22.strictObject({
+  cpu: z22.strictObject({
     /** Busy share of all cores, 0–100, measured now. */
-    percent: z21.number().min(0).max(100),
-    cores: z21.int().min(1),
+    percent: z22.number().min(0).max(100),
+    cores: z22.int().min(1),
     /** 1, 5 and 15 minute load averages; null on Windows. */
-    load: z21.array(z21.number().min(0)).length(3).nullable()
+    load: z22.array(z22.number().min(0)).length(3).nullable()
   }),
-  memory: z21.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
-  swap: z21.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
-  disks: z21.array(ResourcesDisk).max(64),
+  memory: z22.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: z22.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: z22.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
 
 // src/schema/audio.ts
-import { z as z22 } from "zod";
-var AudioDevice = z22.strictObject({
+import { z as z23 } from "zod";
+var AudioDevice = z23.strictObject({
   /** The OS's name for it, as audio.record takes it. */
-  id: z22.string().min(1).max(256),
-  name: z22.string().max(256),
-  default: z22.boolean()
+  id: z23.string().min(1).max(256),
+  name: z23.string().max(256),
+  default: z23.boolean()
 });
-var AudioDevicesParams = z22.strictObject({});
-var AudioDevicesResult = z22.strictObject({
-  inputs: z22.array(AudioDevice).max(64),
-  outputs: z22.array(AudioDevice).max(64)
+var AudioDevicesParams = z23.strictObject({});
+var AudioDevicesResult = z23.strictObject({
+  inputs: z23.array(AudioDevice).max(64),
+  outputs: z23.array(AudioDevice).max(64)
 });
-var AudioRecordParams = z22.strictObject({
-  seconds: z22.number().min(0.5).max(600),
+var AudioRecordParams = z23.strictObject({
+  seconds: z23.number().min(0.5).max(600),
   /** The microphone (from audio.devices); the default input when absent. */
-  device_id: z22.string().min(1).max(256).optional(),
+  device_id: z23.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 = z22.strictObject({
+var AudioRecordResult = z23.strictObject({
   path: AbsPath,
-  seconds: z22.number().min(0),
+  seconds: z23.number().min(0),
   bytes: nonNegInt,
   /** Loudest sample, 0–1: 0 means the device gave silence. */
-  peak: z22.number().min(0).max(1)
+  peak: z23.number().min(0).max(1)
 });
-var AudioPlayParams = z22.strictObject({ path: AbsPath });
-var AudioPlayResult = z22.strictObject({ path: AbsPath, seconds: z22.number().min(0) });
+var AudioPlayParams = z23.strictObject({ path: AbsPath });
+var AudioPlayResult = z23.strictObject({ path: AbsPath, seconds: z23.number().min(0) });
 
 // src/schema/fs-watch.ts
-import { z as z23 } from "zod";
-var FsWatchId = z23.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = z23.strictObject({
+import { z as z24 } from "zod";
+var FsWatchId = z24.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = z24.strictObject({
   path: AbsPath,
-  recursive: z23.boolean().default(true),
+  recursive: z24.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: z23.array(z23.string().max(256)).max(64).default([])
+  ignore: z24.array(z24.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = z23.strictObject({
+var FsWatchStartResult = z24.strictObject({
   watch_id: FsWatchId,
   path: AbsPath,
   /** The watch ends by itself if nobody reads it for 30 minutes. */
   expires_at_ms: epochMs
 });
-var FsWatchEventsParams = z23.strictObject({
+var FsWatchEventsParams = z24.strictObject({
   watch_id: FsWatchId,
   /** Wait up to this long for a first change when none is waiting (0 answers at once). */
-  wait_ms: z23.int().min(0).max(25e3).default(0)
+  wait_ms: z24.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = z23.strictObject({
+var FsWatchEventsResult = z24.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: z23.array(FsChange).max(1e3),
+  changes: z24.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: z23.boolean(),
+  overflow: z24.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = z23.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = z23.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = z24.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = z24.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-import { z as z24 } from "zod";
-var ExecJobId = z24.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = z24.strictObject({
-  command: z24.string().min(1).max(131072),
+import { z as z25 } from "zod";
+var ExecJobId = z25.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = z25.strictObject({
+  command: z25.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: z24.record(z24.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z24.string().max(32768)).optional()
+  env: z25.record(z25.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z25.string().max(32768)).optional()
 });
-var ExecJobStartResult = z24.strictObject({ job_id: ExecJobId, pid: z24.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = z24.strictObject({
+var ExecJobStartResult = z25.strictObject({ job_id: ExecJobId, pid: z25.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = z25.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: z24.int().min(0).max(25e3).default(0),
-  max_bytes: z24.int().min(1024).max(1048576).default(65536)
+  wait_ms: z25.int().min(0).max(25e3).default(0),
+  max_bytes: z25.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = z24.strictObject({
+var ExecJobOutputResult = z25.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: z24.string(),
+  output: z25.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: z24.boolean(),
-  exit_code: z24.int().nullable()
+  running: z25.boolean(),
+  exit_code: z25.int().nullable()
 });
-var ExecJobStopParams = z24.strictObject({
+var ExecJobStopParams = z25.strictObject({
   job_id: ExecJobId,
   /** End it at once (SIGKILL; on Windows the whole tree with /F) instead of asking it to quit. */
-  force: z24.boolean().default(false)
+  force: z25.boolean().default(false)
 });
-var ExecJobStopResult = z24.strictObject({ job_id: ExecJobId, exited: z24.boolean(), exit_code: z24.int().nullable() });
-var ExecJobInfo = z24.strictObject({
+var ExecJobStopResult = z25.strictObject({ job_id: ExecJobId, exited: z25.boolean(), exit_code: z25.int().nullable() });
+var ExecJobInfo = z25.strictObject({
   job_id: ExecJobId,
-  command: z24.string().max(1024),
-  pid: z24.int().min(1),
+  command: z25.string().max(1024),
+  pid: z25.int().min(1),
   cwd: AbsPath,
-  running: z24.boolean(),
-  exit_code: z24.int().nullable(),
+  running: z25.boolean(),
+  exit_code: z25.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = z24.strictObject({});
-var ExecJobListResult = z24.strictObject({ jobs: z24.array(ExecJobInfo).max(64) });
+var ExecJobListParams = z25.strictObject({});
+var ExecJobListResult = z25.strictObject({ jobs: z25.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-import { z as z25 } from "zod";
-var CodingServiceCredentials = z25.strictObject({
-  access_token: z25.string().min(16).max(16384),
-  user_id: z25.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/),
+import { z as z26 } from "zod";
+var CodingServiceCredentials = z26.strictObject({
+  access_token: z26.string().min(16).max(16384),
+  user_id: z26.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/),
   /** The AI Matrx server this app talks to (production, or a local server on the nightly copy). */
-  server_url: z25.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: z26.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = z25.enum([
+var CodingHistoryBlocked = z26.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -1418,11 +1562,11 @@ var CodingHistoryBlocked = z25.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = z25.strictObject({
-  session_id: z25.string().max(64),
-  reason: z25.string().max(300)
+var CodingHistoryFailure = z26.strictObject({
+  session_id: z26.string().max(64),
+  reason: z26.string().max(300)
 });
-var CodingHistoryRun = z25.strictObject({
+var CodingHistoryRun = z26.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -1437,39 +1581,39 @@ var CodingHistoryRun = z25.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: z25.array(CodingHistoryFailure).max(20),
+  failures: z26.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: z25.string().max(400)
+  summary: z26.string().max(400)
 });
-var CodingHistoryStep = z25.strictObject({
+var CodingHistoryStep = z26.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: z25.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: z25.boolean(),
+  plan_id: z26.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: z26.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = z25.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = z25.strictObject({
-  plan_id: z25.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = z26.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = z26.strictObject({
+  plan_id: z26.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = z25.strictObject({
-  phase: z25.enum(["checking", "importing"]),
+var CodingServiceProgress = z26.strictObject({
+  phase: z26.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = z25.strictObject({});
-var CodingHistoryImportMissingResult = z25.strictObject({
-  state: z25.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = z26.strictObject({});
+var CodingHistoryImportMissingResult = z26.strictObject({
+  state: z26.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = z25.strictObject({
+var CodingHistoryProgressEvent = z26.strictObject({
   request_id: RequestId,
-  phase: z25.enum(["checking", "importing"]),
+  phase: z26.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -1514,6 +1658,15 @@ var OPS = {
   "apps.profiles.save": { params: AppsProfilesSaveParams, result: AppsProfilesSaveResult, kind: "unary", since: "1.2", errors: ["AUTH_REQUIRED", "AUTH_FORBIDDEN", "NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "DEVICE_OFFLINE", "INTERNAL"] },
   "apps.profiles.remove": { params: AppsProfilesRemoveParams, result: AppsProfilesRemoveResult, kind: "unary", since: "1.2", errors: ["AUTH_REQUIRED", "AUTH_FORBIDDEN", "NOT_FOUND", "DEVICE_OFFLINE", "INTERNAL"] },
   "apps.open": { params: AppsOpenParams, result: AppsOpenResult, kind: "unary", since: "1.2", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "AUTH_REQUIRED", "DEVICE_OFFLINE", "INTERNAL"] },
+  "apps.chats.list": { params: AppsChatsListParams, result: AppsChatsListResult, kind: "unary", since: "1.8", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.chats.watch": { params: AppsChatsWatchParams, result: AppsChatsWatchResult, kind: "resource", since: "1.8", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "RESOURCE_BUSY", "INTERNAL"] },
+  "apps.chats.star": { params: AppsChatsStarParams, result: AppsChatsStarResult, kind: "unary", since: "1.8", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.projects.file": { params: AppsProjectsFileParams, result: AppsProjectsFileResult, kind: "unary", since: "1.8", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.chats.place": { params: AppsChatsPlaceParams, result: AppsChatsPlaceResult, kind: "unary", since: "1.9", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.projects.file_many": { params: AppsProjectsFileManyParams, result: AppsProjectsFileManyResult, kind: "unary", since: "1.9", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.projects.update": { params: AppsProjectsUpdateParams, result: AppsProjectsUpdateResult, kind: "unary", since: "1.9", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.projects.copy": { params: AppsProjectsCopyParams, result: AppsProjectsCopyResult, kind: "unary", since: "1.9", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.projects.unfile": { params: AppsProjectsUnfileParams, result: AppsProjectsUnfileResult, kind: "unary", since: "1.8", errors: ["NOT_FOUND", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "proc.list": { params: ProcListParams, result: ProcListResult, kind: "unary", since: "1.3", errors: ["INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "proc.ports": { params: ProcPortsParams, result: ProcPortsResult, kind: "unary", since: "1.3", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "proc.kill": { params: ProcKillParams, result: ProcKillResult, kind: "unary", since: "1.3", errors: ["NOT_FOUND", "AUTH_FORBIDDEN", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "INTERNAL"] },
@@ -1550,6 +1703,8 @@ var OPS = {
 };
 var EVENTS = {
   "fs.changed": FsChangedEvent,
+  "apps.chats.changed": AppsChatsChangedEvent,
+  "apps.chats.watch_state": AppsChatsWatchStateEvent,
   "exec.exited": ExecExitedEvent,
   "exec.title": ExecTitleEvent,
   "exec.cwd": ExecCwdEvent,
@@ -1814,7 +1969,37 @@ var NAMED_SCHEMAS = {
   AppsProfilesRemoveParams,
   AppsProfilesRemoveResult,
   AppsOpenParams,
-  AppsOpenResult
+  AppsOpenResult,
+  ChatId,
+  ChatPlace,
+  ChatProjectId,
+  ChatWindow,
+  ChatProject,
+  ChatPin,
+  ChatRunning,
+  ChatHidden,
+  ChatLastUse,
+  ChatRow,
+  AppsChatsListParams,
+  AppsChatsListResult,
+  AppsChatsWatchParams,
+  AppsChatsWatchResult,
+  AppsChatsChangedEvent,
+  AppsChatsStarParams,
+  AppsChatsStarResult,
+  AppsProjectsFileParams,
+  AppsProjectsFileResult,
+  AppsProjectsUnfileParams,
+  AppsProjectsUnfileResult,
+  AppsChatsWatchStateEvent,
+  AppsChatsPlaceParams,
+  AppsChatsPlaceResult,
+  AppsProjectsFileManyParams,
+  AppsProjectsFileManyResult,
+  AppsProjectsUpdateParams,
+  AppsProjectsUpdateResult,
+  AppsProjectsCopyParams,
+  AppsProjectsCopyResult
 };
 
 // src/versioning.ts
@@ -1823,7 +2008,8 @@ var FIELDS_SINCE = {
   "ProtocolErrorBody.data": { edits_failed: "1.1" },
   "RelayCallResponse|0": { protocol_version: "1.1" },
   "RelayCallResponse|1": { protocol_version: "1.1" },
-  WindowInfo: { app: "1.7", pid: "1.7" }
+  WindowInfo: { app: "1.7", pid: "1.7" },
+  AppsChatsListResult: { updating: "1.9", live: "1.9" }
 };
 var NULL_SINCE = {
   "RelayDeviceStatusEvent.since_ms": { since: "1.1", olderPeersGet: 0 }
@@ -1876,7 +2062,10 @@ function strip(value, fields, version) {
   }
   return out ?? value;
 }
-var RESULT_PATH = /* @__PURE__ */ new Map([["fs.patch", "FsPatchResult"]]);
+var RESULT_PATH = /* @__PURE__ */ new Map([
+  ["fs.patch", "FsPatchResult"],
+  ["apps.chats.list", "AppsChatsListResult"]
+]);
 var WINDOW_RESULTS = /* @__PURE__ */ new Map([
   ["window.list", "windows"],
   ["window.focus", "window"],
@@ -1917,7 +2106,7 @@ function forPeer(op, part, value, version) {
 var VERSIONED_RESULT_OPS = [...RESULT_PATH.keys(), ...WINDOW_RESULTS.keys()];
 
 // src/contract.ts
-var CONTRACT_SHA256 = "5525674072a767340a8bd75a4e4b98c588577a866b4d381edeb377401729e14d";
+var CONTRACT_SHA256 = "8a36e6b958c871853f0a9520e49c92dd30aa05442765c5a1f04c4caa71a35229";
 
 // src/close-policy.ts
 var CLOSE_RULES = {
@@ -2267,6 +2456,16 @@ export {
   AppProfileLocator,
   AppSupport,
   AppUsageReading,
+  AppsChatsChangedEvent,
+  AppsChatsListParams,
+  AppsChatsListResult,
+  AppsChatsPlaceParams,
+  AppsChatsPlaceResult,
+  AppsChatsStarParams,
+  AppsChatsStarResult,
+  AppsChatsWatchParams,
+  AppsChatsWatchResult,
+  AppsChatsWatchStateEvent,
   AppsListParams,
   AppsListResult,
   AppsOpenParams,
@@ -2277,6 +2476,16 @@ export {
   AppsProfilesRemoveResult,
   AppsProfilesSaveParams,
   AppsProfilesSaveResult,
+  AppsProjectsCopyParams,
+  AppsProjectsCopyResult,
+  AppsProjectsFileManyParams,
+  AppsProjectsFileManyResult,
+  AppsProjectsFileParams,
+  AppsProjectsFileResult,
+  AppsProjectsUnfileParams,
+  AppsProjectsUnfileResult,
+  AppsProjectsUpdateParams,
+  AppsProjectsUpdateResult,
   AudioDevice,
   AudioDevicesParams,
   AudioDevicesResult,
@@ -2289,6 +2498,16 @@ export {
   CLOSE_RULES,
   CONTRACT_SHA256,
   CancelMsg,
+  ChatHidden,
+  ChatId,
+  ChatLastUse,
+  ChatPin,
+  ChatPlace,
+  ChatProject,
+  ChatProjectId,
+  ChatRow,
+  ChatRunning,
+  ChatWindow,
   ClientToCoreMsg,
   ClientType,
   ClipboardReadParams,