@ai-matrx/desktop-protocol 0.18.0 → 0.20.0

package/dist/client.cjs

@@ -144,7 +144,7 @@ var import_zod2 = require("zod");
 var import_zod = require("zod");
 var import_uuid = require("@ai-matrx/kit/uuid");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 17;
+var PROTOCOL_MINOR = 20;
 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_-]+$/);
@@ -1304,178 +1304,262 @@ var ResourcesIncidentsResult = import_zod19.z.strictObject({
   incidents: import_zod19.z.array(ResourcesIncident).max(200)
 });
 
-// src/schema/stack.ts
+// src/schema/diag.ts
 var import_zod20 = require("zod");
-var StackServerName = import_zod20.z.string().regex(/^[a-z0-9_-]{1,64}$/);
-var StackTone = import_zod20.z.enum(["good", "wait", "bad", "off"]);
-var StackServer = import_zod20.z.strictObject({
+var DiagProcess = import_zod20.z.enum([
+  "main",
+  "renderer",
+  "hosted_page",
+  "core",
+  "pty_host",
+  "python_ml",
+  "python_coding",
+  "python_tools",
+  "relay",
+  "coding_sessions",
+  "claude_accounts"
+]);
+var DiagErrorKind = import_zod20.z.enum([
+  "uncaught_exception",
+  "unhandled_rejection",
+  "renderer_crash",
+  "native_crash",
+  "console_error",
+  "load_failed",
+  "op_failed",
+  "child_exit",
+  "banner",
+  "logged_error"
+]);
+var DiagErrorStatus = import_zod20.z.enum(["waiting", "sent", "resolved"]);
+var DiagErrorEntry = import_zod20.z.strictObject({
+  /** sha256 prefix over process, kind, source, code and the normalized message. */
+  signature: import_zod20.z.string().regex(/^[0-9a-f]{32}$/),
+  process: DiagProcess,
+  kind: DiagErrorKind,
+  /** Where: a cap.op, a log event, a screen or page name. */
+  source: import_zod20.z.string().min(1).max(128),
+  /** An ErrorCode, an exit code or signal, an error class; null when there is none. */
+  code: import_zod20.z.string().max(64).nullable(),
+  /** The first occurrence's message, personal data removed. */
+  message: import_zod20.z.string().max(500),
+  count: nonNegInt,
+  first_seen_ms: epochMs,
+  last_seen_ms: epochMs,
+  status: DiagErrorStatus,
+  /** What the agent who resolved it wrote; null until resolved. */
+  resolution_note: import_zod20.z.string().max(500).nullable(),
+  app_version: import_zod20.z.string().max(64)
+});
+var DiagErrorsListParams = import_zod20.z.strictObject({
+  /** open = waiting or sent; all includes resolved. */
+  status: import_zod20.z.enum(["open", "all"]).default("open"),
+  limit: import_zod20.z.int().min(1).max(500).default(200)
+});
+var DiagErrorsListResult = import_zod20.z.strictObject({
+  /** Newest last_seen first. */
+  entries: import_zod20.z.array(DiagErrorEntry).max(500),
+  total_signatures: nonNegInt,
+  total_occurrences: nonNegInt,
+  /** Signatures with occurrences not yet delivered. */
+  waiting: nonNegInt,
+  /** signed_out = kept until sign-in; ok = the last delivery worked; failing = the last delivery failed (kept, retried). */
+  delivery: import_zod20.z.enum(["signed_out", "ok", "failing"]),
+  last_delivery_ms: epochMs.nullable()
+});
+var DiagErrorsReportParams = import_zod20.z.strictObject({
+  process: import_zod20.z.enum(["renderer", "hosted_page"]),
+  kind: import_zod20.z.enum(["uncaught_exception", "unhandled_rejection", "console_error", "banner"]),
+  /** The screen or page, e.g. "code.chats". */
+  source: import_zod20.z.string().min(1).max(128),
+  message: import_zod20.z.string().min(1).max(2e3),
+  code: import_zod20.z.string().max(64).optional(),
+  stack: import_zod20.z.string().max(8e3).optional()
+});
+var DiagErrorsReportResult = import_zod20.z.strictObject({
+  signature: import_zod20.z.string().regex(/^[0-9a-f]{32}$/)
+});
+var DiagErrorsChangedEvent = import_zod20.z.strictObject({
+  total_signatures: nonNegInt,
+  waiting: nonNegInt
+});
+
+// src/schema/stack.ts
+var import_zod21 = require("zod");
+var StackServerName = import_zod21.z.string().regex(/^[a-z0-9_-]{1,64}$/);
+var StackTone = import_zod21.z.enum(["good", "wait", "bad", "off"]);
+var StackServer = import_zod21.z.strictObject({
   name: StackServerName,
   /** One word: Healthy, Starting, Unhealthy, Restarting, Stopping, Waiting, Stopped, Crashed, Off. */
-  label: import_zod20.z.string().max(32),
+  label: import_zod21.z.string().max(32),
   tone: StackTone,
   /** What is going on, in one or two plain sentences. */
-  sentence: import_zod20.z.string().max(2e3),
+  sentence: import_zod21.z.string().max(2e3),
   /** The config's own description of the server. */
-  description: import_zod20.z.string().max(512),
+  description: import_zod21.z.string().max(512),
   /** Where the server answers, when its description names an address. */
-  open_url: import_zod20.z.string().max(2048).nullable(),
-  log_file: import_zod20.z.string().max(4096),
+  open_url: import_zod21.z.string().max(2048).nullable(),
+  log_file: import_zod21.z.string().max(4096),
   /** When its log file was last written. */
   last_output_at_ms: epochMs.nullable(),
   started_at_ms: epochMs.nullable(),
   restarts: nonNegInt,
-  exit_code: import_zod20.z.int().nullable(),
-  pid: import_zod20.z.int().nullable()
-});
-var StackEvent = import_zod20.z.strictObject({
+  exit_code: import_zod21.z.int().nullable(),
+  pid: import_zod21.z.int().nullable(),
+  /** (1.18) CPU of the server's process and everything under it, in percent of one core; absent when it is not running. */
+  cpu_percent: import_zod21.z.number().min(0).optional(),
+  /** (1.18) Memory of the same processes: the physical footprint (Activity Monitor's Memory) summed; absent when it is not running. */
+  memory_bytes: nonNegInt.optional()
+});
+var StackEvent = import_zod21.z.strictObject({
   at_ms: epochMs,
   /** A server name, or "stack" for the stack as a whole. */
-  server: import_zod20.z.string().max(64),
+  server: import_zod21.z.string().max(64),
   /** started · stopped · healthy · unhealthy · crashed · exited · restarting · stopping · action · action-done · action-failed · setup · error */
-  kind: import_zod20.z.string().max(32),
-  text: import_zod20.z.string().max(4e3)
+  kind: import_zod21.z.string().max(32),
+  text: import_zod21.z.string().max(4e3)
 });
-var StackStateParams = import_zod20.z.strictObject({});
-var StackStateResult = import_zod20.z.strictObject({
+var StackStateParams = import_zod21.z.strictObject({});
+var StackStateResult = import_zod21.z.strictObject({
   /** The stack's config file, when found. */
-  config_path: import_zod20.z.string().max(4096).nullable(),
+  config_path: import_zod21.z.string().max(4096).nullable(),
   /** Why the stack cannot be run from here (no config, no process-compose), else null. */
-  problem: import_zod20.z.string().max(1e3).nullable(),
-  stack_up: import_zod20.z.boolean(),
+  problem: import_zod21.z.string().max(1e3).nullable(),
+  stack_up: import_zod21.z.boolean(),
   stack_started_at_ms: epochMs.nullable(),
-  servers: import_zod20.z.array(StackServer).max(64),
+  servers: import_zod21.z.array(StackServer).max(64),
   /** One line about the one-shot setup steps ("Docker Desktop: running."), or null. */
-  setup_note: import_zod20.z.string().max(500).nullable(),
+  setup_note: import_zod21.z.string().max(500).nullable(),
   /** Start everything / Stop everything in flight. */
-  pending: import_zod20.z.strictObject({ verb: import_zod20.z.enum(["start", "stop"]), label: import_zod20.z.string().max(64), since_ms: epochMs }).nullable(),
+  pending: import_zod21.z.strictObject({ verb: import_zod21.z.enum(["start", "stop"]), label: import_zod21.z.string().max(64), since_ms: epochMs }).nullable(),
   /** The newest entries last. */
-  events: import_zod20.z.array(StackEvent).max(300)
+  events: import_zod21.z.array(StackEvent).max(300)
 });
-var StackStartParams = import_zod20.z.strictObject({});
-var StackStopParams = import_zod20.z.strictObject({});
-var StackRunResult = import_zod20.z.strictObject({ accepted: import_zod20.z.boolean() });
-var StackServerActionParams = import_zod20.z.strictObject({
+var StackStartParams = import_zod21.z.strictObject({});
+var StackStopParams = import_zod21.z.strictObject({});
+var StackRunResult = import_zod21.z.strictObject({ accepted: import_zod21.z.boolean() });
+var StackServerActionParams = import_zod21.z.strictObject({
   name: StackServerName,
-  verb: import_zod20.z.enum(["start", "stop", "restart"])
+  verb: import_zod21.z.enum(["start", "stop", "restart"])
 });
-var StackServerActionResult = import_zod20.z.strictObject({ message: import_zod20.z.string().max(1e3) });
-var StackLogsParams = import_zod20.z.strictObject({
+var StackServerActionResult = import_zod21.z.strictObject({ message: import_zod21.z.string().max(1e3) });
+var StackLogsParams = import_zod21.z.strictObject({
   name: StackServerName,
   /** Without `offset`: the last this-many complete lines. With it: new lines after it, at most this many. */
-  lines: import_zod20.z.int().min(1).max(2e5).default(2e3),
+  lines: import_zod21.z.int().min(1).max(2e5).default(2e3),
   /** Byte offset the last read ended at: answer only what was written after it (follow). */
   offset: nonNegInt.optional(),
   /** A "Clear" point: the lines written after this byte offset (no `offset`). */
   since: nonNegInt.optional(),
   /** With `offset`: wait up to this long for a new line when none is waiting (0 answers at once). */
-  wait_ms: import_zod20.z.int().min(0).max(25e3).default(0)
+  wait_ms: import_zod21.z.int().min(0).max(25e3).default(0)
 });
-var StackLogsResult = import_zod20.z.strictObject({
+var StackLogsResult = import_zod21.z.strictObject({
   /** Complete lines, colour codes removed. */
-  lines: import_zod20.z.array(import_zod20.z.string().max(65536)).max(2e5),
+  lines: import_zod21.z.array(import_zod21.z.string().max(65536)).max(2e5),
   /** Where these lines end: pass it back as `offset` to follow. */
   offset: nonNegInt,
   /** False when `since` no longer exists (the log rotated): the lines are the plain tail instead. */
-  since_valid: import_zod20.z.boolean(),
+  since_valid: import_zod21.z.boolean(),
   /** The log was rotated or truncated since `offset`: these lines start the file again. */
-  reset: import_zod20.z.boolean(),
-  log_file: import_zod20.z.string().max(4096)
+  reset: import_zod21.z.boolean(),
+  log_file: import_zod21.z.string().max(4096)
 });
-var StackErrorsParams = import_zod20.z.strictObject({
-  window_minutes: import_zod20.z.int().min(1).max(1440).default(60)
+var StackErrorsParams = import_zod21.z.strictObject({
+  window_minutes: import_zod21.z.int().min(1).max(1440).default(60)
 });
-var StackErrorsResult = import_zod20.z.strictObject({
+var StackErrorsResult = import_zod21.z.strictObject({
   /** Per server: a heading line ("=== aidream — errors in the last 60 minutes (<file>) ===") and each error with the 10 lines after it. */
-  sections: import_zod20.z.array(import_zod20.z.strictObject({ name: StackServerName, heading: import_zod20.z.string().max(4096), lines: import_zod20.z.array(import_zod20.z.string().max(65536)).max(5e3) })).max(64),
-  window_minutes: import_zod20.z.int().min(1).max(1440)
+  sections: import_zod21.z.array(import_zod21.z.strictObject({ name: StackServerName, heading: import_zod21.z.string().max(4096), lines: import_zod21.z.array(import_zod21.z.string().max(65536)).max(5e3) })).max(64),
+  window_minutes: import_zod21.z.int().min(1).max(1440)
 });
 
 // src/schema/fs-watch.ts
-var import_zod21 = require("zod");
-var FsWatchId = import_zod21.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = import_zod21.z.strictObject({
+var import_zod22 = require("zod");
+var FsWatchId = import_zod22.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = import_zod22.z.strictObject({
   path: AbsPath,
-  recursive: import_zod21.z.boolean().default(true),
+  recursive: import_zod22.z.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: import_zod21.z.array(import_zod21.z.string().max(256)).max(64).default([])
+  ignore: import_zod22.z.array(import_zod22.z.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = import_zod21.z.strictObject({
+var FsWatchStartResult = import_zod22.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_zod21.z.strictObject({
+var FsWatchEventsParams = import_zod22.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_zod21.z.int().min(0).max(25e3).default(0)
+  wait_ms: import_zod22.z.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = import_zod21.z.strictObject({
+var FsWatchEventsResult = import_zod22.z.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: import_zod21.z.array(FsChange).max(1e3),
+  changes: import_zod22.z.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: import_zod21.z.boolean(),
+  overflow: import_zod22.z.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = import_zod21.z.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = import_zod21.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = import_zod22.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = import_zod22.z.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-var import_zod22 = require("zod");
-var ExecJobId = import_zod22.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = import_zod22.z.strictObject({
-  command: import_zod22.z.string().min(1).max(131072),
+var import_zod23 = require("zod");
+var ExecJobId = import_zod23.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = import_zod23.z.strictObject({
+  command: import_zod23.z.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: import_zod22.z.record(import_zod22.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod22.z.string().max(32768)).optional()
+  env: import_zod23.z.record(import_zod23.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod23.z.string().max(32768)).optional()
 });
-var ExecJobStartResult = import_zod22.z.strictObject({ job_id: ExecJobId, pid: import_zod22.z.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = import_zod22.z.strictObject({
+var ExecJobStartResult = import_zod23.z.strictObject({ job_id: ExecJobId, pid: import_zod23.z.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = import_zod23.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_zod22.z.int().min(0).max(25e3).default(0),
-  max_bytes: import_zod22.z.int().min(1024).max(1048576).default(65536)
+  wait_ms: import_zod23.z.int().min(0).max(25e3).default(0),
+  max_bytes: import_zod23.z.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = import_zod22.z.strictObject({
+var ExecJobOutputResult = import_zod23.z.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: import_zod22.z.string(),
+  output: import_zod23.z.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: import_zod22.z.boolean(),
-  exit_code: import_zod22.z.int().nullable()
+  running: import_zod23.z.boolean(),
+  exit_code: import_zod23.z.int().nullable()
 });
-var ExecJobStopParams = import_zod22.z.strictObject({
+var ExecJobStopParams = import_zod23.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_zod22.z.boolean().default(false)
+  force: import_zod23.z.boolean().default(false)
 });
-var ExecJobStopResult = import_zod22.z.strictObject({ job_id: ExecJobId, exited: import_zod22.z.boolean(), exit_code: import_zod22.z.int().nullable() });
-var ExecJobInfo = import_zod22.z.strictObject({
+var ExecJobStopResult = import_zod23.z.strictObject({ job_id: ExecJobId, exited: import_zod23.z.boolean(), exit_code: import_zod23.z.int().nullable() });
+var ExecJobInfo = import_zod23.z.strictObject({
   job_id: ExecJobId,
-  command: import_zod22.z.string().max(1024),
-  pid: import_zod22.z.int().min(1),
+  command: import_zod23.z.string().max(1024),
+  pid: import_zod23.z.int().min(1),
   cwd: AbsPath,
-  running: import_zod22.z.boolean(),
-  exit_code: import_zod22.z.int().nullable(),
+  running: import_zod23.z.boolean(),
+  exit_code: import_zod23.z.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = import_zod22.z.strictObject({});
-var ExecJobListResult = import_zod22.z.strictObject({ jobs: import_zod22.z.array(ExecJobInfo).max(64) });
+var ExecJobListParams = import_zod23.z.strictObject({});
+var ExecJobListResult = import_zod23.z.strictObject({ jobs: import_zod23.z.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 var import_uuid2 = require("@ai-matrx/kit/uuid");
-var CodingServiceCredentials = import_zod23.z.strictObject({
-  access_token: import_zod23.z.string().min(16).max(16384),
-  user_id: import_zod23.z.string().regex(import_uuid2.UUID_SHAPE_PATTERN),
+var CodingServiceCredentials = import_zod24.z.strictObject({
+  access_token: import_zod24.z.string().min(16).max(16384),
+  user_id: import_zod24.z.string().regex(import_uuid2.UUID_SHAPE_PATTERN),
   /** The AI Matrx server this app talks to (production, or a local server on the nightly copy). */
-  server_url: import_zod23.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: import_zod24.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = import_zod23.z.enum([
+var CodingHistoryBlocked = import_zod24.z.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -1483,11 +1567,11 @@ var CodingHistoryBlocked = import_zod23.z.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = import_zod23.z.strictObject({
-  session_id: import_zod23.z.string().max(64),
-  reason: import_zod23.z.string().max(300)
+var CodingHistoryFailure = import_zod24.z.strictObject({
+  session_id: import_zod24.z.string().max(64),
+  reason: import_zod24.z.string().max(300)
 });
-var CodingHistoryRun = import_zod23.z.strictObject({
+var CodingHistoryRun = import_zod24.z.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -1502,39 +1586,39 @@ var CodingHistoryRun = import_zod23.z.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: import_zod23.z.array(CodingHistoryFailure).max(20),
+  failures: import_zod24.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_zod23.z.string().max(400)
+  summary: import_zod24.z.string().max(400)
 });
-var CodingHistoryStep = import_zod23.z.strictObject({
+var CodingHistoryStep = import_zod24.z.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: import_zod23.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: import_zod23.z.boolean(),
+  plan_id: import_zod24.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: import_zod24.z.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = import_zod23.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = import_zod23.z.strictObject({
-  plan_id: import_zod23.z.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = import_zod24.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = import_zod24.z.strictObject({
+  plan_id: import_zod24.z.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = import_zod23.z.strictObject({
-  phase: import_zod23.z.enum(["checking", "importing"]),
+var CodingServiceProgress = import_zod24.z.strictObject({
+  phase: import_zod24.z.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = import_zod23.z.strictObject({});
-var CodingHistoryImportMissingResult = import_zod23.z.strictObject({
-  state: import_zod23.z.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = import_zod24.z.strictObject({});
+var CodingHistoryImportMissingResult = import_zod24.z.strictObject({
+  state: import_zod24.z.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = import_zod23.z.strictObject({
+var CodingHistoryProgressEvent = import_zod24.z.strictObject({
   request_id: RequestId,
-  phase: import_zod23.z.enum(["checking", "importing"]),
+  phase: import_zod24.z.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -1543,23 +1627,23 @@ var CodingHistoryProgressEvent = import_zod23.z.strictObject({
 });
 
 // src/schema/apps.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 var import_uuid3 = require("@ai-matrx/kit/uuid");
-var AppKey = import_zod24.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
-var AppProfileId = import_zod24.z.string().regex(import_uuid3.UUID_SHAPE_PATTERN);
-var AppProfileLocator = import_zod24.z.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
-var AppSupport = import_zod24.z.enum(["supported", "partial", "unsupported"]);
-var AppFeatureStatus = import_zod24.z.strictObject({
+var AppKey = import_zod25.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+var AppProfileId = import_zod25.z.string().regex(import_uuid3.UUID_SHAPE_PATTERN);
+var AppProfileLocator = import_zod25.z.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
+var AppSupport = import_zod25.z.enum(["supported", "partial", "unsupported"]);
+var AppFeatureStatus = import_zod25.z.strictObject({
   status: AppSupport,
   /** One line, set whenever status is not "supported". */
-  reason: import_zod24.z.string().max(140).nullable()
+  reason: import_zod25.z.string().max(140).nullable()
 });
-var AppInfo = import_zod24.z.strictObject({
+var AppInfo = import_zod25.z.strictObject({
   app_key: AppKey,
-  name: import_zod24.z.string().max(64),
-  installed: import_zod24.z.boolean(),
+  name: import_zod25.z.string().max(64),
+  installed: import_zod25.z.boolean(),
   /** The app's own version string, or null when it is not installed or does not say. */
-  version: import_zod24.z.string().max(64).nullable(),
+  version: import_zod25.z.string().max(64).nullable(),
   /** The install found (an .app bundle, an .exe, a binary), or null. */
   location: AbsPath.nullable(),
   /** Open the app at all on this OS. */
@@ -1569,148 +1653,148 @@ var AppInfo = import_zod24.z.strictObject({
   /** Plan usage read from the app's own files on this OS. */
   usage: AppFeatureStatus
 });
-var AppUsageReading = import_zod24.z.strictObject({
-  window: import_zod24.z.enum(["five_hour", "weekly", "extra"]),
+var AppUsageReading = import_zod25.z.strictObject({
+  window: import_zod25.z.enum(["five_hour", "weekly", "extra"]),
   /** 0–100 for five_hour and weekly; extra-usage spend as a percent of its cap (may pass 100). */
-  percent: import_zod24.z.number().min(0).max(1e4),
+  percent: import_zod25.z.number().min(0).max(1e4),
   /** When the app recorded it. */
   sampled_at_ms: epochMs,
   /** True when the window has rolled over since the sample, so the figure has reset. */
-  reset_since: import_zod24.z.boolean()
+  reset_since: import_zod25.z.boolean()
 });
-var AppProfile = import_zod24.z.strictObject({
+var AppProfile = import_zod25.z.strictObject({
   /** The row's id; null for a folder found on disk that no row names yet. */
   id: AppProfileId.nullable(),
   app_key: AppKey,
-  display_name: import_zod24.z.string().min(1).max(120),
+  display_name: import_zod25.z.string().min(1).max(120),
   /** The account the person means to be signed in here; null when not stated (never guessed). */
-  account_identity: import_zod24.z.string().min(3).max(320).nullable(),
+  account_identity: import_zod25.z.string().min(3).max(320).nullable(),
   profile_locator: AppProfileLocator.nullable(),
   /** The device the row is tied to; null when the row names none. */
   device_id: DeviceId.nullable(),
   /** The folder this profile resolves to on this device; null for a row tied to another device. */
   folder: AbsPath.nullable(),
   /** The folder exists on this device. */
-  on_disk: import_zod24.z.boolean(),
+  on_disk: import_zod25.z.boolean(),
   /** An instance with this profile is running; null when it could not be determined. */
-  running: import_zod24.z.boolean().nullable(),
+  running: import_zod25.z.boolean().nullable(),
   /** Usage the app recorded for this profile; null when the app exposes none here. */
-  usage: import_zod24.z.array(AppUsageReading).nullable(),
+  usage: import_zod25.z.array(AppUsageReading).nullable(),
   last_opened_ms: epochMs.nullable()
 });
-var AppsListParams = import_zod24.z.strictObject({});
-var AppsListResult = import_zod24.z.strictObject({ apps: import_zod24.z.array(AppInfo) });
-var AppsProfilesListParams = import_zod24.z.strictObject({
+var AppsListParams = import_zod25.z.strictObject({});
+var AppsListResult = import_zod25.z.strictObject({ apps: import_zod25.z.array(AppInfo) });
+var AppsProfilesListParams = import_zod25.z.strictObject({
   /** Only this app's profiles; every app's when absent. */
   app_key: AppKey.optional()
 });
-var AppsProfilesListResult = import_zod24.z.strictObject({
-  profiles: import_zod24.z.array(AppProfile),
+var AppsProfilesListResult = import_zod25.z.strictObject({
+  profiles: import_zod25.z.array(AppProfile),
   /**
    * Whether the saved rows could be read: false while signed out or offline, when only folders
    * found on disk are listed.
    */
-  registry: import_zod24.z.enum(["ok", "signed_out", "unavailable"])
+  registry: import_zod25.z.enum(["ok", "signed_out", "unavailable"])
 });
-var AppsProfilesSaveParams = import_zod24.z.strictObject({
+var AppsProfilesSaveParams = import_zod25.z.strictObject({
   id: AppProfileId.optional(),
   app_key: AppKey,
-  display_name: import_zod24.z.string().min(1).max(120),
-  account_identity: import_zod24.z.string().min(3).max(320).nullable(),
+  display_name: import_zod25.z.string().min(1).max(120),
+  account_identity: import_zod25.z.string().min(3).max(320).nullable(),
   /** On create: the folder to use (one found on disk), or null for the app's default profile. Ignored on update. */
   profile_locator: AppProfileLocator.nullable(),
   /** On create with profile_locator null: make a new folder named after display_name instead. */
-  new_folder: import_zod24.z.boolean().default(false)
+  new_folder: import_zod25.z.boolean().default(false)
 });
 var AppsProfilesSaveResult = AppProfile;
-var AppsProfilesRemoveParams = import_zod24.z.strictObject({ id: AppProfileId });
-var AppsProfilesRemoveResult = import_zod24.z.strictObject({ removed: import_zod24.z.boolean() });
-var AppsOpenParams = import_zod24.z.strictObject({
+var AppsProfilesRemoveParams = import_zod25.z.strictObject({ id: AppProfileId });
+var AppsProfilesRemoveResult = import_zod25.z.strictObject({ removed: import_zod25.z.boolean() });
+var AppsOpenParams = import_zod25.z.strictObject({
   app_key: AppKey,
   profile_id: AppProfileId.optional()
 });
-var AppsOpenResult = import_zod24.z.strictObject({
+var AppsOpenResult = import_zod25.z.strictObject({
   /** True when an instance with this profile was already running; it is brought forward. */
-  already_running: import_zod24.z.boolean(),
+  already_running: import_zod25.z.boolean(),
   folder: AbsPath.nullable()
 });
 
 // src/schema/apps-chats.ts
-var import_zod25 = require("zod");
-var ChatId = import_zod25.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/);
-var ChatPlace = import_zod25.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/);
-var ChatProjectId = import_zod25.z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
-var ChatWindow = import_zod25.z.strictObject({
+var import_zod26 = require("zod");
+var ChatId = import_zod26.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/);
+var ChatPlace = import_zod26.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/);
+var ChatProjectId = import_zod26.z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+var ChatWindow = import_zod26.z.strictObject({
   key: ChatPlace,
   /** The app's default profile (Claude: the main window, which lists every account's chats). */
-  main: import_zod25.z.boolean(),
+  main: import_zod26.z.boolean(),
   /** The account the window is signed into, when known. */
-  account: import_zod25.z.string().max(320).nullable()
+  account: import_zod26.z.string().max(320).nullable()
 });
-var ChatProject = import_zod25.z.strictObject({
+var ChatProject = import_zod26.z.strictObject({
   id: ChatProjectId,
-  name: import_zod25.z.string().min(1).max(200),
-  archived: import_zod25.z.boolean(),
+  name: import_zod26.z.string().min(1).max(200),
+  archived: import_zod26.z.boolean(),
   /** Chats in it. */
   count: nonNegInt
 });
-var ChatPin = import_zod25.z.strictObject({
+var ChatPin = import_zod26.z.strictObject({
   /** The window whose account pins it; an account with no window of its own is named by its email. */
-  window: import_zod25.z.string().min(1).max(320),
+  window: import_zod26.z.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 = import_zod25.z.strictObject({
+var ChatRunning = import_zod26.z.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: import_zod25.z.enum(["process", "activity"])
+  how: import_zod26.z.enum(["process", "activity"])
 });
-var ChatHidden = import_zod25.z.strictObject({
+var ChatHidden = import_zod26.z.strictObject({
   window: ChatPlace,
-  reason: import_zod25.z.string().max(200)
+  reason: import_zod26.z.string().max(200)
 });
-var ChatLastUse = import_zod25.z.strictObject({
+var ChatLastUse = import_zod26.z.strictObject({
   /** The conversation's last reply. */
   at_ms: epochMs,
   window: ChatPlace.nullable(),
-  account: import_zod25.z.string().max(320).nullable(),
+  account: import_zod26.z.string().max(320).nullable(),
   /** How the window was decided (one short line). */
-  how: import_zod25.z.string().max(120).nullable(),
+  how: import_zod26.z.string().max(120).nullable(),
   /** The account's 1-hour prompt cache is still warm. */
-  cache_warm: import_zod25.z.boolean(),
+  cache_warm: import_zod26.z.boolean(),
   cache_minutes_left: nonNegInt
 });
-var ChatAppProject = import_zod25.z.strictObject({
-  id: import_zod25.z.string().min(1).max(200),
-  name: import_zod25.z.string().max(200)
+var ChatAppProject = import_zod26.z.strictObject({
+  id: import_zod26.z.string().min(1).max(200),
+  name: import_zod26.z.string().max(200)
 });
-var ChatTitleSource = import_zod25.z.enum(["app", "app-remembered", "custom-title", "ai-title", "agent-name", "summary", "first-prompt", "last-prompt"]);
-var ChatRow = import_zod25.z.strictObject({
+var ChatTitleSource = import_zod26.z.enum(["app", "app-remembered", "custom-title", "ai-title", "agent-name", "summary", "first-prompt", "last-prompt"]);
+var ChatRow = import_zod26.z.strictObject({
   id: ChatId,
   /** The short id people see (the listing's first 8 characters). */
-  short_id: import_zod25.z.string().max(16),
+  short_id: import_zod26.z.string().max(16),
   /** The listing's own name (Claude: local_<id>), null for a chat only in the holder. */
-  record: import_zod25.z.string().max(160).nullable(),
-  title: import_zod25.z.string().max(1e3),
+  record: import_zod26.z.string().max(160).nullable(),
+  title: import_zod26.z.string().max(1e3),
   last_active_ms: epochMs.nullable(),
   created_ms: epochMs.nullable(),
-  projects: import_zod25.z.array(ChatProjectId).max(500),
-  starred: import_zod25.z.boolean(),
-  pinned_in: import_zod25.z.array(ChatPin).max(200),
+  projects: import_zod26.z.array(ChatProjectId).max(500),
+  starred: import_zod26.z.boolean(),
+  pinned_in: import_zod26.z.array(ChatPin).max(200),
   /** Every place it is listed now: window keys, plus "holder". */
-  places: import_zod25.z.array(ChatPlace).max(200),
-  held: import_zod25.z.boolean(),
-  running: import_zod25.z.array(ChatRunning).max(200),
-  hidden_in: import_zod25.z.array(ChatHidden).max(200),
+  places: import_zod26.z.array(ChatPlace).max(200),
+  held: import_zod26.z.boolean(),
+  running: import_zod26.z.array(ChatRunning).max(200),
+  hidden_in: import_zod26.z.array(ChatHidden).max(200),
   /** Kept out of the main window on purpose. */
-  hidden_from_main: import_zod25.z.boolean(),
+  hidden_from_main: import_zod26.z.boolean(),
   /** Listed in a side window and not yet copied into main. */
-  main_pending: import_zod25.z.boolean(),
+  main_pending: import_zod26.z.boolean(),
   /** A scheduled routine's run (its task id). */
-  scheduled: import_zod25.z.string().max(200).nullable(),
+  scheduled: import_zod26.z.string().max(200).nullable(),
   /** Created recently and in no project: offered for filing. */
-  new_unfiled: import_zod25.z.boolean(),
-  warnings: import_zod25.z.array(import_zod25.z.string().max(400)).max(20),
+  new_unfiled: import_zod26.z.boolean(),
+  warnings: import_zod26.z.array(import_zod26.z.string().max(400)).max(20),
   last_use: ChatLastUse.nullable(),
   /** 1.13: the app's own project the chat is grouped under in the app (Codex), read only; absent = none or not an app that groups. */
   app_project: ChatAppProject.optional(),
@@ -1720,285 +1804,322 @@ var ChatRow = import_zod25.z.strictObject({
    * 1.14: the chat's own title before the person's rename (the one title rule, `@ai-matrx/coding-sessions/sessions`);
    * `title` is what to show (`title_override` when set, else this).
    */
-  original_title: import_zod25.z.string().max(1e3).optional(),
+  original_title: import_zod26.z.string().max(1e3).optional(),
   /** 1.14: where `original_title` came from (the one rule's sources, strongest first; 1.15: a closed set). */
   title_source: ChatTitleSource.optional(),
   /** 1.14: the person's rename inside Matrx (Coding Sessions), applied once by the row builder; absent = none. */
-  title_override: import_zod25.z.string().min(1).max(300).optional(),
+  title_override: import_zod26.z.string().min(1).max(300).optional(),
   /** 1.15: the app itself archived it (hidden_in says where and why, in words for people; this is the typed fact). */
-  archived: import_zod25.z.boolean().optional()
+  archived: import_zod26.z.boolean().optional()
 });
-var ChatFamily = import_zod25.z.strictObject({
+var ChatFamily = import_zod26.z.strictObject({
   id: ChatId,
   fork_of: ChatId.nullable(),
   copy_of: ChatId.nullable()
 });
-var AppsChatsListParams = import_zod25.z.strictObject({
+var AppsChatsListParams = import_zod26.z.strictObject({
   app_key: AppKey,
   /** Only these chats (a live update re-reads just what changed). */
-  ids: import_zod25.z.array(ChatId).max(500).optional()
+  ids: import_zod26.z.array(ChatId).max(500).optional()
 });
-var AppsChatsListResult = import_zod25.z.strictObject({
+var AppsChatsListResult = import_zod26.z.strictObject({
   app_key: AppKey,
   /** Bumps on every change the index sees; `apps.chats.changed` carries the same number. */
   version: nonNegInt,
-  windows: import_zod25.z.array(ChatWindow).max(200),
-  projects: import_zod25.z.array(ChatProject).max(5e3),
-  chats: import_zod25.z.array(ChatRow).max(2e4),
+  windows: import_zod26.z.array(ChatWindow).max(200),
+  projects: import_zod26.z.array(ChatProject).max(5e3),
+  chats: import_zod26.z.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: import_zod25.z.boolean().optional(),
+  updating: import_zod26.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_zod25.z.boolean().optional(),
+  live: import_zod26.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_zod25.z.array(ChatFamily).max(2e4).optional()
+  families: import_zod26.z.array(ChatFamily).max(2e4).optional()
 });
-var AppsChatsWatchParams = import_zod25.z.strictObject({ app_key: AppKey });
-var AppsChatsWatchResult = import_zod25.z.strictObject({ resource_id: ResourceId, version: nonNegInt });
-var AppsChatsChangedEvent = import_zod25.z.strictObject({
+var AppsChatsWatchParams = import_zod26.z.strictObject({ app_key: AppKey });
+var AppsChatsWatchResult = import_zod26.z.strictObject({ resource_id: ResourceId, version: nonNegInt });
+var AppsChatsChangedEvent = import_zod26.z.strictObject({
   app_key: AppKey,
   version: nonNegInt,
-  ids: import_zod25.z.array(ChatId).max(1e3),
-  all: import_zod25.z.boolean()
+  ids: import_zod26.z.array(ChatId).max(1e3),
+  all: import_zod26.z.boolean()
 });
-var AppsChatsWatchStateEvent = import_zod25.z.strictObject({
+var AppsChatsWatchStateEvent = import_zod26.z.strictObject({
   app_key: AppKey,
-  live: import_zod25.z.boolean(),
-  updating: import_zod25.z.boolean(),
-  reason: import_zod25.z.string().max(300).nullable()
+  live: import_zod26.z.boolean(),
+  updating: import_zod26.z.boolean(),
+  reason: import_zod26.z.string().max(300).nullable()
 });
-var AppsChatsPlaceParams = import_zod25.z.strictObject({
+var AppsChatsPlaceParams = import_zod26.z.strictObject({
   app_key: AppKey,
   chat_id: ChatId,
-  action: import_zod25.z.enum(["place", "take_off", "hold"]),
+  action: import_zod26.z.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: import_zod25.z.boolean().default(false)
+  stop_if_open: import_zod26.z.boolean().default(false)
 });
-var AppsChatsPlaceResult = import_zod25.z.strictObject({ chat: ChatRow, message: import_zod25.z.string().max(400) });
-var AppsProjectsFileManyParams = import_zod25.z.strictObject({
+var AppsChatsPlaceResult = import_zod26.z.strictObject({ chat: ChatRow, message: import_zod26.z.string().max(400) });
+var AppsProjectsFileManyParams = import_zod26.z.strictObject({
   app_key: AppKey,
-  chat_ids: import_zod25.z.array(ChatId).min(1).max(500),
+  chat_ids: import_zod26.z.array(ChatId).min(1).max(500),
   project_id: ChatProjectId.optional(),
-  new_project_name: import_zod25.z.string().min(1).max(200).optional()
+  new_project_name: import_zod26.z.string().min(1).max(200).optional()
 });
-var AppsProjectsFileManyResult = import_zod25.z.strictObject({ chats: import_zod25.z.array(ChatRow).max(500), project: ChatProject });
-var AppsProjectsUpdateParams = import_zod25.z.strictObject({
+var AppsProjectsFileManyResult = import_zod26.z.strictObject({ chats: import_zod26.z.array(ChatRow).max(500), project: ChatProject });
+var AppsProjectsUpdateParams = import_zod26.z.strictObject({
   app_key: AppKey,
   project_id: ChatProjectId,
-  name: import_zod25.z.string().min(1).max(200).optional(),
-  archived: import_zod25.z.boolean().optional()
+  name: import_zod26.z.string().min(1).max(200).optional(),
+  archived: import_zod26.z.boolean().optional()
 });
-var AppsProjectsUpdateResult = import_zod25.z.strictObject({ project: ChatProject });
-var AppsProjectsCopyParams = import_zod25.z.strictObject({ app_key: AppKey, project_id: ChatProjectId, new_project_name: import_zod25.z.string().min(1).max(200) });
-var AppsProjectsCopyResult = import_zod25.z.strictObject({ project: ChatProject });
-var AppsProjectsFileParams = import_zod25.z.strictObject({
+var AppsProjectsUpdateResult = import_zod26.z.strictObject({ project: ChatProject });
+var AppsProjectsCopyParams = import_zod26.z.strictObject({ app_key: AppKey, project_id: ChatProjectId, new_project_name: import_zod26.z.string().min(1).max(200) });
+var AppsProjectsCopyResult = import_zod26.z.strictObject({ project: ChatProject });
+var AppsProjectsFileParams = import_zod26.z.strictObject({
   app_key: AppKey,
   chat_id: ChatId,
   project_id: ChatProjectId.optional(),
-  new_project_name: import_zod25.z.string().min(1).max(200).optional()
+  new_project_name: import_zod26.z.string().min(1).max(200).optional()
 });
-var AppsProjectsFileResult = import_zod25.z.strictObject({ chat: ChatRow, project: ChatProject });
-var AppsProjectsUnfileParams = import_zod25.z.strictObject({ app_key: AppKey, chat_id: ChatId, project_id: ChatProjectId });
-var AppsProjectsUnfileResult = import_zod25.z.strictObject({ chat: ChatRow });
-var AppsChatsStarParams = import_zod25.z.strictObject({ app_key: AppKey, chat_id: ChatId, starred: import_zod25.z.boolean() });
-var AppsChatsStarResult = import_zod25.z.strictObject({ chat: ChatRow });
+var AppsProjectsFileResult = import_zod26.z.strictObject({ chat: ChatRow, project: ChatProject });
+var AppsProjectsUnfileParams = import_zod26.z.strictObject({ app_key: AppKey, chat_id: ChatId, project_id: ChatProjectId });
+var AppsProjectsUnfileResult = import_zod26.z.strictObject({ chat: ChatRow });
+var AppsChatsStarParams = import_zod26.z.strictObject({ app_key: AppKey, chat_id: ChatId, starred: import_zod26.z.boolean() });
+var AppsChatsStarResult = import_zod26.z.strictObject({ chat: ChatRow });
 
 // src/schema/apps-accounts.ts
-var import_zod26 = require("zod");
-var AppWindowInfo = import_zod26.z.strictObject({
+var import_zod27 = require("zod");
+var AppWindowInfo = import_zod27.z.strictObject({
   key: ChatPlace,
   /** The app's default profile (Claude: main, which may sign into any account). */
-  main: import_zod26.z.boolean(),
+  main: import_zod27.z.boolean(),
   /** The account the window is meant for (null for main). */
-  account: import_zod26.z.string().max(320).nullable(),
+  account: import_zod27.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_zod26.z.string().max(320).nullable(),
-  signed_in_is_email: import_zod26.z.boolean(),
+  signed_in: import_zod27.z.string().max(320).nullable(),
+  signed_in_is_email: import_zod27.z.boolean(),
   /** Signed into another account than the one it is meant for. */
-  mismatch: import_zod26.z.boolean(),
+  mismatch: import_zod27.z.boolean(),
   /** Its folder exists. */
-  created: import_zod26.z.boolean(),
+  created: import_zod27.z.boolean(),
   /** Open now. */
-  running: import_zod26.z.boolean(),
+  running: import_zod27.z.boolean(),
   /** Chats open in it now (a process resuming each one). */
   open_chats: nonNegInt
 });
-var AccountUsage = import_zod26.z.strictObject({
+var AccountUsage = import_zod27.z.strictObject({
   /** The account's email, or "org <8 chars>" when no window has ever sampled that org. */
-  account: import_zod26.z.string().max(320),
-  org: import_zod26.z.string().max(80).nullable(),
+  account: import_zod27.z.string().max(320),
+  org: import_zod27.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_zod26.z.boolean(),
+  account_certain: import_zod27.z.boolean(),
   /** 5-hour use in percent (0 once the reading is over 5 hours old). */
-  five_hour: import_zod26.z.number().nullable(),
-  five_hour_reset_since: import_zod26.z.boolean(),
+  five_hour: import_zod27.z.number().nullable(),
+  five_hour_reset_since: import_zod27.z.boolean(),
   /** Weekly use in percent (0 once the week reset after the reading). */
-  weekly: import_zod26.z.number().nullable(),
-  weekly_reset_since: import_zod26.z.boolean(),
+  weekly: import_zod27.z.number().nullable(),
+  weekly_reset_since: import_zod27.z.boolean(),
   /** Extra-usage spend in percent of its cap, when on. */
-  extra_usage: import_zod26.z.number().nullable(),
+  extra_usage: import_zod27.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_zod26.z.array(ChatPlace).max(200),
+  windows: import_zod27.z.array(ChatPlace).max(200),
   /** The window that took the reading is open now and the reading is under 30 minutes old. */
-  live: import_zod26.z.boolean(),
+  live: import_zod27.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_zod26.z.boolean().nullable(),
+  weekly_reset_official: import_zod27.z.boolean().nullable(),
   /** 1.13: the account's plan as the app names it (Codex: "pro", "prolite"), when recorded. */
-  plan: import_zod26.z.string().max(80).optional(),
+  plan: import_zod27.z.string().max(80).optional(),
   /** 1.13: the account's credit balance as the app records it (Codex), when recorded. */
-  credits: import_zod26.z.string().max(40).optional()
+  credits: import_zod27.z.string().max(40).optional()
 });
-var AccountReset = import_zod26.z.strictObject({
+var AccountReset = import_zod27.z.strictObject({
   window: ChatPlace,
-  account: import_zod26.z.string().max(320).nullable(),
+  account: import_zod27.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_zod26.z.enum(["claude", "usage_history", "your_list"]).nullable(),
+  source: import_zod27.z.enum(["claude", "usage_history", "your_list"]).nullable(),
   /** claude or usage_history. */
-  official: import_zod26.z.boolean(),
+  official: import_zod27.z.boolean(),
   /** Set when the person's list disagrees with the official time. */
-  note: import_zod26.z.string().max(200).nullable()
+  note: import_zod27.z.string().max(200).nullable()
 });
-var AppsWindowsListParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsWindowsListResult = import_zod26.z.strictObject({ app_key: AppKey, windows: import_zod26.z.array(AppWindowInfo).max(200) });
-var AppsAccountsUsageParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsAccountsUsageResult = import_zod26.z.strictObject({
+var AppsWindowsListParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsWindowsListResult = import_zod27.z.strictObject({ app_key: AppKey, windows: import_zod27.z.array(AppWindowInfo).max(200) });
+var AppsAccountsUsageParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsAccountsUsageResult = import_zod27.z.strictObject({
   app_key: AppKey,
-  accounts: import_zod26.z.array(AccountUsage).max(500),
+  accounts: import_zod27.z.array(AccountUsage).max(500),
   /** 1.12: the rows are right but something around them failed (a newly read reset time could not be saved); shown, never hidden. */
-  problem: import_zod26.z.string().max(400).optional()
+  problem: import_zod27.z.string().max(400).optional()
 });
-var AppsAccountsResetsParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsAccountsResetsResult = import_zod26.z.strictObject({
+var AppsAccountsResetsParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsAccountsResetsResult = import_zod27.z.strictObject({
   app_key: AppKey,
-  resets: import_zod26.z.array(AccountReset).max(200),
+  resets: import_zod27.z.array(AccountReset).max(200),
   /** 1.12: as on `apps.accounts.usage`. */
-  problem: import_zod26.z.string().max(400).optional()
-});
-var AppsWindowActionResult = import_zod26.z.strictObject({ message: import_zod26.z.string().max(400) });
-var AppsWindowsOpenParams = import_zod26.z.strictObject({ app_key: AppKey, window: ChatPlace });
-var AppsWindowsReloadParams = import_zod26.z.strictObject({ app_key: AppKey, window: ChatPlace });
-var AppsWindowsRestartParams = import_zod26.z.strictObject({ app_key: AppKey, window: ChatPlace, force: import_zod26.z.boolean().default(false) });
-var AppsWindowsRefreshUsageParams = import_zod26.z.strictObject({ app_key: AppKey, window: ChatPlace });
-var AppsProjectsMoveParams = import_zod26.z.strictObject({
+  problem: import_zod27.z.string().max(400).optional()
+});
+var AppsWindowActionResult = import_zod27.z.strictObject({ message: import_zod27.z.string().max(400) });
+var AppsWindowsOpenParams = import_zod27.z.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsWindowsReloadParams = import_zod27.z.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsWindowsRestartParams = import_zod27.z.strictObject({ app_key: AppKey, window: ChatPlace, force: import_zod27.z.boolean().default(false) });
+var AppsWindowsRefreshUsageParams = import_zod27.z.strictObject({ app_key: AppKey, window: ChatPlace });
+var AppsProjectsMoveParams = import_zod27.z.strictObject({
   app_key: AppKey,
   chat_id: ChatId,
   from_project_id: ChatProjectId,
   to_project_id: ChatProjectId.optional(),
-  new_project_name: import_zod26.z.string().min(1).max(200).optional()
+  new_project_name: import_zod27.z.string().min(1).max(200).optional()
+});
+var AppsProjectsMoveResult = import_zod27.z.strictObject({ chat: ChatRow, project: ChatProject });
+var AppsProjectsCreateParams = import_zod27.z.strictObject({ app_key: AppKey, name: import_zod27.z.string().min(1).max(200) });
+var AppsProjectsCreateResult = import_zod27.z.strictObject({ project: ChatProject });
+var AppsProjectsImportPinsParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsProjectsImportPinsResult = import_zod27.z.strictObject({ message: import_zod27.z.string().max(400) });
+var ProjectMoveChat = import_zod27.z.strictObject({ chat_id: ChatId, title: import_zod27.z.string().max(300) });
+var ProjectMoveSkip = import_zod27.z.strictObject({ chat_id: ChatId, title: import_zod27.z.string().max(300), window: ChatPlace.nullable(), reason: import_zod27.z.string().max(400) });
+var ProjectMoveGroup = import_zod27.z.strictObject({
+  ok: import_zod27.z.boolean(),
+  name: import_zod27.z.string().max(200),
+  /** Why it is not (or was not) grouped — e.g. the window is open. */
+  reason: import_zod27.z.string().max(400).optional(),
+  /** Chats that get (or got) the group; already in it; taken from another group of the window. */
+  assign: nonNegInt.optional(),
+  already: nonNegInt.optional(),
+  from_other_groups: nonNegInt.optional(),
+  /** A group of that name was already there (reused, never doubled). */
+  group_exists: import_zod27.z.boolean().optional()
+});
+var AppsProjectsToWindowParams = import_zod27.z.strictObject({
+  app_key: AppKey,
+  project_id: ChatProjectId,
+  window: ChatPlace,
+  /** Also take each chat off its other side windows where safe (never main, the holder, an open window). */
+  take_off: import_zod27.z.boolean().default(false),
+  /** Also group them under the project's name in that window's sidebar (closed windows only). */
+  group: import_zod27.z.boolean().default(false),
+  dry_run: import_zod27.z.boolean().default(false)
 });
-var AppsProjectsMoveResult = import_zod26.z.strictObject({ chat: ChatRow, project: ChatProject });
-var AppsProjectsCreateParams = import_zod26.z.strictObject({ app_key: AppKey, name: import_zod26.z.string().min(1).max(200) });
-var AppsProjectsCreateResult = import_zod26.z.strictObject({ project: ChatProject });
-var AppsProjectsImportPinsParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsProjectsImportPinsResult = import_zod26.z.strictObject({ message: import_zod26.z.string().max(400) });
-var ColdChat = import_zod26.z.strictObject({
+var AppsProjectsToWindowResult = import_zod27.z.strictObject({
+  project_id: ChatProjectId,
+  window: ChatPlace,
+  dry_run: import_zod27.z.boolean(),
+  place: import_zod27.z.array(ProjectMoveChat).max(5e3),
+  already: import_zod27.z.array(ProjectMoveChat).max(5e3),
+  take_off: import_zod27.z.array(ProjectMoveChat.extend({ window: ChatPlace })).max(2e4),
+  skipped: import_zod27.z.array(ProjectMoveSkip).max(2e4),
+  /** Chats of the project from other apps (no windows to place into), left as they are. */
+  other_apps: nonNegInt,
+  group: ProjectMoveGroup.nullable(),
+  message: import_zod27.z.string().max(400)
+});
+var ColdChat = import_zod27.z.strictObject({
   id: ChatId,
-  title: import_zod26.z.string().max(1e3),
-  repo: import_zod26.z.string().max(200).nullable(),
-  window: import_zod26.z.string().max(64).nullable(),
-  account: import_zod26.z.string().max(320).nullable(),
-  model_name: import_zod26.z.string().max(120).nullable(),
+  title: import_zod27.z.string().max(1e3),
+  repo: import_zod27.z.string().max(200).nullable(),
+  window: import_zod27.z.string().max(64).nullable(),
+  account: import_zod27.z.string().max(320).nullable(),
+  model_name: import_zod27.z.string().max(120).nullable(),
   context_tokens: nonNegInt,
   cold_at_ms: epochMs,
   /** Waking it once the cache is cold. */
-  cold_cost: import_zod26.z.number().nullable(),
+  cold_cost: import_zod27.z.number().nullable(),
   /** Waking it while the cache is warm. */
-  warm_cost: import_zod26.z.number().nullable(),
+  warm_cost: import_zod27.z.number().nullable(),
   /** Its account is on extra usage (a 5-minute cache, and real money). */
-  extra_usage: import_zod26.z.boolean(),
+  extra_usage: import_zod27.z.boolean(),
   /** A scheduled routine's run. */
-  scheduled: import_zod26.z.boolean(),
+  scheduled: import_zod27.z.boolean(),
   /** It can be shown in its window (started in the desktop app). */
-  openable: import_zod26.z.boolean(),
+  openable: import_zod27.z.boolean(),
   /** How its window was decided, or why it can't be opened. */
-  how: import_zod26.z.string().max(200).nullable()
+  how: import_zod27.z.string().max(200).nullable()
 });
-var AppsChatsColdParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsChatsColdResult = import_zod26.z.strictObject({
+var AppsChatsColdParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsChatsColdResult = import_zod27.z.strictObject({
   app_key: AppKey,
   /** Waiting for the person with a warm cache, most urgent first. */
-  waiting: import_zod26.z.array(ColdChat).max(2e3),
+  waiting: import_zod27.z.array(ColdChat).max(2e3),
   /** Went cold in the last while. */
-  recently_cold: import_zod26.z.array(ColdChat).max(2e3),
+  recently_cold: import_zod27.z.array(ColdChat).max(2e3),
   /** Chats working right now (not waiting). */
   working: nonNegInt
 });
-var AppsChatsOpenParams = import_zod26.z.strictObject({ app_key: AppKey, chat_id: ChatId, window: ChatPlace.optional() });
-var SpendSplit = import_zod26.z.strictObject({ main: import_zod26.z.number(), helpers: import_zod26.z.number() });
-var SpendScopes = import_zod26.z.strictObject({ today: SpendSplit, week: SpendSplit });
-var SpendAccount = import_zod26.z.strictObject({
-  account: import_zod26.z.string().max(320),
+var AppsChatsOpenParams = import_zod27.z.strictObject({ app_key: AppKey, chat_id: ChatId, window: ChatPlace.optional() });
+var SpendSplit = import_zod27.z.strictObject({ main: import_zod27.z.number(), helpers: import_zod27.z.number() });
+var SpendScopes = import_zod27.z.strictObject({ today: SpendSplit, week: SpendSplit });
+var SpendAccount = import_zod27.z.strictObject({
+  account: import_zod27.z.string().max(320),
   spend: SpendScopes,
-  last_hour: import_zod26.z.number().nullable(),
-  last_5h: import_zod26.z.number().nullable(),
-  five_hour: import_zod26.z.number().nullable(),
-  weekly: import_zod26.z.number().nullable(),
+  last_hour: import_zod27.z.number().nullable(),
+  last_5h: import_zod27.z.number().nullable(),
+  five_hour: import_zod27.z.number().nullable(),
+  weekly: import_zod27.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_zod26.z.boolean()
+  stale: import_zod27.z.boolean()
 });
-var SpendModel = import_zod26.z.strictObject({ model: import_zod26.z.string().max(120), name: import_zod26.z.string().max(120), spend: SpendScopes });
-var SpendChat = import_zod26.z.strictObject({
+var SpendModel = import_zod27.z.strictObject({ model: import_zod27.z.string().max(120), name: import_zod27.z.string().max(120), spend: SpendScopes });
+var SpendChat = import_zod27.z.strictObject({
   id: ChatId,
-  title: import_zod26.z.string().max(1e3),
-  repo: import_zod26.z.string().max(200).nullable(),
-  window: import_zod26.z.string().max(64).nullable(),
+  title: import_zod27.z.string().max(1e3),
+  repo: import_zod27.z.string().max(200).nullable(),
+  window: import_zod27.z.string().max(64).nullable(),
   spend: SpendScopes,
   helpers: nonNegInt
 });
-var SpendHelper = import_zod26.z.strictObject({ model: import_zod26.z.string().max(120), steps: nonNegInt, over_steps: import_zod26.z.boolean(), description: import_zod26.z.string().max(400) });
-var SpendLive = import_zod26.z.strictObject({ id: ChatId, title: import_zod26.z.string().max(1e3), window: import_zod26.z.string().max(64).nullable(), helpers: import_zod26.z.array(SpendHelper).max(200) });
-var SpendIdleScope = import_zod26.z.strictObject({ count: nonNegInt, tokens: nonNegInt, cost: import_zod26.z.number(), avoidable: import_zod26.z.number() });
-var SpendIdle = import_zod26.z.strictObject({ id: ChatId, chat: import_zod26.z.string().max(1e3), who: import_zod26.z.string().max(400), today: SpendIdleScope, week: SpendIdleScope, last_ms: epochMs });
-var SpendStart = import_zod26.z.strictObject({ repo: import_zod26.z.string().max(200), count: nonNegInt, median: nonNegInt, latest: import_zod26.z.array(nonNegInt).max(20), alarm: import_zod26.z.string().max(400).nullable() });
-var AppsSpendParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsSpendResult = import_zod26.z.strictObject({
+var SpendHelper = import_zod27.z.strictObject({ model: import_zod27.z.string().max(120), steps: nonNegInt, over_steps: import_zod27.z.boolean(), description: import_zod27.z.string().max(400) });
+var SpendLive = import_zod27.z.strictObject({ id: ChatId, title: import_zod27.z.string().max(1e3), window: import_zod27.z.string().max(64).nullable(), helpers: import_zod27.z.array(SpendHelper).max(200) });
+var SpendIdleScope = import_zod27.z.strictObject({ count: nonNegInt, tokens: nonNegInt, cost: import_zod27.z.number(), avoidable: import_zod27.z.number() });
+var SpendIdle = import_zod27.z.strictObject({ id: ChatId, chat: import_zod27.z.string().max(1e3), who: import_zod27.z.string().max(400), today: SpendIdleScope, week: SpendIdleScope, last_ms: epochMs });
+var SpendStart = import_zod27.z.strictObject({ repo: import_zod27.z.string().max(200), count: nonNegInt, median: nonNegInt, latest: import_zod27.z.array(nonNegInt).max(20), alarm: import_zod27.z.string().max(400).nullable() });
+var AppsSpendParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsSpendResult = import_zod27.z.strictObject({
   app_key: AppKey,
   /** False while older chats are still being read. */
-  complete: import_zod26.z.boolean(),
-  today_total: import_zod26.z.number(),
-  week_total: import_zod26.z.number(),
-  idle_today: import_zod26.z.number(),
-  idle_week: import_zod26.z.number(),
+  complete: import_zod27.z.boolean(),
+  today_total: import_zod27.z.number(),
+  week_total: import_zod27.z.number(),
+  idle_today: import_zod27.z.number(),
+  idle_week: import_zod27.z.number(),
   /** Models with no known list price. */
-  unpriced: import_zod26.z.array(import_zod26.z.string().max(120)).max(100),
+  unpriced: import_zod27.z.array(import_zod27.z.string().max(120)).max(100),
   /** Helpers past their step budget, unusual starting sizes. */
-  alarms: import_zod26.z.array(import_zod26.z.string().max(400)).max(200),
-  live: import_zod26.z.array(SpendLive).max(200),
-  accounts: import_zod26.z.array(SpendAccount).max(200),
-  models: import_zod26.z.array(SpendModel).max(100),
-  chats: import_zod26.z.array(SpendChat).max(500),
-  idle: import_zod26.z.array(SpendIdle).max(500),
-  starts: import_zod26.z.array(SpendStart).max(200)
-});
-var AppsSyncStatusParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsSyncStatusResult = import_zod26.z.strictObject({
-  healthy: import_zod26.z.boolean(),
-  summary: import_zod26.z.string().max(400),
-  problems: import_zod26.z.array(import_zod26.z.string().max(400)).max(200),
-  warnings: import_zod26.z.array(import_zod26.z.string().max(400)).max(200),
+  alarms: import_zod27.z.array(import_zod27.z.string().max(400)).max(200),
+  live: import_zod27.z.array(SpendLive).max(200),
+  accounts: import_zod27.z.array(SpendAccount).max(200),
+  models: import_zod27.z.array(SpendModel).max(100),
+  chats: import_zod27.z.array(SpendChat).max(500),
+  idle: import_zod27.z.array(SpendIdle).max(500),
+  starts: import_zod27.z.array(SpendStart).max(200)
+});
+var AppsSyncStatusParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsSyncStatusResult = import_zod27.z.strictObject({
+  healthy: import_zod27.z.boolean(),
+  summary: import_zod27.z.string().max(400),
+  problems: import_zod27.z.array(import_zod27.z.string().max(400)).max(200),
+  warnings: import_zod27.z.array(import_zod27.z.string().max(400)).max(200),
   /** Accounts seen with no saved name yet (Save account names fixes them). */
-  unnamed_accounts: import_zod26.z.array(import_zod26.z.string().max(80)).max(200),
+  unnamed_accounts: import_zod27.z.array(import_zod27.z.string().max(80)).max(200),
   /** The full report. */
-  output: import_zod26.z.string().max(2e5)
+  output: import_zod27.z.string().max(2e5)
 });
-var AppsSyncRunParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsWindowsProcessesParams = import_zod26.z.strictObject({ app_key: AppKey });
-var AppsWindowsProcessesResult = import_zod26.z.strictObject({ processes: import_zod26.z.array(import_zod26.z.string().max(2e3)).max(2e3) });
-var AppsWindowsAddParams = import_zod26.z.strictObject({ app_key: AppKey, window: ChatPlace, email: import_zod26.z.string().min(3).max(320) });
-var AppsWindowsSaveNamesParams = import_zod26.z.strictObject({ app_key: AppKey });
+var AppsSyncRunParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsWindowsProcessesParams = import_zod27.z.strictObject({ app_key: AppKey });
+var AppsWindowsProcessesResult = import_zod27.z.strictObject({ processes: import_zod27.z.array(import_zod27.z.string().max(2e3)).max(2e3) });
+var AppsWindowsAddParams = import_zod27.z.strictObject({ app_key: AppKey, window: ChatPlace, email: import_zod27.z.string().min(3).max(320) });
+var AppsWindowsSaveNamesParams = import_zod27.z.strictObject({ app_key: AppKey });
 
 // src/schema/registry.ts
 var FS_ERR = ["NOT_FOUND", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "RESOURCE_BUSY", "INTERNAL"];
@@ -2057,6 +2178,7 @@ var OPS = {
   "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"] },
+  "apps.projects.to_window": { params: AppsProjectsToWindowParams, result: AppsProjectsToWindowResult, kind: "unary", since: "1.19", errors: ["NOT_FOUND", "INVALID_PARAMS", "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"] },
@@ -2107,6 +2229,9 @@ var OPS = {
   "stack.server.action": { params: StackServerActionParams, result: StackServerActionResult, kind: "unary", since: "1.16", errors: ["NOT_FOUND", "CONFLICT", "INTERNAL"] },
   "stack.logs": { params: StackLogsParams, result: StackLogsResult, kind: "unary", since: "1.16", errors: ["NOT_FOUND", "INTERNAL"] },
   "stack.errors": { params: StackErrorsParams, result: StackErrorsResult, kind: "unary", since: "1.16", errors: ["INTERNAL"] },
+  // The device's error ledger (SPEC §3.12): every process's errors, grouped, delivered to ops.system_error.
+  "diag.errors.list": { params: DiagErrorsListParams, result: DiagErrorsListResult, kind: "unary", since: "1.20", errors: ["INTERNAL"] },
+  "diag.errors.report": { params: DiagErrorsReportParams, result: DiagErrorsReportResult, kind: "unary", since: "1.20", errors: ["INTERNAL"] },
   // Claude Code history (SPEC §6 coding): served by the `coding` Python service through SERVICES below.
   "coding.history.import_missing": { params: CodingHistoryImportMissingParams, result: CodingHistoryImportMissingResult, kind: "unary", since: "1.5", errors: ["RESOURCE_BUSY", "RESOURCE_GONE", "CANCELLED", "INTERNAL"] }
 };
@@ -2121,7 +2246,8 @@ var EVENTS = {
   "models.progress": ModelsProgressEvent,
   "coding.history.progress": CodingHistoryProgressEvent,
   "relay.device_status": RelayDeviceStatusEvent,
-  "relay.auth_expiring": RelayAuthExpiringEvent
+  "relay.auth_expiring": RelayAuthExpiringEvent,
+  "diag.errors.changed": DiagErrorsChangedEvent
 };
 
 // src/client/client.ts