@ai-matrx/desktop-protocol 0.17.5 → 0.17.7

package/dist/index.cjs

@@ -21,6 +21,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AbsPath: () => AbsPath,
+  AccountReset: () => AccountReset,
+  AccountUsage: () => AccountUsage,
   AppFeatureStatus: () => AppFeatureStatus,
   AppInfo: () => AppInfo,
   AppKey: () => AppKey,
@@ -29,9 +31,17 @@ __export(src_exports, {
   AppProfileLocator: () => AppProfileLocator,
   AppSupport: () => AppSupport,
   AppUsageReading: () => AppUsageReading,
+  AppWindowInfo: () => AppWindowInfo,
+  AppsAccountsResetsParams: () => AppsAccountsResetsParams,
+  AppsAccountsResetsResult: () => AppsAccountsResetsResult,
+  AppsAccountsUsageParams: () => AppsAccountsUsageParams,
+  AppsAccountsUsageResult: () => AppsAccountsUsageResult,
   AppsChatsChangedEvent: () => AppsChatsChangedEvent,
+  AppsChatsColdParams: () => AppsChatsColdParams,
+  AppsChatsColdResult: () => AppsChatsColdResult,
   AppsChatsListParams: () => AppsChatsListParams,
   AppsChatsListResult: () => AppsChatsListResult,
+  AppsChatsOpenParams: () => AppsChatsOpenParams,
   AppsChatsPlaceParams: () => AppsChatsPlaceParams,
   AppsChatsPlaceResult: () => AppsChatsPlaceResult,
   AppsChatsStarParams: () => AppsChatsStarParams,
@@ -51,14 +61,36 @@ __export(src_exports, {
   AppsProfilesSaveResult: () => AppsProfilesSaveResult,
   AppsProjectsCopyParams: () => AppsProjectsCopyParams,
   AppsProjectsCopyResult: () => AppsProjectsCopyResult,
+  AppsProjectsCreateParams: () => AppsProjectsCreateParams,
+  AppsProjectsCreateResult: () => AppsProjectsCreateResult,
   AppsProjectsFileManyParams: () => AppsProjectsFileManyParams,
   AppsProjectsFileManyResult: () => AppsProjectsFileManyResult,
   AppsProjectsFileParams: () => AppsProjectsFileParams,
   AppsProjectsFileResult: () => AppsProjectsFileResult,
+  AppsProjectsImportPinsParams: () => AppsProjectsImportPinsParams,
+  AppsProjectsImportPinsResult: () => AppsProjectsImportPinsResult,
+  AppsProjectsMoveParams: () => AppsProjectsMoveParams,
+  AppsProjectsMoveResult: () => AppsProjectsMoveResult,
   AppsProjectsUnfileParams: () => AppsProjectsUnfileParams,
   AppsProjectsUnfileResult: () => AppsProjectsUnfileResult,
   AppsProjectsUpdateParams: () => AppsProjectsUpdateParams,
   AppsProjectsUpdateResult: () => AppsProjectsUpdateResult,
+  AppsSpendParams: () => AppsSpendParams,
+  AppsSpendResult: () => AppsSpendResult,
+  AppsSyncRunParams: () => AppsSyncRunParams,
+  AppsSyncStatusParams: () => AppsSyncStatusParams,
+  AppsSyncStatusResult: () => AppsSyncStatusResult,
+  AppsWindowActionResult: () => AppsWindowActionResult,
+  AppsWindowsAddParams: () => AppsWindowsAddParams,
+  AppsWindowsListParams: () => AppsWindowsListParams,
+  AppsWindowsListResult: () => AppsWindowsListResult,
+  AppsWindowsOpenParams: () => AppsWindowsOpenParams,
+  AppsWindowsProcessesParams: () => AppsWindowsProcessesParams,
+  AppsWindowsProcessesResult: () => AppsWindowsProcessesResult,
+  AppsWindowsRefreshUsageParams: () => AppsWindowsRefreshUsageParams,
+  AppsWindowsReloadParams: () => AppsWindowsReloadParams,
+  AppsWindowsRestartParams: () => AppsWindowsRestartParams,
+  AppsWindowsSaveNamesParams: () => AppsWindowsSaveNamesParams,
   AudioDevice: () => AudioDevice,
   AudioDevicesParams: () => AudioDevicesParams,
   AudioDevicesResult: () => AudioDevicesResult,
@@ -71,6 +103,7 @@ __export(src_exports, {
   CLOSE_RULES: () => CLOSE_RULES,
   CONTRACT_SHA256: () => CONTRACT_SHA256,
   CancelMsg: () => CancelMsg,
+  ChatFamily: () => ChatFamily,
   ChatHidden: () => ChatHidden,
   ChatId: () => ChatId,
   ChatLastUse: () => ChatLastUse,
@@ -100,6 +133,7 @@ __export(src_exports, {
   CodingPlanMissingParams: () => CodingPlanMissingParams,
   CodingServiceCredentials: () => CodingServiceCredentials,
   CodingServiceProgress: () => CodingServiceProgress,
+  ColdChat: () => ColdChat,
   ContractHash: () => ContractHash,
   CoreToClientMsg: () => CoreToClientMsg,
   CoreToServiceMsg: () => CoreToServiceMsg,
@@ -297,6 +331,16 @@ __export(src_exports, {
   SessionReleaseParams: () => SessionReleaseParams,
   SessionReleaseResult: () => SessionReleaseResult,
   Signal: () => Signal,
+  SpendAccount: () => SpendAccount,
+  SpendChat: () => SpendChat,
+  SpendHelper: () => SpendHelper,
+  SpendIdle: () => SpendIdle,
+  SpendIdleScope: () => SpendIdleScope,
+  SpendLive: () => SpendLive,
+  SpendModel: () => SpendModel,
+  SpendScopes: () => SpendScopes,
+  SpendSplit: () => SpendSplit,
+  SpendStart: () => SpendStart,
   StreamMeta: () => StreamMeta,
   StreamMsg: () => StreamMsg,
   SysinfoGetParams: () => SysinfoGetParams,
@@ -362,7 +406,7 @@ module.exports = __toCommonJS(src_exports);
 // src/schema/primitives.ts
 var import_zod = require("zod");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 9;
+var PROTOCOL_MINOR = 11;
 var PROTOCOL_VERSION = `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
 var ProtocolVersion = import_zod.z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
 var RequestId = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
@@ -1325,6 +1369,11 @@ var ChatRow = import_zod12.z.strictObject({
   warnings: import_zod12.z.array(import_zod12.z.string().max(400)).max(20),
   last_use: ChatLastUse.nullable()
 });
+var ChatFamily = import_zod12.z.strictObject({
+  id: ChatId,
+  fork_of: ChatId.nullable(),
+  copy_of: ChatId.nullable()
+});
 var AppsChatsListParams = import_zod12.z.strictObject({
   app_key: AppKey,
   /** Only these chats (a live update re-reads just what changed). */
@@ -1342,7 +1391,9 @@ var AppsChatsListResult = import_zod12.z.strictObject({
   /** 1.9: this is the copy saved at the last read, shown while everything is read again. */
   updating: import_zod12.z.boolean().optional(),
   /** 1.9: false while the folder watches are down (changes are not arriving); `apps.chats.watch_state` says when it changes. */
-  live: import_zod12.z.boolean().optional()
+  live: import_zod12.z.boolean().optional(),
+  /** 1.10: every listed chat that is a fork or a copy of another (read from the conversations' first lines). */
+  families: import_zod12.z.array(ChatFamily).max(2e4).optional()
 });
 var AppsChatsWatchParams = import_zod12.z.strictObject({ app_key: AppKey });
 var AppsChatsWatchResult = import_zod12.z.strictObject({ resource_id: ResourceId, version: nonNegInt });
@@ -1396,250 +1447,430 @@ var AppsProjectsUnfileResult = import_zod12.z.strictObject({ chat: ChatRow });
 var AppsChatsStarParams = import_zod12.z.strictObject({ app_key: AppKey, chat_id: ChatId, starred: import_zod12.z.boolean() });
 var AppsChatsStarResult = import_zod12.z.strictObject({ chat: ChatRow });
 
-// src/schema/service.ts
+// src/schema/apps-accounts.ts
 var import_zod13 = require("zod");
+var AppWindowInfo = import_zod13.z.strictObject({
+  key: ChatPlace,
+  /** The app's default profile (Claude: main, which may sign into any account). */
+  main: import_zod13.z.boolean(),
+  /** The account the window is meant for (null for main). */
+  account: import_zod13.z.string().max(320).nullable(),
+  /** The account signed in there now: an email, or the account id while it has no saved name. */
+  signed_in: import_zod13.z.string().max(320).nullable(),
+  signed_in_is_email: import_zod13.z.boolean(),
+  /** Signed into another account than the one it is meant for. */
+  mismatch: import_zod13.z.boolean(),
+  /** Its folder exists. */
+  created: import_zod13.z.boolean(),
+  /** Open now. */
+  running: import_zod13.z.boolean(),
+  /** Chats open in it now (a process resuming each one). */
+  open_chats: nonNegInt
+});
+var AccountUsage = import_zod13.z.strictObject({
+  /** The account's email, or "org <8 chars>" when no window has ever sampled that org. */
+  account: import_zod13.z.string().max(320),
+  org: import_zod13.z.string().max(80).nullable(),
+  /** False when the org was sampled in several accounts' windows and the vote is not clear (≥ 75 %). */
+  account_certain: import_zod13.z.boolean(),
+  /** 5-hour use in percent (0 once the reading is over 5 hours old). */
+  five_hour: import_zod13.z.number().nullable(),
+  five_hour_reset_since: import_zod13.z.boolean(),
+  /** Weekly use in percent (0 once the week reset after the reading). */
+  weekly: import_zod13.z.number().nullable(),
+  weekly_reset_since: import_zod13.z.boolean(),
+  /** Extra-usage spend in percent of its cap, when on. */
+  extra_usage: import_zod13.z.number().nullable(),
+  extra_usage_as_of_ms: epochMs.nullable(),
+  as_of_ms: epochMs,
+  /** The windows meant for this account (and main when main took the reading). */
+  windows: import_zod13.z.array(ChatPlace).max(200),
+  /** The window that took the reading is open now and the reading is under 30 minutes old. */
+  live: import_zod13.z.boolean(),
+  /** The next weekly reset, when known. */
+  weekly_resets_at_ms: epochMs.nullable(),
+  /** That reset time is Claude's own (its reading, or a reset seen in its usage history). */
+  weekly_reset_official: import_zod13.z.boolean().nullable()
+});
+var AccountReset = import_zod13.z.strictObject({
+  window: ChatPlace,
+  account: import_zod13.z.string().max(320).nullable(),
+  next_reset_ms: epochMs.nullable(),
+  /** claude: the app's own reading; usage_history: a weekly drop seen in its usage record; your_list: the person's own entry. */
+  source: import_zod13.z.enum(["claude", "usage_history", "your_list"]).nullable(),
+  /** claude or usage_history. */
+  official: import_zod13.z.boolean(),
+  /** Set when the person's list disagrees with the official time. */
+  note: import_zod13.z.string().max(200).nullable()
+});
+var AppsWindowsListParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsWindowsListResult = import_zod13.z.strictObject({ app_key: AppKey, windows: import_zod13.z.array(AppWindowInfo).max(200) });
+var AppsAccountsUsageParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsAccountsUsageResult = import_zod13.z.strictObject({ app_key: AppKey, accounts: import_zod13.z.array(AccountUsage).max(500) });
+var AppsAccountsResetsParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsAccountsResetsResult = import_zod13.z.strictObject({ app_key: AppKey, resets: import_zod13.z.array(AccountReset).max(200) });
+var AppsWindowActionResult = import_zod13.z.strictObject({ message: import_zod13.z.string().max(400) });
+var AppsWindowsOpenParams = import_zod13.z.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsWindowsReloadParams = import_zod13.z.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsWindowsRestartParams = import_zod13.z.strictObject({ app_key: AppKey, window: ChatPlace, force: import_zod13.z.boolean().default(false) });
+var AppsWindowsRefreshUsageParams = import_zod13.z.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsProjectsMoveParams = import_zod13.z.strictObject({
+  app_key: AppKey,
+  chat_id: ChatId,
+  from_project_id: ChatProjectId,
+  to_project_id: ChatProjectId.optional(),
+  new_project_name: import_zod13.z.string().min(1).max(200).optional()
+});
+var AppsProjectsMoveResult = import_zod13.z.strictObject({ chat: ChatRow, project: ChatProject });
+var AppsProjectsCreateParams = import_zod13.z.strictObject({ app_key: AppKey, name: import_zod13.z.string().min(1).max(200) });
+var AppsProjectsCreateResult = import_zod13.z.strictObject({ project: ChatProject });
+var AppsProjectsImportPinsParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsProjectsImportPinsResult = import_zod13.z.strictObject({ message: import_zod13.z.string().max(400) });
+var ColdChat = import_zod13.z.strictObject({
+  id: ChatId,
+  title: import_zod13.z.string().max(1e3),
+  repo: import_zod13.z.string().max(200).nullable(),
+  window: import_zod13.z.string().max(64).nullable(),
+  account: import_zod13.z.string().max(320).nullable(),
+  model_name: import_zod13.z.string().max(120).nullable(),
+  context_tokens: nonNegInt,
+  cold_at_ms: epochMs,
+  /** Waking it once the cache is cold. */
+  cold_cost: import_zod13.z.number().nullable(),
+  /** Waking it while the cache is warm. */
+  warm_cost: import_zod13.z.number().nullable(),
+  /** Its account is on extra usage (a 5-minute cache, and real money). */
+  extra_usage: import_zod13.z.boolean(),
+  /** A scheduled routine's run. */
+  scheduled: import_zod13.z.boolean(),
+  /** It can be shown in its window (started in the desktop app). */
+  openable: import_zod13.z.boolean(),
+  /** How its window was decided, or why it can't be opened. */
+  how: import_zod13.z.string().max(200).nullable()
+});
+var AppsChatsColdParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsChatsColdResult = import_zod13.z.strictObject({
+  app_key: AppKey,
+  /** Waiting for the person with a warm cache, most urgent first. */
+  waiting: import_zod13.z.array(ColdChat).max(2e3),
+  /** Went cold in the last while. */
+  recently_cold: import_zod13.z.array(ColdChat).max(2e3),
+  /** Chats working right now (not waiting). */
+  working: nonNegInt
+});
+var AppsChatsOpenParams = import_zod13.z.strictObject({ app_key: AppKey, chat_id: ChatId, window: ChatPlace.optional() });
+var SpendSplit = import_zod13.z.strictObject({ main: import_zod13.z.number(), helpers: import_zod13.z.number() });
+var SpendScopes = import_zod13.z.strictObject({ today: SpendSplit, week: SpendSplit });
+var SpendAccount = import_zod13.z.strictObject({
+  account: import_zod13.z.string().max(320),
+  spend: SpendScopes,
+  last_hour: import_zod13.z.number().nullable(),
+  last_5h: import_zod13.z.number().nullable(),
+  five_hour: import_zod13.z.number().nullable(),
+  weekly: import_zod13.z.number().nullable(),
+  as_of_ms: epochMs.nullable(),
+  weekly_resets_at_ms: epochMs.nullable(),
+  /** When the 5-hour or weekly limit is projected to be reached at the current burn. */
+  five_hour_full_at_ms: epochMs.nullable(),
+  weekly_full_at_ms: epochMs.nullable(),
+  /** The reading is too old to project. */
+  stale: import_zod13.z.boolean()
+});
+var SpendModel = import_zod13.z.strictObject({ model: import_zod13.z.string().max(120), name: import_zod13.z.string().max(120), spend: SpendScopes });
+var SpendChat = import_zod13.z.strictObject({
+  id: ChatId,
+  title: import_zod13.z.string().max(1e3),
+  repo: import_zod13.z.string().max(200).nullable(),
+  window: import_zod13.z.string().max(64).nullable(),
+  spend: SpendScopes,
+  helpers: nonNegInt
+});
+var SpendHelper = import_zod13.z.strictObject({ model: import_zod13.z.string().max(120), steps: nonNegInt, over_steps: import_zod13.z.boolean(), description: import_zod13.z.string().max(400) });
+var SpendLive = import_zod13.z.strictObject({ id: ChatId, title: import_zod13.z.string().max(1e3), window: import_zod13.z.string().max(64).nullable(), helpers: import_zod13.z.array(SpendHelper).max(200) });
+var SpendIdleScope = import_zod13.z.strictObject({ count: nonNegInt, tokens: nonNegInt, cost: import_zod13.z.number(), avoidable: import_zod13.z.number() });
+var SpendIdle = import_zod13.z.strictObject({ id: ChatId, chat: import_zod13.z.string().max(1e3), who: import_zod13.z.string().max(400), today: SpendIdleScope, week: SpendIdleScope, last_ms: epochMs });
+var SpendStart = import_zod13.z.strictObject({ repo: import_zod13.z.string().max(200), count: nonNegInt, median: nonNegInt, latest: import_zod13.z.array(nonNegInt).max(20), alarm: import_zod13.z.string().max(400).nullable() });
+var AppsSpendParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsSpendResult = import_zod13.z.strictObject({
+  app_key: AppKey,
+  /** False while older chats are still being read. */
+  complete: import_zod13.z.boolean(),
+  today_total: import_zod13.z.number(),
+  week_total: import_zod13.z.number(),
+  idle_today: import_zod13.z.number(),
+  idle_week: import_zod13.z.number(),
+  /** Models with no known list price. */
+  unpriced: import_zod13.z.array(import_zod13.z.string().max(120)).max(100),
+  /** Helpers past their step budget, unusual starting sizes. */
+  alarms: import_zod13.z.array(import_zod13.z.string().max(400)).max(200),
+  live: import_zod13.z.array(SpendLive).max(200),
+  accounts: import_zod13.z.array(SpendAccount).max(200),
+  models: import_zod13.z.array(SpendModel).max(100),
+  chats: import_zod13.z.array(SpendChat).max(500),
+  idle: import_zod13.z.array(SpendIdle).max(500),
+  starts: import_zod13.z.array(SpendStart).max(200)
+});
+var AppsSyncStatusParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsSyncStatusResult = import_zod13.z.strictObject({
+  healthy: import_zod13.z.boolean(),
+  summary: import_zod13.z.string().max(400),
+  problems: import_zod13.z.array(import_zod13.z.string().max(400)).max(200),
+  warnings: import_zod13.z.array(import_zod13.z.string().max(400)).max(200),
+  /** Accounts seen with no saved name yet (Save account names fixes them). */
+  unnamed_accounts: import_zod13.z.array(import_zod13.z.string().max(80)).max(200),
+  /** The full report. */
+  output: import_zod13.z.string().max(2e5)
+});
+var AppsSyncRunParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsWindowsProcessesParams = import_zod13.z.strictObject({ app_key: AppKey });
+var AppsWindowsProcessesResult = import_zod13.z.strictObject({ processes: import_zod13.z.array(import_zod13.z.string().max(2e3)).max(2e3) });
+var AppsWindowsAddParams = import_zod13.z.strictObject({ app_key: AppKey, window: ChatPlace, email: import_zod13.z.string().min(3).max(320) });
+var AppsWindowsSaveNamesParams = import_zod13.z.strictObject({ app_key: AppKey });
+
+// src/schema/service.ts
+var import_zod14 = require("zod");
 var SERVICE_MAX_FRAME_BYTES = 16777216;
-var ServiceName = import_zod13.z.enum(["ml", "coding"]);
-var ContractHash = import_zod13.z.string().regex(/^[0-9a-f]{64}$/);
-var ServiceToken = import_zod13.z.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var ServiceName = import_zod14.z.enum(["ml", "coding"]);
+var ContractHash = import_zod14.z.string().regex(/^[0-9a-f]{64}$/);
+var ServiceToken = import_zod14.z.string().regex(/^[A-Za-z0-9_-]{43}$/);
 var ServiceRequestId = u32;
-var ServiceHello = import_zod13.z.strictObject({ type: import_zod13.z.literal("hello"), token: ServiceToken, contract: ContractHash });
-var ServiceWelcome = import_zod13.z.strictObject({
-  type: import_zod13.z.literal("welcome"),
+var ServiceHello = import_zod14.z.strictObject({ type: import_zod14.z.literal("hello"), token: ServiceToken, contract: ContractHash });
+var ServiceWelcome = import_zod14.z.strictObject({
+  type: import_zod14.z.literal("welcome"),
   service: ServiceName,
   contract: ContractHash,
   pid: nonNegInt,
   /** The interpreter's version, e.g. "3.13.15". */
-  python: import_zod13.z.string().max(32),
+  python: import_zod14.z.string().max(32),
   /** Every op this service serves; must equal SERVICES[service] exactly. */
-  ops: import_zod13.z.array(import_zod13.z.string().min(1).max(64)).max(64)
+  ops: import_zod14.z.array(import_zod14.z.string().min(1).max(64)).max(64)
 });
-var ServiceRequest = import_zod13.z.strictObject({
-  type: import_zod13.z.literal("request"),
+var ServiceRequest = import_zod14.z.strictObject({
+  type: import_zod14.z.literal("request"),
   id: ServiceRequestId,
-  op: import_zod13.z.string().min(1).max(64),
-  params: import_zod13.z.unknown()
+  op: import_zod14.z.string().min(1).max(64),
+  params: import_zod14.z.unknown()
   // validated by the service against SERVICES[service][op].params
 });
-var ServiceResponse = import_zod13.z.strictObject({
-  type: import_zod13.z.literal("response"),
+var ServiceResponse = import_zod14.z.strictObject({
+  type: import_zod14.z.literal("response"),
   id: ServiceRequestId,
-  result: import_zod13.z.unknown()
+  result: import_zod14.z.unknown()
   // validated by the core against SERVICES[service][op].result
 });
-var ServiceErrorMsg = import_zod13.z.strictObject({ type: import_zod13.z.literal("error"), id: ServiceRequestId, error: ProtocolErrorBody });
-var ServiceProgressMsg = import_zod13.z.strictObject({ type: import_zod13.z.literal("progress"), id: ServiceRequestId, progress: import_zod13.z.unknown() });
-var ServiceCancel = import_zod13.z.strictObject({ type: import_zod13.z.literal("cancel"), id: ServiceRequestId });
-var ServicePing = import_zod13.z.strictObject({ type: import_zod13.z.literal("ping"), id: ServiceRequestId });
-var ServicePong = import_zod13.z.strictObject({
-  type: import_zod13.z.literal("pong"),
+var ServiceErrorMsg = import_zod14.z.strictObject({ type: import_zod14.z.literal("error"), id: ServiceRequestId, error: ProtocolErrorBody });
+var ServiceProgressMsg = import_zod14.z.strictObject({ type: import_zod14.z.literal("progress"), id: ServiceRequestId, progress: import_zod14.z.unknown() });
+var ServiceCancel = import_zod14.z.strictObject({ type: import_zod14.z.literal("cancel"), id: ServiceRequestId });
+var ServicePing = import_zod14.z.strictObject({ type: import_zod14.z.literal("ping"), id: ServiceRequestId });
+var ServicePong = import_zod14.z.strictObject({
+  type: import_zod14.z.literal("pong"),
   id: ServiceRequestId,
   /** Requests running now. */
   busy: nonNegInt
 });
-var ServiceShutdown = import_zod13.z.strictObject({ type: import_zod13.z.literal("shutdown") });
-var CoreToServiceMsg = import_zod13.z.discriminatedUnion("type", [ServiceHello, ServiceRequest, ServiceCancel, ServicePing, ServiceShutdown]);
-var ServiceToCoreMsg = import_zod13.z.discriminatedUnion("type", [ServiceWelcome, ServiceResponse, ServiceErrorMsg, ServiceProgressMsg, ServicePong]);
+var ServiceShutdown = import_zod14.z.strictObject({ type: import_zod14.z.literal("shutdown") });
+var CoreToServiceMsg = import_zod14.z.discriminatedUnion("type", [ServiceHello, ServiceRequest, ServiceCancel, ServicePing, ServiceShutdown]);
+var ServiceToCoreMsg = import_zod14.z.discriminatedUnion("type", [ServiceWelcome, ServiceResponse, ServiceErrorMsg, ServiceProgressMsg, ServicePong]);
 
 // src/schema/tools.ts
-var import_zod14 = require("zod");
-var ToolLevel = import_zod14.z.enum(["programmatic", "protocol", "chat"]);
-var ToolOutcome = import_zod14.z.enum(["pass", "fail", "skip"]);
-var ToolPlatform = import_zod14.z.enum(["darwin", "win32", "linux"]);
-var ToolTransport = import_zod14.z.enum(["in_process", "localhost", "relay", "agent"]);
-var ToolName = import_zod14.z.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/);
-var ToolLevelResult = import_zod14.z.strictObject({
+var import_zod15 = require("zod");
+var ToolLevel = import_zod15.z.enum(["programmatic", "protocol", "chat"]);
+var ToolOutcome = import_zod15.z.enum(["pass", "fail", "skip"]);
+var ToolPlatform = import_zod15.z.enum(["darwin", "win32", "linux"]);
+var ToolTransport = import_zod15.z.enum(["in_process", "localhost", "relay", "agent"]);
+var ToolName = import_zod15.z.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/);
+var ToolLevelResult = import_zod15.z.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: import_zod14.z.boolean(),
+  remote_network: import_zod15.z.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: import_zod14.z.string().max(500),
+  detail: import_zod15.z.string().max(500),
   /** The harness that produced it, e.g. `matrx-desktop test/tools/programmatic.test.ts`. */
-  suite: import_zod14.z.string().min(1).max(200),
+  suite: import_zod15.z.string().min(1).max(200),
   /** The test case inside the suite. */
-  test: import_zod14.z.string().min(1).max(300),
-  run_at_ms: import_zod14.z.int().min(0)
+  test: import_zod15.z.string().min(1).max(300),
+  run_at_ms: import_zod15.z.int().min(0)
 });
-var ToolResultsFile = import_zod14.z.strictObject({
-  schema: import_zod14.z.literal("matrx.tool-results.v1"),
+var ToolResultsFile = import_zod15.z.strictObject({
+  schema: import_zod15.z.literal("matrx.tool-results.v1"),
   /** The producing repo's commit (short or full SHA). */
-  commit: import_zod14.z.string().min(4).max(64),
-  results: import_zod14.z.array(ToolLevelResult).max(1e4)
+  commit: import_zod15.z.string().min(4).max(64),
+  results: import_zod15.z.array(ToolLevelResult).max(1e4)
 });
 
 // src/schema/proc.ts
-var import_zod15 = require("zod");
-var ProcSort = import_zod15.z.enum(["cpu", "memory", "pid", "name"]);
-var ProcListParams = import_zod15.z.strictObject({
+var import_zod16 = require("zod");
+var ProcSort = import_zod16.z.enum(["cpu", "memory", "pid", "name"]);
+var ProcListParams = import_zod16.z.strictObject({
   /** Case-insensitive substring of the process name or its command line. */
-  name: import_zod15.z.string().min(1).max(128).optional(),
+  name: import_zod16.z.string().min(1).max(128).optional(),
   sort: ProcSort.default("cpu"),
-  limit: import_zod15.z.int().min(1).max(500).default(50)
+  limit: import_zod16.z.int().min(1).max(500).default(50)
 });
-var ProcInfo = import_zod15.z.strictObject({
-  pid: import_zod15.z.int().min(0),
+var ProcInfo = import_zod16.z.strictObject({
+  pid: import_zod16.z.int().min(0),
   /** Parent process id; null where the OS does not report it. */
-  ppid: import_zod15.z.int().min(0).nullable(),
-  name: import_zod15.z.string().max(256),
+  ppid: import_zod16.z.int().min(0).nullable(),
+  name: import_zod16.z.string().max(256),
   /** The command line, cut to 1024 characters. */
-  command: import_zod15.z.string().max(1024),
+  command: import_zod16.z.string().max(1024),
   /** Share of one core, as `ps` and Task Manager report it; null where the OS does not say. */
-  cpu_percent: import_zod15.z.number().min(0).nullable(),
+  cpu_percent: import_zod16.z.number().min(0).nullable(),
   memory_bytes: nonNegInt.nullable(),
-  user: import_zod15.z.string().max(128).nullable()
+  user: import_zod16.z.string().max(128).nullable()
 });
-var ProcListResult = import_zod15.z.strictObject({
-  processes: import_zod15.z.array(ProcInfo).max(500),
+var ProcListResult = import_zod16.z.strictObject({
+  processes: import_zod16.z.array(ProcInfo).max(500),
   /** Processes that matched before `limit`. */
   total: nonNegInt,
-  truncated: import_zod15.z.boolean()
+  truncated: import_zod16.z.boolean()
 });
-var ProcPortsParams = import_zod15.z.strictObject({
+var ProcPortsParams = import_zod16.z.strictObject({
   /** Only this port. */
-  port: import_zod15.z.int().min(1).max(65535).optional()
+  port: import_zod16.z.int().min(1).max(65535).optional()
 });
-var ProcPort = import_zod15.z.strictObject({
-  port: import_zod15.z.int().min(1).max(65535),
-  protocol: import_zod15.z.enum(["tcp", "udp"]),
+var ProcPort = import_zod16.z.strictObject({
+  port: import_zod16.z.int().min(1).max(65535),
+  protocol: import_zod16.z.enum(["tcp", "udp"]),
   /** The local address it listens on ("127.0.0.1", "*", "::"). */
-  address: import_zod15.z.string().max(64),
-  pid: import_zod15.z.int().min(0).nullable(),
-  process: import_zod15.z.string().max(256).nullable()
+  address: import_zod16.z.string().max(64),
+  pid: import_zod16.z.int().min(0).nullable(),
+  process: import_zod16.z.string().max(256).nullable()
 });
-var ProcPortsResult = import_zod15.z.strictObject({ ports: import_zod15.z.array(ProcPort).max(4e3) });
-var ProcKillParams = import_zod15.z.strictObject({
-  pid: import_zod15.z.int().min(1),
+var ProcPortsResult = import_zod16.z.strictObject({ ports: import_zod16.z.array(ProcPort).max(4e3) });
+var ProcKillParams = import_zod16.z.strictObject({
+  pid: import_zod16.z.int().min(1),
   /** Kill outright (SIGKILL; on Windows the same /F) instead of asking it to quit. */
-  force: import_zod15.z.boolean().default(false)
+  force: import_zod16.z.boolean().default(false)
 });
-var ProcKillResult = import_zod15.z.strictObject({
-  pid: import_zod15.z.int().min(1),
-  signal: import_zod15.z.enum(["SIGTERM", "SIGKILL"]),
+var ProcKillResult = import_zod16.z.strictObject({
+  pid: import_zod16.z.int().min(1),
+  signal: import_zod16.z.enum(["SIGTERM", "SIGKILL"]),
   /** True when the process was gone within 3 s. */
-  exited: import_zod15.z.boolean()
+  exited: import_zod16.z.boolean()
 });
 
 // src/schema/clipboard.ts
-var import_zod16 = require("zod");
-var ClipboardReadParams = import_zod16.z.strictObject({});
-var ClipboardReadResult = import_zod16.z.strictObject({
+var import_zod17 = require("zod");
+var ClipboardReadParams = import_zod17.z.strictObject({});
+var ClipboardReadResult = import_zod17.z.strictObject({
   /** The clipboard's text ("" when it holds none), cut to 1 MiB. */
-  text: import_zod16.z.string().max(1048576),
-  truncated: import_zod16.z.boolean()
+  text: import_zod17.z.string().max(1048576),
+  truncated: import_zod17.z.boolean()
 });
-var ClipboardWriteParams = import_zod16.z.strictObject({ text: import_zod16.z.string().max(1048576) });
-var ClipboardWriteResult = import_zod16.z.strictObject({ bytes: nonNegInt });
+var ClipboardWriteParams = import_zod17.z.strictObject({ text: import_zod17.z.string().max(1048576) });
+var ClipboardWriteResult = import_zod17.z.strictObject({ bytes: nonNegInt });
 
 // src/schema/system.ts
-var import_zod17 = require("zod");
-var SystemOpenUrlParams = import_zod17.z.strictObject({
+var import_zod18 = require("zod");
+var SystemOpenUrlParams = import_zod18.z.strictObject({
   /** http, https or mailto; opened in the person's default app for it. */
-  url: import_zod17.z.string().min(1).max(4096)
+  url: import_zod18.z.string().min(1).max(4096)
 });
-var SystemOpenUrlResult = import_zod17.z.strictObject({ url: import_zod17.z.string().max(4096) });
-var SystemOpenPathParams = import_zod17.z.strictObject({
+var SystemOpenUrlResult = import_zod18.z.strictObject({ url: import_zod18.z.string().max(4096) });
+var SystemOpenPathParams = import_zod18.z.strictObject({
   path: AbsPath,
   /** Show it in the file manager (Finder, Explorer) instead of opening it. */
-  reveal: import_zod17.z.boolean().default(false)
+  reveal: import_zod18.z.boolean().default(false)
 });
-var SystemOpenPathResult = import_zod17.z.strictObject({ path: AbsPath, revealed: import_zod17.z.boolean() });
-var SystemNotifyParams = import_zod17.z.strictObject({
-  title: import_zod17.z.string().min(1).max(128),
-  body: import_zod17.z.string().max(1024).default("")
+var SystemOpenPathResult = import_zod18.z.strictObject({ path: AbsPath, revealed: import_zod18.z.boolean() });
+var SystemNotifyParams = import_zod18.z.strictObject({
+  title: import_zod18.z.string().min(1).max(128),
+  body: import_zod18.z.string().max(1024).default("")
 });
-var SystemNotifyResult = import_zod17.z.strictObject({
+var SystemNotifyResult = import_zod18.z.strictObject({
   /** False when this computer has no notification service to show it (a bare Linux box). */
-  shown: import_zod17.z.boolean()
+  shown: import_zod18.z.boolean()
 });
 
 // src/schema/screen.ts
-var import_zod18 = require("zod");
-var ScreenDisplay = import_zod18.z.strictObject({
+var import_zod19 = require("zod");
+var ScreenDisplay = import_zod19.z.strictObject({
   /** The OS's display id; pass it to screen.capture. */
   id: nonNegInt,
-  name: import_zod18.z.string().max(128),
+  name: import_zod19.z.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: import_zod18.z.int(),
-  y: import_zod18.z.int(),
-  width: import_zod18.z.int().min(1),
-  height: import_zod18.z.int().min(1),
+  x: import_zod19.z.int(),
+  y: import_zod19.z.int(),
+  width: import_zod19.z.int().min(1),
+  height: import_zod19.z.int().min(1),
   /** Pixels per point (2 on a Retina display). */
-  scale: import_zod18.z.number().min(0.1).max(8),
-  primary: import_zod18.z.boolean()
+  scale: import_zod19.z.number().min(0.1).max(8),
+  primary: import_zod19.z.boolean()
 });
-var ScreenListParams = import_zod18.z.strictObject({});
-var ScreenListResult = import_zod18.z.strictObject({ displays: import_zod18.z.array(ScreenDisplay).max(32) });
-var ScreenCaptureParams = import_zod18.z.strictObject({
+var ScreenListParams = import_zod19.z.strictObject({});
+var ScreenListResult = import_zod19.z.strictObject({ displays: import_zod19.z.array(ScreenDisplay).max(32) });
+var ScreenCaptureParams = import_zod19.z.strictObject({
   /** The display (from screen.list); the primary display when absent. */
   display_id: nonNegInt.optional(),
-  format: import_zod18.z.enum(["jpeg", "png"]).default("jpeg"),
+  format: import_zod19.z.enum(["jpeg", "png"]).default("jpeg"),
   /** Scale the picture down to at most this width in pixels (kept when already smaller). */
-  max_width: import_zod18.z.int().min(160).max(7680).default(1600)
+  max_width: import_zod19.z.int().min(160).max(7680).default(1600)
 });
-var ScreenCaptureResult = import_zod18.z.strictObject({
+var ScreenCaptureResult = import_zod19.z.strictObject({
   display_id: nonNegInt,
-  mime_type: import_zod18.z.enum(["image/jpeg", "image/png"]),
-  width: import_zod18.z.int().min(1),
-  height: import_zod18.z.int().min(1),
+  mime_type: import_zod19.z.enum(["image/jpeg", "image/png"]),
+  width: import_zod19.z.int().min(1),
+  height: import_zod19.z.int().min(1),
   /** The display's full resolution in pixels, before scaling. */
-  source_width: import_zod18.z.int().min(1),
-  source_height: import_zod18.z.int().min(1),
+  source_width: import_zod19.z.int().min(1),
+  source_height: import_zod19.z.int().min(1),
   /** The image, base64 (at most 6 MiB of text). */
-  data_base64: import_zod18.z.string().max(6291456)
+  data_base64: import_zod19.z.string().max(6291456)
 });
 
 // src/schema/window.ts
-var import_zod19 = require("zod");
-var WindowInfo = import_zod19.z.strictObject({
+var import_zod20 = require("zod");
+var WindowInfo = import_zod20.z.strictObject({
   /** The OS's window handle (macOS window number, Windows HWND, X11 window id). */
   id: nonNegInt,
-  title: import_zod19.z.string().max(512),
+  title: import_zod20.z.string().max(512),
   /** Position and size in logical points. */
-  x: import_zod19.z.int(),
-  y: import_zod19.z.int(),
-  width: import_zod19.z.int().min(0),
-  height: import_zod19.z.int().min(0),
+  x: import_zod20.z.int(),
+  y: import_zod20.z.int(),
+  width: import_zod20.z.int().min(0),
+  height: import_zod20.z.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: import_zod19.z.string().max(256).optional(),
+  app: import_zod20.z.string().max(256).optional(),
   /** The owning process id; absent when the OS does not say. Added in protocol 1.7. */
-  pid: import_zod19.z.int().min(0).optional()
+  pid: import_zod20.z.int().min(0).optional()
 });
-var WindowListParams = import_zod19.z.strictObject({
+var WindowListParams = import_zod20.z.strictObject({
   /** Case-insensitive substring of the window title. */
-  title: import_zod19.z.string().min(1).max(256).optional(),
-  limit: import_zod19.z.int().min(1).max(500).default(100)
+  title: import_zod20.z.string().min(1).max(256).optional(),
+  limit: import_zod20.z.int().min(1).max(500).default(100)
 });
-var WindowListResult = import_zod19.z.strictObject({
-  windows: import_zod19.z.array(WindowInfo).max(500),
+var WindowListResult = import_zod20.z.strictObject({
+  windows: import_zod20.z.array(WindowInfo).max(500),
   total: nonNegInt,
-  truncated: import_zod19.z.boolean()
+  truncated: import_zod20.z.boolean()
 });
-var WindowFocusParams = import_zod19.z.strictObject({ id: nonNegInt });
-var WindowFocusResult = import_zod19.z.strictObject({ window: WindowInfo });
-var WindowMoveParams = import_zod19.z.strictObject({
+var WindowFocusParams = import_zod20.z.strictObject({ id: nonNegInt });
+var WindowFocusResult = import_zod20.z.strictObject({ window: WindowInfo });
+var WindowMoveParams = import_zod20.z.strictObject({
   id: nonNegInt,
   /** New top-left corner; unchanged when absent. */
-  x: import_zod19.z.int().optional(),
-  y: import_zod19.z.int().optional(),
+  x: import_zod20.z.int().optional(),
+  y: import_zod20.z.int().optional(),
   /** New size; unchanged when absent. */
-  width: import_zod19.z.int().min(50).max(16384).optional(),
-  height: import_zod19.z.int().min(50).max(16384).optional()
+  width: import_zod20.z.int().min(50).max(16384).optional(),
+  height: import_zod20.z.int().min(50).max(16384).optional()
 });
-var WindowMoveResult = import_zod19.z.strictObject({ window: WindowInfo });
-var WindowMinimizeParams = import_zod19.z.strictObject({ id: nonNegInt });
-var WindowMinimizeResult = import_zod19.z.strictObject({ id: nonNegInt });
+var WindowMoveResult = import_zod20.z.strictObject({ window: WindowInfo });
+var WindowMinimizeParams = import_zod20.z.strictObject({ id: nonNegInt });
+var WindowMinimizeResult = import_zod20.z.strictObject({ id: nonNegInt });
 
 // src/schema/input.ts
-var import_zod20 = require("zod");
-var InputKey = import_zod20.z.enum([
+var import_zod21 = require("zod");
+var InputKey = import_zod21.z.enum([
   "cmd",
   "ctrl",
   "alt",
@@ -1719,203 +1950,203 @@ var InputKey = import_zod20.z.enum([
   "backslash",
   "grave"
 ]);
-var InputTypeTextParams = import_zod20.z.strictObject({ text: import_zod20.z.string().min(1).max(1e4) });
-var InputTypeTextResult = import_zod20.z.strictObject({ characters: import_zod20.z.int().min(1) });
-var InputHotkeyParams = import_zod20.z.strictObject({
+var InputTypeTextParams = import_zod21.z.strictObject({ text: import_zod21.z.string().min(1).max(1e4) });
+var InputTypeTextResult = import_zod21.z.strictObject({ characters: import_zod21.z.int().min(1) });
+var InputHotkeyParams = import_zod21.z.strictObject({
   /** Pressed together in order and released in reverse: ["cmd", "shift", "t"]. */
-  keys: import_zod20.z.array(InputKey).min(1).max(6)
+  keys: import_zod21.z.array(InputKey).min(1).max(6)
 });
-var InputHotkeyResult = import_zod20.z.strictObject({ keys: import_zod20.z.array(InputKey) });
-var InputPoint = import_zod20.z.strictObject({ x: import_zod20.z.int(), y: import_zod20.z.int() });
-var InputMouseMoveParams = import_zod20.z.strictObject({
+var InputHotkeyResult = import_zod21.z.strictObject({ keys: import_zod21.z.array(InputKey) });
+var InputPoint = import_zod21.z.strictObject({ x: import_zod21.z.int(), y: import_zod21.z.int() });
+var InputMouseMoveParams = import_zod21.z.strictObject({
   /** Screen position in logical points (the coordinates screen.list and window.list report). */
-  x: import_zod20.z.int(),
-  y: import_zod20.z.int()
+  x: import_zod21.z.int(),
+  y: import_zod21.z.int()
 });
-var InputMouseMoveResult = import_zod20.z.strictObject({
+var InputMouseMoveResult = import_zod21.z.strictObject({
   /** Where the pointer is now, read back from the OS. */
   position: InputPoint
 });
-var InputMouseClickParams = import_zod20.z.strictObject({
+var InputMouseClickParams = import_zod21.z.strictObject({
   /** Move here first; clicks where the pointer is when absent. */
-  x: import_zod20.z.int().optional(),
-  y: import_zod20.z.int().optional(),
-  button: import_zod20.z.enum(["left", "right", "middle"]).default("left"),
-  double: import_zod20.z.boolean().default(false)
+  x: import_zod21.z.int().optional(),
+  y: import_zod21.z.int().optional(),
+  button: import_zod21.z.enum(["left", "right", "middle"]).default("left"),
+  double: import_zod21.z.boolean().default(false)
 });
-var InputMouseClickResult = import_zod20.z.strictObject({
+var InputMouseClickResult = import_zod21.z.strictObject({
   position: InputPoint,
-  button: import_zod20.z.enum(["left", "right", "middle"]),
-  double: import_zod20.z.boolean()
+  button: import_zod21.z.enum(["left", "right", "middle"]),
+  double: import_zod21.z.boolean()
 });
 
 // src/schema/power.ts
-var import_zod21 = require("zod");
-var PowerStatusParams = import_zod21.z.strictObject({});
-var PowerStatusResult = import_zod21.z.strictObject({
-  has_battery: import_zod21.z.boolean(),
+var import_zod22 = require("zod");
+var PowerStatusParams = import_zod22.z.strictObject({});
+var PowerStatusResult = import_zod22.z.strictObject({
+  has_battery: import_zod22.z.boolean(),
   /** 0–100; null without a battery. */
-  percent: import_zod21.z.number().min(0).max(100).nullable(),
-  charging: import_zod21.z.boolean().nullable(),
+  percent: import_zod22.z.number().min(0).max(100).nullable(),
+  charging: import_zod22.z.boolean().nullable(),
   /** On wall power; null where the OS does not say. */
-  plugged_in: import_zod21.z.boolean().nullable(),
+  plugged_in: import_zod22.z.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 = import_zod21.z.strictObject({
+var PowerPreventSleepParams = import_zod22.z.strictObject({
   /** Keep the computer awake this long; 0 lets it sleep again now. */
-  seconds: import_zod21.z.int().min(0).max(86400),
+  seconds: import_zod22.z.int().min(0).max(86400),
   /** Shown where the OS lists what keeps it awake. */
-  reason: import_zod21.z.string().min(1).max(128).default("Matrx 2 is working")
+  reason: import_zod22.z.string().min(1).max(128).default("Matrx 2 is working")
 });
-var PowerPreventSleepResult = import_zod21.z.strictObject({
+var PowerPreventSleepResult = import_zod22.z.strictObject({
   /** When it may sleep again; null after seconds 0. */
   awake_until_ms: epochMs.nullable()
 });
 
 // src/schema/resources.ts
-var import_zod22 = require("zod");
-var ResourcesDisk = import_zod22.z.strictObject({
+var import_zod23 = require("zod");
+var ResourcesDisk = import_zod23.z.strictObject({
   /** Where it is mounted ("/", "C:"). */
-  mount: import_zod22.z.string().max(512),
+  mount: import_zod23.z.string().max(512),
   /** The file system ("apfs", "NTFS", "ext4"). */
-  fs: import_zod22.z.string().max(64),
+  fs: import_zod23.z.string().max(64),
   size_bytes: nonNegInt,
   used_bytes: nonNegInt,
   available_bytes: nonNegInt
 });
-var ResourcesSnapshotParams = import_zod22.z.strictObject({});
-var ResourcesSnapshotResult = import_zod22.z.strictObject({
-  cpu: import_zod22.z.strictObject({
+var ResourcesSnapshotParams = import_zod23.z.strictObject({});
+var ResourcesSnapshotResult = import_zod23.z.strictObject({
+  cpu: import_zod23.z.strictObject({
     /** Busy share of all cores, 0–100, measured now. */
-    percent: import_zod22.z.number().min(0).max(100),
-    cores: import_zod22.z.int().min(1),
+    percent: import_zod23.z.number().min(0).max(100),
+    cores: import_zod23.z.int().min(1),
     /** 1, 5 and 15 minute load averages; null on Windows. */
-    load: import_zod22.z.array(import_zod22.z.number().min(0)).length(3).nullable()
+    load: import_zod23.z.array(import_zod23.z.number().min(0)).length(3).nullable()
   }),
-  memory: import_zod22.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
-  swap: import_zod22.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
-  disks: import_zod22.z.array(ResourcesDisk).max(64),
+  memory: import_zod23.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: import_zod23.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: import_zod23.z.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
 
 // src/schema/audio.ts
-var import_zod23 = require("zod");
-var AudioDevice = import_zod23.z.strictObject({
+var import_zod24 = require("zod");
+var AudioDevice = import_zod24.z.strictObject({
   /** The OS's name for it, as audio.record takes it. */
-  id: import_zod23.z.string().min(1).max(256),
-  name: import_zod23.z.string().max(256),
-  default: import_zod23.z.boolean()
+  id: import_zod24.z.string().min(1).max(256),
+  name: import_zod24.z.string().max(256),
+  default: import_zod24.z.boolean()
 });
-var AudioDevicesParams = import_zod23.z.strictObject({});
-var AudioDevicesResult = import_zod23.z.strictObject({
-  inputs: import_zod23.z.array(AudioDevice).max(64),
-  outputs: import_zod23.z.array(AudioDevice).max(64)
+var AudioDevicesParams = import_zod24.z.strictObject({});
+var AudioDevicesResult = import_zod24.z.strictObject({
+  inputs: import_zod24.z.array(AudioDevice).max(64),
+  outputs: import_zod24.z.array(AudioDevice).max(64)
 });
-var AudioRecordParams = import_zod23.z.strictObject({
-  seconds: import_zod23.z.number().min(0.5).max(600),
+var AudioRecordParams = import_zod24.z.strictObject({
+  seconds: import_zod24.z.number().min(0.5).max(600),
   /** The microphone (from audio.devices); the default input when absent. */
-  device_id: import_zod23.z.string().min(1).max(256).optional(),
+  device_id: import_zod24.z.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 = import_zod23.z.strictObject({
+var AudioRecordResult = import_zod24.z.strictObject({
   path: AbsPath,
-  seconds: import_zod23.z.number().min(0),
+  seconds: import_zod24.z.number().min(0),
   bytes: nonNegInt,
   /** Loudest sample, 0–1: 0 means the device gave silence. */
-  peak: import_zod23.z.number().min(0).max(1)
+  peak: import_zod24.z.number().min(0).max(1)
 });
-var AudioPlayParams = import_zod23.z.strictObject({ path: AbsPath });
-var AudioPlayResult = import_zod23.z.strictObject({ path: AbsPath, seconds: import_zod23.z.number().min(0) });
+var AudioPlayParams = import_zod24.z.strictObject({ path: AbsPath });
+var AudioPlayResult = import_zod24.z.strictObject({ path: AbsPath, seconds: import_zod24.z.number().min(0) });
 
 // src/schema/fs-watch.ts
-var import_zod24 = require("zod");
-var FsWatchId = import_zod24.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = import_zod24.z.strictObject({
+var import_zod25 = require("zod");
+var FsWatchId = import_zod25.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = import_zod25.z.strictObject({
   path: AbsPath,
-  recursive: import_zod24.z.boolean().default(true),
+  recursive: import_zod25.z.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: import_zod24.z.array(import_zod24.z.string().max(256)).max(64).default([])
+  ignore: import_zod25.z.array(import_zod25.z.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = import_zod24.z.strictObject({
+var FsWatchStartResult = import_zod25.z.strictObject({
   watch_id: FsWatchId,
   path: AbsPath,
   /** The watch ends by itself if nobody reads it for 30 minutes. */
   expires_at_ms: epochMs
 });
-var FsWatchEventsParams = import_zod24.z.strictObject({
+var FsWatchEventsParams = import_zod25.z.strictObject({
   watch_id: FsWatchId,
   /** Wait up to this long for a first change when none is waiting (0 answers at once). */
-  wait_ms: import_zod24.z.int().min(0).max(25e3).default(0)
+  wait_ms: import_zod25.z.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = import_zod24.z.strictObject({
+var FsWatchEventsResult = import_zod25.z.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: import_zod24.z.array(FsChange).max(1e3),
+  changes: import_zod25.z.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: import_zod24.z.boolean(),
+  overflow: import_zod25.z.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = import_zod24.z.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = import_zod24.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = import_zod25.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = import_zod25.z.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-var import_zod25 = require("zod");
-var ExecJobId = import_zod25.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = import_zod25.z.strictObject({
-  command: import_zod25.z.string().min(1).max(131072),
+var import_zod26 = require("zod");
+var ExecJobId = import_zod26.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = import_zod26.z.strictObject({
+  command: import_zod26.z.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: import_zod25.z.record(import_zod25.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod25.z.string().max(32768)).optional()
+  env: import_zod26.z.record(import_zod26.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod26.z.string().max(32768)).optional()
 });
-var ExecJobStartResult = import_zod25.z.strictObject({ job_id: ExecJobId, pid: import_zod25.z.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = import_zod25.z.strictObject({
+var ExecJobStartResult = import_zod26.z.strictObject({ job_id: ExecJobId, pid: import_zod26.z.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = import_zod26.z.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: import_zod25.z.int().min(0).max(25e3).default(0),
-  max_bytes: import_zod25.z.int().min(1024).max(1048576).default(65536)
+  wait_ms: import_zod26.z.int().min(0).max(25e3).default(0),
+  max_bytes: import_zod26.z.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = import_zod25.z.strictObject({
+var ExecJobOutputResult = import_zod26.z.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: import_zod25.z.string(),
+  output: import_zod26.z.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: import_zod25.z.boolean(),
-  exit_code: import_zod25.z.int().nullable()
+  running: import_zod26.z.boolean(),
+  exit_code: import_zod26.z.int().nullable()
 });
-var ExecJobStopParams = import_zod25.z.strictObject({
+var ExecJobStopParams = import_zod26.z.strictObject({
   job_id: ExecJobId,
   /** End it at once (SIGKILL; on Windows the whole tree with /F) instead of asking it to quit. */
-  force: import_zod25.z.boolean().default(false)
+  force: import_zod26.z.boolean().default(false)
 });
-var ExecJobStopResult = import_zod25.z.strictObject({ job_id: ExecJobId, exited: import_zod25.z.boolean(), exit_code: import_zod25.z.int().nullable() });
-var ExecJobInfo = import_zod25.z.strictObject({
+var ExecJobStopResult = import_zod26.z.strictObject({ job_id: ExecJobId, exited: import_zod26.z.boolean(), exit_code: import_zod26.z.int().nullable() });
+var ExecJobInfo = import_zod26.z.strictObject({
   job_id: ExecJobId,
-  command: import_zod25.z.string().max(1024),
-  pid: import_zod25.z.int().min(1),
+  command: import_zod26.z.string().max(1024),
+  pid: import_zod26.z.int().min(1),
   cwd: AbsPath,
-  running: import_zod25.z.boolean(),
-  exit_code: import_zod25.z.int().nullable(),
+  running: import_zod26.z.boolean(),
+  exit_code: import_zod26.z.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = import_zod25.z.strictObject({});
-var ExecJobListResult = import_zod25.z.strictObject({ jobs: import_zod25.z.array(ExecJobInfo).max(64) });
+var ExecJobListParams = import_zod26.z.strictObject({});
+var ExecJobListResult = import_zod26.z.strictObject({ jobs: import_zod26.z.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-var import_zod26 = require("zod");
-var CodingServiceCredentials = import_zod26.z.strictObject({
-  access_token: import_zod26.z.string().min(16).max(16384),
-  user_id: import_zod26.z.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}$/),
+var import_zod27 = require("zod");
+var CodingServiceCredentials = import_zod27.z.strictObject({
+  access_token: import_zod27.z.string().min(16).max(16384),
+  user_id: import_zod27.z.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: import_zod26.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: import_zod27.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = import_zod26.z.enum([
+var CodingHistoryBlocked = import_zod27.z.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -1923,11 +2154,11 @@ var CodingHistoryBlocked = import_zod26.z.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = import_zod26.z.strictObject({
-  session_id: import_zod26.z.string().max(64),
-  reason: import_zod26.z.string().max(300)
+var CodingHistoryFailure = import_zod27.z.strictObject({
+  session_id: import_zod27.z.string().max(64),
+  reason: import_zod27.z.string().max(300)
 });
-var CodingHistoryRun = import_zod26.z.strictObject({
+var CodingHistoryRun = import_zod27.z.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -1942,39 +2173,39 @@ var CodingHistoryRun = import_zod26.z.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: import_zod26.z.array(CodingHistoryFailure).max(20),
+  failures: import_zod27.z.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: import_zod26.z.string().max(400)
+  summary: import_zod27.z.string().max(400)
 });
-var CodingHistoryStep = import_zod26.z.strictObject({
+var CodingHistoryStep = import_zod27.z.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: import_zod26.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: import_zod26.z.boolean(),
+  plan_id: import_zod27.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: import_zod27.z.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = import_zod26.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = import_zod26.z.strictObject({
-  plan_id: import_zod26.z.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = import_zod27.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = import_zod27.z.strictObject({
+  plan_id: import_zod27.z.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = import_zod26.z.strictObject({
-  phase: import_zod26.z.enum(["checking", "importing"]),
+var CodingServiceProgress = import_zod27.z.strictObject({
+  phase: import_zod27.z.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = import_zod26.z.strictObject({});
-var CodingHistoryImportMissingResult = import_zod26.z.strictObject({
-  state: import_zod26.z.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = import_zod27.z.strictObject({});
+var CodingHistoryImportMissingResult = import_zod27.z.strictObject({
+  state: import_zod27.z.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = import_zod26.z.strictObject({
+var CodingHistoryProgressEvent = import_zod27.z.strictObject({
   request_id: RequestId,
-  phase: import_zod26.z.enum(["checking", "importing"]),
+  phase: import_zod27.z.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -2028,6 +2259,26 @@ var OPS = {
   "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"] },
+  // 1.10: the app's windows and accounts (usage by vote, weekly resets, window actions), project move/create, Refresh pins.
+  "apps.windows.list": { params: AppsWindowsListParams, result: AppsWindowsListResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.windows.open": { params: AppsWindowsOpenParams, result: AppsWindowActionResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.windows.reload": { params: AppsWindowsReloadParams, result: AppsWindowActionResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "CONFLICT", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.windows.restart": { params: AppsWindowsRestartParams, result: AppsWindowActionResult, kind: "unary", since: "1.10", errors: ["NOT_FOUND", "CONFLICT", "TIMEOUT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "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"] },
+  "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"] },
+  // 1.11: Going cold, Spend, sync health, windows upkeep.
+  "apps.chats.cold": { params: AppsChatsColdParams, result: AppsChatsColdResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.chats.open": { params: AppsChatsOpenParams, result: AppsWindowActionResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "CONFLICT", "TIMEOUT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.spend": { params: AppsSpendParams, result: AppsSpendResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.sync.status": { params: AppsSyncStatusParams, result: AppsSyncStatusResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.sync.run": { params: AppsSyncRunParams, result: AppsWindowActionResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.windows.processes": { params: AppsWindowsProcessesParams, result: AppsWindowsProcessesResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.windows.add": { params: AppsWindowsAddParams, result: AppsWindowActionResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "apps.windows.save_names": { params: AppsWindowsSaveNamesParams, result: AppsWindowActionResult, kind: "unary", since: "1.11", errors: ["NOT_FOUND", "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"] },
@@ -2360,7 +2611,51 @@ var NAMED_SCHEMAS = {
   AppsProjectsUpdateParams,
   AppsProjectsUpdateResult,
   AppsProjectsCopyParams,
-  AppsProjectsCopyResult
+  AppsProjectsCopyResult,
+  ChatFamily,
+  AppWindowInfo,
+  AccountUsage,
+  AccountReset,
+  AppsWindowsListParams,
+  AppsWindowsListResult,
+  AppsAccountsUsageParams,
+  AppsAccountsUsageResult,
+  AppsAccountsResetsParams,
+  AppsAccountsResetsResult,
+  AppsWindowActionResult,
+  AppsWindowsOpenParams,
+  AppsWindowsReloadParams,
+  AppsWindowsRestartParams,
+  AppsWindowsRefreshUsageParams,
+  AppsProjectsMoveParams,
+  AppsProjectsMoveResult,
+  AppsProjectsCreateParams,
+  AppsProjectsCreateResult,
+  AppsProjectsImportPinsParams,
+  AppsProjectsImportPinsResult,
+  ColdChat,
+  AppsChatsColdParams,
+  AppsChatsColdResult,
+  AppsChatsOpenParams,
+  SpendSplit,
+  SpendScopes,
+  SpendAccount,
+  SpendModel,
+  SpendChat,
+  SpendHelper,
+  SpendLive,
+  SpendIdleScope,
+  SpendIdle,
+  SpendStart,
+  AppsSpendParams,
+  AppsSpendResult,
+  AppsSyncStatusParams,
+  AppsSyncStatusResult,
+  AppsSyncRunParams,
+  AppsWindowsProcessesParams,
+  AppsWindowsProcessesResult,
+  AppsWindowsAddParams,
+  AppsWindowsSaveNamesParams
 };
 
 // src/versioning.ts
@@ -2370,7 +2665,7 @@ var FIELDS_SINCE = {
   "RelayCallResponse|0": { protocol_version: "1.1" },
   "RelayCallResponse|1": { protocol_version: "1.1" },
   WindowInfo: { app: "1.7", pid: "1.7" },
-  AppsChatsListResult: { updating: "1.9", live: "1.9" }
+  AppsChatsListResult: { updating: "1.9", live: "1.9", families: "1.10" }
 };
 var NULL_SINCE = {
   "RelayDeviceStatusEvent.since_ms": { since: "1.1", olderPeersGet: 0 }
@@ -2467,7 +2762,7 @@ function forPeer(op, part, value, version) {
 var VERSIONED_RESULT_OPS = [...RESULT_PATH.keys(), ...WINDOW_RESULTS.keys()];
 
 // src/contract.ts
-var CONTRACT_SHA256 = "8a36e6b958c871853f0a9520e49c92dd30aa05442765c5a1f04c4caa71a35229";
+var CONTRACT_SHA256 = "de809e319141925b0d86c5acbfe2493f3a85cad7c668c3e20b082e9319f5199b";
 
 // src/close-policy.ts
 var CLOSE_RULES = {