@ai-matrx/desktop-protocol 0.19.0 → 0.20.0

package/dist/index.js

@@ -2,7 +2,7 @@
 import { z } from "zod";
 import { UUID_SHAPE_PATTERN } from "@ai-matrx/kit/uuid";
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 19;
+var PROTOCOL_MINOR = 20;
 var PROTOCOL_VERSION = `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
 var ProtocolVersion = z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
 var RequestId = z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
@@ -1674,95 +1674,175 @@ var PowerPreventSleepResult = z22.strictObject({
   awake_until_ms: epochMs.nullable()
 });
 
-// src/schema/resources.ts
+// src/schema/diag.ts
 import { z as z23 } from "zod";
-var ResourcesDisk = z23.strictObject({
+var DiagProcess = z23.enum([
+  "main",
+  "renderer",
+  "hosted_page",
+  "core",
+  "pty_host",
+  "python_ml",
+  "python_coding",
+  "python_tools",
+  "relay",
+  "coding_sessions",
+  "claude_accounts"
+]);
+var DiagErrorKind = z23.enum([
+  "uncaught_exception",
+  "unhandled_rejection",
+  "renderer_crash",
+  "native_crash",
+  "console_error",
+  "load_failed",
+  "op_failed",
+  "child_exit",
+  "banner",
+  "logged_error"
+]);
+var DiagErrorStatus = z23.enum(["waiting", "sent", "resolved"]);
+var DiagErrorEntry = z23.strictObject({
+  /** sha256 prefix over process, kind, source, code and the normalized message. */
+  signature: z23.string().regex(/^[0-9a-f]{32}$/),
+  process: DiagProcess,
+  kind: DiagErrorKind,
+  /** Where: a cap.op, a log event, a screen or page name. */
+  source: z23.string().min(1).max(128),
+  /** An ErrorCode, an exit code or signal, an error class; null when there is none. */
+  code: z23.string().max(64).nullable(),
+  /** The first occurrence's message, personal data removed. */
+  message: z23.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: z23.string().max(500).nullable(),
+  app_version: z23.string().max(64)
+});
+var DiagErrorsListParams = z23.strictObject({
+  /** open = waiting or sent; all includes resolved. */
+  status: z23.enum(["open", "all"]).default("open"),
+  limit: z23.int().min(1).max(500).default(200)
+});
+var DiagErrorsListResult = z23.strictObject({
+  /** Newest last_seen first. */
+  entries: z23.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: z23.enum(["signed_out", "ok", "failing"]),
+  last_delivery_ms: epochMs.nullable()
+});
+var DiagErrorsReportParams = z23.strictObject({
+  process: z23.enum(["renderer", "hosted_page"]),
+  kind: z23.enum(["uncaught_exception", "unhandled_rejection", "console_error", "banner"]),
+  /** The screen or page, e.g. "code.chats". */
+  source: z23.string().min(1).max(128),
+  message: z23.string().min(1).max(2e3),
+  code: z23.string().max(64).optional(),
+  stack: z23.string().max(8e3).optional()
+});
+var DiagErrorsReportResult = z23.strictObject({
+  signature: z23.string().regex(/^[0-9a-f]{32}$/)
+});
+var DiagErrorsChangedEvent = z23.strictObject({
+  total_signatures: nonNegInt,
+  waiting: nonNegInt
+});
+
+// src/schema/resources.ts
+import { z as z24 } from "zod";
+var ResourcesDisk = z24.strictObject({
   /** Where it is mounted ("/", "C:"). */
-  mount: z23.string().max(512),
+  mount: z24.string().max(512),
   /** The volume's name as the file manager shows it ("Macintosh HD", "Local Disk (C:)"). Since 1.17. */
-  name: z23.string().max(256).optional(),
+  name: z24.string().max(256).optional(),
   /** The file system ("apfs", "NTFS", "ext4"). */
-  fs: z23.string().max(64),
+  fs: z24.string().max(64),
   size_bytes: nonNegInt,
   used_bytes: nonNegInt,
   available_bytes: nonNegInt
 });
-var ResourcesSnapshotParams = z23.strictObject({});
-var ResourcesSnapshotResult = z23.strictObject({
-  cpu: z23.strictObject({
+var ResourcesSnapshotParams = z24.strictObject({});
+var ResourcesSnapshotResult = z24.strictObject({
+  cpu: z24.strictObject({
     /** Busy share of all cores, 0–100, measured now. */
-    percent: z23.number().min(0).max(100),
-    cores: z23.int().min(1),
+    percent: z24.number().min(0).max(100),
+    cores: z24.int().min(1),
     /** 1, 5 and 15 minute load averages; null on Windows. */
-    load: z23.array(z23.number().min(0)).length(3).nullable()
+    load: z24.array(z24.number().min(0)).length(3).nullable()
   }),
-  memory: z23.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
-  swap: z23.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
-  disks: z23.array(ResourcesDisk).max(64),
+  memory: z24.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: z24.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: z24.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
-var ResourcesJobKind = z23.enum(["type-check", "tests", "build", "lint", "dev server", "language server", "search"]);
-var ResourcesStrain = z23.enum(["good", "strain", "overloaded"]);
-var ResourcesPressure = z23.enum(["normal", "warning", "critical"]);
-var ResourcesJob = z23.strictObject({
+var ResourcesJobKind = z24.enum(["type-check", "tests", "build", "lint", "dev server", "language server", "search"]);
+var ResourcesStrain = z24.enum(["good", "strain", "overloaded"]);
+var ResourcesPressure = z24.enum(["normal", "warning", "critical"]);
+var ResourcesJob = z24.strictObject({
   /** The job's root process (Stop takes its whole tree). */
-  pid: z23.int().min(0),
+  pid: z24.int().min(0),
   kind: ResourcesJobKind,
   /** Its heaviest process's command line, shortened ("…/lib/tsc --noEmit -p tsconfig.json"). */
-  command: z23.string().max(256),
+  command: z24.string().max(256),
   /** Who started it: "Claude Code", "Codex", "Cursor", "VS Code", "Terminal", "local stack", "detached"; null when unknown. */
-  started_by: z23.string().max(64).nullable(),
+  started_by: z24.string().max(64).nullable(),
   /** Whatever started it is gone and nothing waits for it. */
-  orphan: z23.boolean(),
+  orphan: z24.boolean(),
   /** A type-check queued for its turn (no compiler running yet). */
-  waiting: z23.boolean(),
+  waiting: z24.boolean(),
   /** The project folder it runs in ("matrx-frontend"); null when not in one. */
-  folder: z23.string().max(256).nullable(),
+  folder: z24.string().max(256).nullable(),
   /** The same command in the same folder, running this many times (1 = no duplicate). */
-  duplicates: z23.int().min(1),
-  processes: z23.int().min(1),
+  duplicates: z24.int().min(1),
+  processes: z24.int().min(1),
   /** Sum over the tree, as `ps` reports it: 100 = one full core. */
-  cpu_percent: z23.number().min(0),
+  cpu_percent: z24.number().min(0),
   /** Real memory (macOS: the physical footprint Activity Monitor shows, compressed included). */
   memory_bytes: nonNegInt,
   started_at_ms: epochMs.nullable(),
   /** False for an app, an agent session, a terminal, a system process, the local stack or Matrx 2 itself. */
-  stoppable: z23.boolean()
+  stoppable: z24.boolean()
 });
-var ResourcesProcess = z23.strictObject({
-  pid: z23.int().min(0),
+var ResourcesProcess = z24.strictObject({
+  pid: z24.int().min(0),
   /** The command line, shortened. */
-  name: z23.string().max(256),
-  cpu_percent: z23.number().min(0),
+  name: z24.string().max(256),
+  cpu_percent: z24.number().min(0),
   memory_bytes: nonNegInt,
-  started_by: z23.string().max(64).nullable(),
+  started_by: z24.string().max(64).nullable(),
   /** The job it belongs to ("type-check in aidream"); null when none. */
-  job: z23.string().max(256).nullable(),
+  job: z24.string().max(256).nullable(),
   started_at_ms: epochMs.nullable()
 });
-var ResourcesVerdict = z23.strictObject({
+var ResourcesVerdict = z24.strictObject({
   level: ResourcesStrain,
   /** One sentence ("Your Mac is under strain. 3 type-checks are running at once."). */
-  text: z23.string().max(256),
+  text: z24.string().max(256),
   /** The biggest jobs behind it; null when all is well. */
-  cause: z23.string().max(1024).nullable()
+  cause: z24.string().max(1024).nullable()
 });
-var ResourcesSample = z23.strictObject({
+var ResourcesSample = z24.strictObject({
   at_ms: epochMs,
   /** The 1-minute load average. */
-  load: z23.number().min(0),
+  load: z24.number().min(0),
   memory_used_bytes: nonNegInt,
   typechecks: nonNegInt
 });
-var ResourcesActivityParams = z23.strictObject({});
-var ResourcesActivityResult = z23.strictObject({
+var ResourcesActivityParams = z24.strictObject({});
+var ResourcesActivityResult = z24.strictObject({
   /** False until the first reading (a second or two after start). */
-  ready: z23.boolean(),
+  ready: z24.boolean(),
   sampled_at_ms: epochMs.nullable(),
-  cores: z23.int().min(1),
+  cores: z24.int().min(1),
   /** 1, 5 and 15 minute load averages. */
-  load: z23.array(z23.number().min(0)).length(3),
-  memory: z23.strictObject({
+  load: z24.array(z24.number().min(0)).length(3),
+  memory: z24.strictObject({
     total_bytes: nonNegInt,
     /** Activity Monitor's Memory Used: app memory + wired + compressed. */
     used_bytes: nonNegInt,
@@ -1773,252 +1853,252 @@ var ResourcesActivityResult = z23.strictObject({
     pressure: ResourcesPressure.nullable()
   }),
   verdict: ResourcesVerdict,
-  typechecks: z23.strictObject({ running: nonNegInt, waiting: nonNegInt, comfort: nonNegInt }),
+  typechecks: z24.strictObject({ running: nonNegInt, waiting: nonNegInt, comfort: nonNegInt }),
   /** Heaviest first (1 GB weighs as much as 16 % of a core). */
-  jobs: z23.array(ResourcesJob).max(200),
+  jobs: z24.array(ResourcesJob).max(200),
   /** The 15 heaviest by memory and the 15 busiest by CPU, together. */
-  top: z23.array(ResourcesProcess).max(30),
+  top: z24.array(ResourcesProcess).max(30),
   /** The last hour, oldest first. */
-  history: z23.array(ResourcesSample).max(1200)
+  history: z24.array(ResourcesSample).max(1200)
 });
-var ResourcesStopJobParams = z23.strictObject({ pid: z23.int().min(1) });
-var ResourcesStopJobResult = z23.strictObject({
+var ResourcesStopJobParams = z24.strictObject({ pid: z24.int().min(1) });
+var ResourcesStopJobResult = z24.strictObject({
   /** Processes signalled; whatever is still running 5 seconds later is force-stopped. */
   processes: nonNegInt,
   /** It had finished before the request arrived. */
-  already_finished: z23.boolean()
+  already_finished: z24.boolean()
 });
-var ResourcesIncident = z23.strictObject({
+var ResourcesIncident = z24.strictObject({
   at_ms: epochMs,
   verdict: ResourcesVerdict,
-  load: z23.number().min(0),
+  load: z24.number().min(0),
   memory_used_bytes: nonNegInt,
   compressed_bytes: nonNegInt,
   pressure: ResourcesPressure.nullable(),
-  jobs: z23.array(
-    z23.strictObject({
+  jobs: z24.array(
+    z24.strictObject({
       kind: ResourcesJobKind,
-      started_by: z23.string().max(64).nullable(),
-      folder: z23.string().max(256).nullable(),
-      command: z23.string().max(256),
-      cpu_percent: z23.number().min(0),
+      started_by: z24.string().max(64).nullable(),
+      folder: z24.string().max(256).nullable(),
+      command: z24.string().max(256),
+      cpu_percent: z24.number().min(0),
       memory_bytes: nonNegInt,
-      duplicates: z23.int().min(1)
+      duplicates: z24.int().min(1)
     })
   ).max(8)
 });
-var ResourcesIncidentsParams = z23.strictObject({ limit: z23.int().min(1).max(200).default(50) });
-var ResourcesIncidentsResult = z23.strictObject({
+var ResourcesIncidentsParams = z24.strictObject({ limit: z24.int().min(1).max(200).default(50) });
+var ResourcesIncidentsResult = z24.strictObject({
   /** Newest first; at most one a minute is written. */
-  incidents: z23.array(ResourcesIncident).max(200)
+  incidents: z24.array(ResourcesIncident).max(200)
 });
 
 // src/schema/stack.ts
-import { z as z24 } from "zod";
-var StackServerName = z24.string().regex(/^[a-z0-9_-]{1,64}$/);
-var StackTone = z24.enum(["good", "wait", "bad", "off"]);
-var StackServer = z24.strictObject({
+import { z as z25 } from "zod";
+var StackServerName = z25.string().regex(/^[a-z0-9_-]{1,64}$/);
+var StackTone = z25.enum(["good", "wait", "bad", "off"]);
+var StackServer = z25.strictObject({
   name: StackServerName,
   /** One word: Healthy, Starting, Unhealthy, Restarting, Stopping, Waiting, Stopped, Crashed, Off. */
-  label: z24.string().max(32),
+  label: z25.string().max(32),
   tone: StackTone,
   /** What is going on, in one or two plain sentences. */
-  sentence: z24.string().max(2e3),
+  sentence: z25.string().max(2e3),
   /** The config's own description of the server. */
-  description: z24.string().max(512),
+  description: z25.string().max(512),
   /** Where the server answers, when its description names an address. */
-  open_url: z24.string().max(2048).nullable(),
-  log_file: z24.string().max(4096),
+  open_url: z25.string().max(2048).nullable(),
+  log_file: z25.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: z24.int().nullable(),
-  pid: z24.int().nullable(),
+  exit_code: z25.int().nullable(),
+  pid: z25.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: z24.number().min(0).optional(),
+  cpu_percent: z25.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 = z24.strictObject({
+var StackEvent = z25.strictObject({
   at_ms: epochMs,
   /** A server name, or "stack" for the stack as a whole. */
-  server: z24.string().max(64),
+  server: z25.string().max(64),
   /** started · stopped · healthy · unhealthy · crashed · exited · restarting · stopping · action · action-done · action-failed · setup · error */
-  kind: z24.string().max(32),
-  text: z24.string().max(4e3)
+  kind: z25.string().max(32),
+  text: z25.string().max(4e3)
 });
-var StackStateParams = z24.strictObject({});
-var StackStateResult = z24.strictObject({
+var StackStateParams = z25.strictObject({});
+var StackStateResult = z25.strictObject({
   /** The stack's config file, when found. */
-  config_path: z24.string().max(4096).nullable(),
+  config_path: z25.string().max(4096).nullable(),
   /** Why the stack cannot be run from here (no config, no process-compose), else null. */
-  problem: z24.string().max(1e3).nullable(),
-  stack_up: z24.boolean(),
+  problem: z25.string().max(1e3).nullable(),
+  stack_up: z25.boolean(),
   stack_started_at_ms: epochMs.nullable(),
-  servers: z24.array(StackServer).max(64),
+  servers: z25.array(StackServer).max(64),
   /** One line about the one-shot setup steps ("Docker Desktop: running."), or null. */
-  setup_note: z24.string().max(500).nullable(),
+  setup_note: z25.string().max(500).nullable(),
   /** Start everything / Stop everything in flight. */
-  pending: z24.strictObject({ verb: z24.enum(["start", "stop"]), label: z24.string().max(64), since_ms: epochMs }).nullable(),
+  pending: z25.strictObject({ verb: z25.enum(["start", "stop"]), label: z25.string().max(64), since_ms: epochMs }).nullable(),
   /** The newest entries last. */
-  events: z24.array(StackEvent).max(300)
+  events: z25.array(StackEvent).max(300)
 });
-var StackStartParams = z24.strictObject({});
-var StackStopParams = z24.strictObject({});
-var StackRunResult = z24.strictObject({ accepted: z24.boolean() });
-var StackServerActionParams = z24.strictObject({
+var StackStartParams = z25.strictObject({});
+var StackStopParams = z25.strictObject({});
+var StackRunResult = z25.strictObject({ accepted: z25.boolean() });
+var StackServerActionParams = z25.strictObject({
   name: StackServerName,
-  verb: z24.enum(["start", "stop", "restart"])
+  verb: z25.enum(["start", "stop", "restart"])
 });
-var StackServerActionResult = z24.strictObject({ message: z24.string().max(1e3) });
-var StackLogsParams = z24.strictObject({
+var StackServerActionResult = z25.strictObject({ message: z25.string().max(1e3) });
+var StackLogsParams = z25.strictObject({
   name: StackServerName,
   /** Without `offset`: the last this-many complete lines. With it: new lines after it, at most this many. */
-  lines: z24.int().min(1).max(2e5).default(2e3),
+  lines: z25.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: z24.int().min(0).max(25e3).default(0)
+  wait_ms: z25.int().min(0).max(25e3).default(0)
 });
-var StackLogsResult = z24.strictObject({
+var StackLogsResult = z25.strictObject({
   /** Complete lines, colour codes removed. */
-  lines: z24.array(z24.string().max(65536)).max(2e5),
+  lines: z25.array(z25.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: z24.boolean(),
+  since_valid: z25.boolean(),
   /** The log was rotated or truncated since `offset`: these lines start the file again. */
-  reset: z24.boolean(),
-  log_file: z24.string().max(4096)
+  reset: z25.boolean(),
+  log_file: z25.string().max(4096)
 });
-var StackErrorsParams = z24.strictObject({
-  window_minutes: z24.int().min(1).max(1440).default(60)
+var StackErrorsParams = z25.strictObject({
+  window_minutes: z25.int().min(1).max(1440).default(60)
 });
-var StackErrorsResult = z24.strictObject({
+var StackErrorsResult = z25.strictObject({
   /** Per server: a heading line ("=== aidream — errors in the last 60 minutes (<file>) ===") and each error with the 10 lines after it. */
-  sections: z24.array(z24.strictObject({ name: StackServerName, heading: z24.string().max(4096), lines: z24.array(z24.string().max(65536)).max(5e3) })).max(64),
-  window_minutes: z24.int().min(1).max(1440)
+  sections: z25.array(z25.strictObject({ name: StackServerName, heading: z25.string().max(4096), lines: z25.array(z25.string().max(65536)).max(5e3) })).max(64),
+  window_minutes: z25.int().min(1).max(1440)
 });
 
 // src/schema/audio.ts
-import { z as z25 } from "zod";
-var AudioDevice = z25.strictObject({
+import { z as z26 } from "zod";
+var AudioDevice = z26.strictObject({
   /** The OS's name for it, as audio.record takes it. */
-  id: z25.string().min(1).max(256),
-  name: z25.string().max(256),
-  default: z25.boolean()
+  id: z26.string().min(1).max(256),
+  name: z26.string().max(256),
+  default: z26.boolean()
 });
-var AudioDevicesParams = z25.strictObject({});
-var AudioDevicesResult = z25.strictObject({
-  inputs: z25.array(AudioDevice).max(64),
-  outputs: z25.array(AudioDevice).max(64)
+var AudioDevicesParams = z26.strictObject({});
+var AudioDevicesResult = z26.strictObject({
+  inputs: z26.array(AudioDevice).max(64),
+  outputs: z26.array(AudioDevice).max(64)
 });
-var AudioRecordParams = z25.strictObject({
-  seconds: z25.number().min(0.5).max(600),
+var AudioRecordParams = z26.strictObject({
+  seconds: z26.number().min(0.5).max(600),
   /** The microphone (from audio.devices); the default input when absent. */
-  device_id: z25.string().min(1).max(256).optional(),
+  device_id: z26.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 = z25.strictObject({
+var AudioRecordResult = z26.strictObject({
   path: AbsPath,
-  seconds: z25.number().min(0),
+  seconds: z26.number().min(0),
   bytes: nonNegInt,
   /** Loudest sample, 0–1: 0 means the device gave silence. */
-  peak: z25.number().min(0).max(1)
+  peak: z26.number().min(0).max(1)
 });
-var AudioPlayParams = z25.strictObject({ path: AbsPath });
-var AudioPlayResult = z25.strictObject({ path: AbsPath, seconds: z25.number().min(0) });
+var AudioPlayParams = z26.strictObject({ path: AbsPath });
+var AudioPlayResult = z26.strictObject({ path: AbsPath, seconds: z26.number().min(0) });
 
 // src/schema/fs-watch.ts
-import { z as z26 } from "zod";
-var FsWatchId = z26.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = z26.strictObject({
+import { z as z27 } from "zod";
+var FsWatchId = z27.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = z27.strictObject({
   path: AbsPath,
-  recursive: z26.boolean().default(true),
+  recursive: z27.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: z26.array(z26.string().max(256)).max(64).default([])
+  ignore: z27.array(z27.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = z26.strictObject({
+var FsWatchStartResult = z27.strictObject({
   watch_id: FsWatchId,
   path: AbsPath,
   /** The watch ends by itself if nobody reads it for 30 minutes. */
   expires_at_ms: epochMs
 });
-var FsWatchEventsParams = z26.strictObject({
+var FsWatchEventsParams = z27.strictObject({
   watch_id: FsWatchId,
   /** Wait up to this long for a first change when none is waiting (0 answers at once). */
-  wait_ms: z26.int().min(0).max(25e3).default(0)
+  wait_ms: z27.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = z26.strictObject({
+var FsWatchEventsResult = z27.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: z26.array(FsChange).max(1e3),
+  changes: z27.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: z26.boolean(),
+  overflow: z27.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = z26.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = z26.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = z27.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = z27.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-import { z as z27 } from "zod";
-var ExecJobId = z27.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = z27.strictObject({
-  command: z27.string().min(1).max(131072),
+import { z as z28 } from "zod";
+var ExecJobId = z28.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = z28.strictObject({
+  command: z28.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: z27.record(z27.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z27.string().max(32768)).optional()
+  env: z28.record(z28.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z28.string().max(32768)).optional()
 });
-var ExecJobStartResult = z27.strictObject({ job_id: ExecJobId, pid: z27.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = z27.strictObject({
+var ExecJobStartResult = z28.strictObject({ job_id: ExecJobId, pid: z28.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = z28.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: z27.int().min(0).max(25e3).default(0),
-  max_bytes: z27.int().min(1024).max(1048576).default(65536)
+  wait_ms: z28.int().min(0).max(25e3).default(0),
+  max_bytes: z28.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = z27.strictObject({
+var ExecJobOutputResult = z28.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: z27.string(),
+  output: z28.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: z27.boolean(),
-  exit_code: z27.int().nullable()
+  running: z28.boolean(),
+  exit_code: z28.int().nullable()
 });
-var ExecJobStopParams = z27.strictObject({
+var ExecJobStopParams = z28.strictObject({
   job_id: ExecJobId,
   /** End it at once (SIGKILL; on Windows the whole tree with /F) instead of asking it to quit. */
-  force: z27.boolean().default(false)
+  force: z28.boolean().default(false)
 });
-var ExecJobStopResult = z27.strictObject({ job_id: ExecJobId, exited: z27.boolean(), exit_code: z27.int().nullable() });
-var ExecJobInfo = z27.strictObject({
+var ExecJobStopResult = z28.strictObject({ job_id: ExecJobId, exited: z28.boolean(), exit_code: z28.int().nullable() });
+var ExecJobInfo = z28.strictObject({
   job_id: ExecJobId,
-  command: z27.string().max(1024),
-  pid: z27.int().min(1),
+  command: z28.string().max(1024),
+  pid: z28.int().min(1),
   cwd: AbsPath,
-  running: z27.boolean(),
-  exit_code: z27.int().nullable(),
+  running: z28.boolean(),
+  exit_code: z28.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = z27.strictObject({});
-var ExecJobListResult = z27.strictObject({ jobs: z27.array(ExecJobInfo).max(64) });
+var ExecJobListParams = z28.strictObject({});
+var ExecJobListResult = z28.strictObject({ jobs: z28.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 import { UUID_SHAPE_PATTERN as UUID_SHAPE_PATTERN3 } from "@ai-matrx/kit/uuid";
-var CodingServiceCredentials = z28.strictObject({
-  access_token: z28.string().min(16).max(16384),
-  user_id: z28.string().regex(UUID_SHAPE_PATTERN3),
+var CodingServiceCredentials = z29.strictObject({
+  access_token: z29.string().min(16).max(16384),
+  user_id: z29.string().regex(UUID_SHAPE_PATTERN3),
   /** The AI Matrx server this app talks to (production, or a local server on the nightly copy). */
-  server_url: z28.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: z29.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = z28.enum([
+var CodingHistoryBlocked = z29.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -2026,11 +2106,11 @@ var CodingHistoryBlocked = z28.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = z28.strictObject({
-  session_id: z28.string().max(64),
-  reason: z28.string().max(300)
+var CodingHistoryFailure = z29.strictObject({
+  session_id: z29.string().max(64),
+  reason: z29.string().max(300)
 });
-var CodingHistoryRun = z28.strictObject({
+var CodingHistoryRun = z29.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -2045,39 +2125,39 @@ var CodingHistoryRun = z28.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: z28.array(CodingHistoryFailure).max(20),
+  failures: z29.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: z28.string().max(400)
+  summary: z29.string().max(400)
 });
-var CodingHistoryStep = z28.strictObject({
+var CodingHistoryStep = z29.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: z28.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: z28.boolean(),
+  plan_id: z29.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: z29.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = z28.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = z28.strictObject({
-  plan_id: z28.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = z29.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = z29.strictObject({
+  plan_id: z29.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = z28.strictObject({
-  phase: z28.enum(["checking", "importing"]),
+var CodingServiceProgress = z29.strictObject({
+  phase: z29.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = z28.strictObject({});
-var CodingHistoryImportMissingResult = z28.strictObject({
-  state: z28.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = z29.strictObject({});
+var CodingHistoryImportMissingResult = z29.strictObject({
+  state: z29.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = z28.strictObject({
+var CodingHistoryProgressEvent = z29.strictObject({
   request_id: RequestId,
-  phase: z28.enum(["checking", "importing"]),
+  phase: z29.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -2193,6 +2273,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"] }
 };
@@ -2207,7 +2290,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
 };
 var SERVICES = {
   ml: {
@@ -2453,6 +2537,15 @@ var NAMED_SCHEMAS = {
   StackLogsResult,
   StackErrorsParams,
   StackErrorsResult,
+  DiagProcess,
+  DiagErrorKind,
+  DiagErrorStatus,
+  DiagErrorEntry,
+  DiagErrorsListParams,
+  DiagErrorsListResult,
+  DiagErrorsReportParams,
+  DiagErrorsReportResult,
+  DiagErrorsChangedEvent,
   FsWatchId,
   FsWatchStartParams,
   FsWatchStartResult,
@@ -2719,7 +2812,7 @@ function forPeer(op, part, value, version) {
 var VERSIONED_RESULT_OPS = [.../* @__PURE__ */ new Set([...RESULT_PATH.keys(), ...WINDOW_RESULTS.keys(), ...NESTED_RESULTS.keys()])];
 
 // src/contract.ts
-var CONTRACT_SHA256 = "4fc16cc5bdaf7d666d5a0916ad3cd362df192d0238655ea288e7ffe15e54f246";
+var CONTRACT_SHA256 = "ef1f01f6b4e81ce7a56192d56c5765d182a53aaf9224ef20ce764cd25c20e229";
 
 // src/close-policy.ts
 var CLOSE_RULES = {
@@ -3186,6 +3279,15 @@ export {
   DEFAULT_WINDOW_BYTES,
   DesktopProtocolError,
   DeviceId,
+  DiagErrorEntry,
+  DiagErrorKind,
+  DiagErrorStatus,
+  DiagErrorsChangedEvent,
+  DiagErrorsListParams,
+  DiagErrorsListResult,
+  DiagErrorsReportParams,
+  DiagErrorsReportResult,
+  DiagProcess,
   EVENTS,
   EXCLUDED_TOOLS,
   EndMsg,