@ai-matrx/desktop-protocol 0.17.11 → 0.17.13

package/dist/index.cjs

@@ -297,9 +297,23 @@ __export(src_exports, {
   RequestMsg: () => RequestMsg,
   ResourceId: () => ResourceId,
   ResourceInfo: () => ResourceInfo,
+  ResourcesActivityParams: () => ResourcesActivityParams,
+  ResourcesActivityResult: () => ResourcesActivityResult,
   ResourcesDisk: () => ResourcesDisk,
+  ResourcesIncident: () => ResourcesIncident,
+  ResourcesIncidentsParams: () => ResourcesIncidentsParams,
+  ResourcesIncidentsResult: () => ResourcesIncidentsResult,
+  ResourcesJob: () => ResourcesJob,
+  ResourcesJobKind: () => ResourcesJobKind,
+  ResourcesPressure: () => ResourcesPressure,
+  ResourcesProcess: () => ResourcesProcess,
+  ResourcesSample: () => ResourcesSample,
   ResourcesSnapshotParams: () => ResourcesSnapshotParams,
   ResourcesSnapshotResult: () => ResourcesSnapshotResult,
+  ResourcesStopJobParams: () => ResourcesStopJobParams,
+  ResourcesStopJobResult: () => ResourcesStopJobResult,
+  ResourcesStrain: () => ResourcesStrain,
+  ResourcesVerdict: () => ResourcesVerdict,
   ResponseMsg: () => ResponseMsg,
   SERVICES: () => SERVICES,
   SERVICE_MAX_FRAME_BYTES: () => SERVICE_MAX_FRAME_BYTES,
@@ -342,6 +356,21 @@ __export(src_exports, {
   SpendScopes: () => SpendScopes,
   SpendSplit: () => SpendSplit,
   SpendStart: () => SpendStart,
+  StackErrorsParams: () => StackErrorsParams,
+  StackErrorsResult: () => StackErrorsResult,
+  StackEvent: () => StackEvent,
+  StackLogsParams: () => StackLogsParams,
+  StackLogsResult: () => StackLogsResult,
+  StackRunResult: () => StackRunResult,
+  StackServer: () => StackServer,
+  StackServerActionParams: () => StackServerActionParams,
+  StackServerActionResult: () => StackServerActionResult,
+  StackServerName: () => StackServerName,
+  StackStartParams: () => StackStartParams,
+  StackStateParams: () => StackStateParams,
+  StackStateResult: () => StackStateResult,
+  StackStopParams: () => StackStopParams,
+  StackTone: () => StackTone,
   StreamMeta: () => StreamMeta,
   StreamMsg: () => StreamMsg,
   SysinfoGetParams: () => SysinfoGetParams,
@@ -407,7 +436,7 @@ module.exports = __toCommonJS(src_exports);
 // src/schema/primitives.ts
 var import_zod = require("zod");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 15;
+var PROTOCOL_MINOR = 17;
 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_-]+$/);
@@ -2046,6 +2075,8 @@ var import_zod23 = require("zod");
 var ResourcesDisk = import_zod23.z.strictObject({
   /** Where it is mounted ("/", "C:"). */
   mount: import_zod23.z.string().max(512),
+  /** The volume's name as the file manager shows it ("Macintosh HD", "Local Disk (C:)"). Since 1.17. */
+  name: import_zod23.z.string().max(256).optional(),
   /** The file system ("apfs", "NTFS", "ext4"). */
   fs: import_zod23.z.string().max(64),
   size_bytes: nonNegInt,
@@ -2066,122 +2097,319 @@ var ResourcesSnapshotResult = import_zod23.z.strictObject({
   disks: import_zod23.z.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
+var ResourcesJobKind = import_zod23.z.enum(["type-check", "tests", "build", "lint", "dev server", "language server", "search"]);
+var ResourcesStrain = import_zod23.z.enum(["good", "strain", "overloaded"]);
+var ResourcesPressure = import_zod23.z.enum(["normal", "warning", "critical"]);
+var ResourcesJob = import_zod23.z.strictObject({
+  /** The job's root process (Stop takes its whole tree). */
+  pid: import_zod23.z.int().min(0),
+  kind: ResourcesJobKind,
+  /** Its heaviest process's command line, shortened ("…/lib/tsc --noEmit -p tsconfig.json"). */
+  command: import_zod23.z.string().max(256),
+  /** Who started it: "Claude Code", "Codex", "Cursor", "VS Code", "Terminal", "local stack", "detached"; null when unknown. */
+  started_by: import_zod23.z.string().max(64).nullable(),
+  /** Whatever started it is gone and nothing waits for it. */
+  orphan: import_zod23.z.boolean(),
+  /** A type-check queued for its turn (no compiler running yet). */
+  waiting: import_zod23.z.boolean(),
+  /** The project folder it runs in ("matrx-frontend"); null when not in one. */
+  folder: import_zod23.z.string().max(256).nullable(),
+  /** The same command in the same folder, running this many times (1 = no duplicate). */
+  duplicates: import_zod23.z.int().min(1),
+  processes: import_zod23.z.int().min(1),
+  /** Sum over the tree, as `ps` reports it: 100 = one full core. */
+  cpu_percent: import_zod23.z.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: import_zod23.z.boolean()
+});
+var ResourcesProcess = import_zod23.z.strictObject({
+  pid: import_zod23.z.int().min(0),
+  /** The command line, shortened. */
+  name: import_zod23.z.string().max(256),
+  cpu_percent: import_zod23.z.number().min(0),
+  memory_bytes: nonNegInt,
+  started_by: import_zod23.z.string().max(64).nullable(),
+  /** The job it belongs to ("type-check in aidream"); null when none. */
+  job: import_zod23.z.string().max(256).nullable(),
+  started_at_ms: epochMs.nullable()
+});
+var ResourcesVerdict = import_zod23.z.strictObject({
+  level: ResourcesStrain,
+  /** One sentence ("Your Mac is under strain. 3 type-checks are running at once."). */
+  text: import_zod23.z.string().max(256),
+  /** The biggest jobs behind it; null when all is well. */
+  cause: import_zod23.z.string().max(1024).nullable()
+});
+var ResourcesSample = import_zod23.z.strictObject({
+  at_ms: epochMs,
+  /** The 1-minute load average. */
+  load: import_zod23.z.number().min(0),
+  memory_used_bytes: nonNegInt,
+  typechecks: nonNegInt
+});
+var ResourcesActivityParams = import_zod23.z.strictObject({});
+var ResourcesActivityResult = import_zod23.z.strictObject({
+  /** False until the first reading (a second or two after start). */
+  ready: import_zod23.z.boolean(),
+  sampled_at_ms: epochMs.nullable(),
+  cores: import_zod23.z.int().min(1),
+  /** 1, 5 and 15 minute load averages. */
+  load: import_zod23.z.array(import_zod23.z.number().min(0)).length(3),
+  memory: import_zod23.z.strictObject({
+    total_bytes: nonNegInt,
+    /** Activity Monitor's Memory Used: app memory + wired + compressed. */
+    used_bytes: nonNegInt,
+    /** Data held compressed, and the memory the compressor takes to hold it. */
+    compressed_bytes: nonNegInt,
+    compressor_bytes: nonNegInt,
+    swap_used_bytes: nonNegInt,
+    pressure: ResourcesPressure.nullable()
+  }),
+  verdict: ResourcesVerdict,
+  typechecks: import_zod23.z.strictObject({ running: nonNegInt, waiting: nonNegInt, comfort: nonNegInt }),
+  /** Heaviest first (1 GB weighs as much as 16 % of a core). */
+  jobs: import_zod23.z.array(ResourcesJob).max(200),
+  /** The 15 heaviest by memory and the 15 busiest by CPU, together. */
+  top: import_zod23.z.array(ResourcesProcess).max(30),
+  /** The last hour, oldest first. */
+  history: import_zod23.z.array(ResourcesSample).max(1200)
+});
+var ResourcesStopJobParams = import_zod23.z.strictObject({ pid: import_zod23.z.int().min(1) });
+var ResourcesStopJobResult = import_zod23.z.strictObject({
+  /** Processes signalled; whatever is still running 5 seconds later is force-stopped. */
+  processes: nonNegInt,
+  /** It had finished before the request arrived. */
+  already_finished: import_zod23.z.boolean()
+});
+var ResourcesIncident = import_zod23.z.strictObject({
+  at_ms: epochMs,
+  verdict: ResourcesVerdict,
+  load: import_zod23.z.number().min(0),
+  memory_used_bytes: nonNegInt,
+  compressed_bytes: nonNegInt,
+  pressure: ResourcesPressure.nullable(),
+  jobs: import_zod23.z.array(
+    import_zod23.z.strictObject({
+      kind: ResourcesJobKind,
+      started_by: import_zod23.z.string().max(64).nullable(),
+      folder: import_zod23.z.string().max(256).nullable(),
+      command: import_zod23.z.string().max(256),
+      cpu_percent: import_zod23.z.number().min(0),
+      memory_bytes: nonNegInt,
+      duplicates: import_zod23.z.int().min(1)
+    })
+  ).max(8)
+});
+var ResourcesIncidentsParams = import_zod23.z.strictObject({ limit: import_zod23.z.int().min(1).max(200).default(50) });
+var ResourcesIncidentsResult = import_zod23.z.strictObject({
+  /** Newest first; at most one a minute is written. */
+  incidents: import_zod23.z.array(ResourcesIncident).max(200)
+});
 
-// src/schema/audio.ts
+// src/schema/stack.ts
 var import_zod24 = require("zod");
-var AudioDevice = import_zod24.z.strictObject({
+var StackServerName = import_zod24.z.string().regex(/^[a-z0-9_-]{1,64}$/);
+var StackTone = import_zod24.z.enum(["good", "wait", "bad", "off"]);
+var StackServer = import_zod24.z.strictObject({
+  name: StackServerName,
+  /** One word: Healthy, Starting, Unhealthy, Restarting, Stopping, Waiting, Stopped, Crashed, Off. */
+  label: import_zod24.z.string().max(32),
+  tone: StackTone,
+  /** What is going on, in one or two plain sentences. */
+  sentence: import_zod24.z.string().max(2e3),
+  /** The config's own description of the server. */
+  description: import_zod24.z.string().max(512),
+  /** Where the server answers, when its description names an address. */
+  open_url: import_zod24.z.string().max(2048).nullable(),
+  log_file: import_zod24.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_zod24.z.int().nullable(),
+  pid: import_zod24.z.int().nullable()
+});
+var StackEvent = import_zod24.z.strictObject({
+  at_ms: epochMs,
+  /** A server name, or "stack" for the stack as a whole. */
+  server: import_zod24.z.string().max(64),
+  /** started · stopped · healthy · unhealthy · crashed · exited · restarting · stopping · action · action-done · action-failed · setup · error */
+  kind: import_zod24.z.string().max(32),
+  text: import_zod24.z.string().max(4e3)
+});
+var StackStateParams = import_zod24.z.strictObject({});
+var StackStateResult = import_zod24.z.strictObject({
+  /** The stack's config file, when found. */
+  config_path: import_zod24.z.string().max(4096).nullable(),
+  /** Why the stack cannot be run from here (no config, no process-compose), else null. */
+  problem: import_zod24.z.string().max(1e3).nullable(),
+  stack_up: import_zod24.z.boolean(),
+  stack_started_at_ms: epochMs.nullable(),
+  servers: import_zod24.z.array(StackServer).max(64),
+  /** One line about the one-shot setup steps ("Docker Desktop: running."), or null. */
+  setup_note: import_zod24.z.string().max(500).nullable(),
+  /** Start everything / Stop everything in flight. */
+  pending: import_zod24.z.strictObject({ verb: import_zod24.z.enum(["start", "stop"]), label: import_zod24.z.string().max(64), since_ms: epochMs }).nullable(),
+  /** The newest entries last. */
+  events: import_zod24.z.array(StackEvent).max(300)
+});
+var StackStartParams = import_zod24.z.strictObject({});
+var StackStopParams = import_zod24.z.strictObject({});
+var StackRunResult = import_zod24.z.strictObject({ accepted: import_zod24.z.boolean() });
+var StackServerActionParams = import_zod24.z.strictObject({
+  name: StackServerName,
+  verb: import_zod24.z.enum(["start", "stop", "restart"])
+});
+var StackServerActionResult = import_zod24.z.strictObject({ message: import_zod24.z.string().max(1e3) });
+var StackLogsParams = import_zod24.z.strictObject({
+  name: StackServerName,
+  /** Without `offset`: the last this-many complete lines. With it: new lines after it, at most this many. */
+  lines: import_zod24.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_zod24.z.int().min(0).max(25e3).default(0)
+});
+var StackLogsResult = import_zod24.z.strictObject({
+  /** Complete lines, colour codes removed. */
+  lines: import_zod24.z.array(import_zod24.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_zod24.z.boolean(),
+  /** The log was rotated or truncated since `offset`: these lines start the file again. */
+  reset: import_zod24.z.boolean(),
+  log_file: import_zod24.z.string().max(4096)
+});
+var StackErrorsParams = import_zod24.z.strictObject({
+  window_minutes: import_zod24.z.int().min(1).max(1440).default(60)
+});
+var StackErrorsResult = import_zod24.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_zod24.z.array(import_zod24.z.strictObject({ name: StackServerName, heading: import_zod24.z.string().max(4096), lines: import_zod24.z.array(import_zod24.z.string().max(65536)).max(5e3) })).max(64),
+  window_minutes: import_zod24.z.int().min(1).max(1440)
+});
+
+// src/schema/audio.ts
+var import_zod25 = require("zod");
+var AudioDevice = import_zod25.z.strictObject({
   /** The OS's name for it, as audio.record takes it. */
-  id: import_zod24.z.string().min(1).max(256),
-  name: import_zod24.z.string().max(256),
-  default: import_zod24.z.boolean()
+  id: import_zod25.z.string().min(1).max(256),
+  name: import_zod25.z.string().max(256),
+  default: import_zod25.z.boolean()
 });
-var AudioDevicesParams = import_zod24.z.strictObject({});
-var AudioDevicesResult = import_zod24.z.strictObject({
-  inputs: import_zod24.z.array(AudioDevice).max(64),
-  outputs: import_zod24.z.array(AudioDevice).max(64)
+var AudioDevicesParams = import_zod25.z.strictObject({});
+var AudioDevicesResult = import_zod25.z.strictObject({
+  inputs: import_zod25.z.array(AudioDevice).max(64),
+  outputs: import_zod25.z.array(AudioDevice).max(64)
 });
-var AudioRecordParams = import_zod24.z.strictObject({
-  seconds: import_zod24.z.number().min(0.5).max(600),
+var AudioRecordParams = import_zod25.z.strictObject({
+  seconds: import_zod25.z.number().min(0.5).max(600),
   /** The microphone (from audio.devices); the default input when absent. */
-  device_id: import_zod24.z.string().min(1).max(256).optional(),
+  device_id: import_zod25.z.string().min(1).max(256).optional(),
   /** Where the WAV file goes; a new file in the temp folder when absent. */
   path: AbsPath.optional()
 });
-var AudioRecordResult = import_zod24.z.strictObject({
+var AudioRecordResult = import_zod25.z.strictObject({
   path: AbsPath,
-  seconds: import_zod24.z.number().min(0),
+  seconds: import_zod25.z.number().min(0),
   bytes: nonNegInt,
   /** Loudest sample, 0–1: 0 means the device gave silence. */
-  peak: import_zod24.z.number().min(0).max(1)
+  peak: import_zod25.z.number().min(0).max(1)
 });
-var AudioPlayParams = import_zod24.z.strictObject({ path: AbsPath });
-var AudioPlayResult = import_zod24.z.strictObject({ path: AbsPath, seconds: import_zod24.z.number().min(0) });
+var AudioPlayParams = import_zod25.z.strictObject({ path: AbsPath });
+var AudioPlayResult = import_zod25.z.strictObject({ path: AbsPath, seconds: import_zod25.z.number().min(0) });
 
 // src/schema/fs-watch.ts
-var import_zod25 = require("zod");
-var FsWatchId = import_zod25.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = import_zod25.z.strictObject({
+var import_zod26 = require("zod");
+var FsWatchId = import_zod26.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = import_zod26.z.strictObject({
   path: AbsPath,
-  recursive: import_zod25.z.boolean().default(true),
+  recursive: import_zod26.z.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: import_zod25.z.array(import_zod25.z.string().max(256)).max(64).default([])
+  ignore: import_zod26.z.array(import_zod26.z.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = import_zod25.z.strictObject({
+var FsWatchStartResult = import_zod26.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_zod25.z.strictObject({
+var FsWatchEventsParams = import_zod26.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_zod25.z.int().min(0).max(25e3).default(0)
+  wait_ms: import_zod26.z.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = import_zod25.z.strictObject({
+var FsWatchEventsResult = import_zod26.z.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: import_zod25.z.array(FsChange).max(1e3),
+  changes: import_zod26.z.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: import_zod25.z.boolean(),
+  overflow: import_zod26.z.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = import_zod25.z.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = import_zod25.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = import_zod26.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = import_zod26.z.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-var import_zod26 = require("zod");
-var ExecJobId = import_zod26.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = import_zod26.z.strictObject({
-  command: import_zod26.z.string().min(1).max(131072),
+var import_zod27 = require("zod");
+var ExecJobId = import_zod27.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = import_zod27.z.strictObject({
+  command: import_zod27.z.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: import_zod26.z.record(import_zod26.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod26.z.string().max(32768)).optional()
+  env: import_zod27.z.record(import_zod27.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod27.z.string().max(32768)).optional()
 });
-var ExecJobStartResult = import_zod26.z.strictObject({ job_id: ExecJobId, pid: import_zod26.z.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = import_zod26.z.strictObject({
+var ExecJobStartResult = import_zod27.z.strictObject({ job_id: ExecJobId, pid: import_zod27.z.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = import_zod27.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_zod26.z.int().min(0).max(25e3).default(0),
-  max_bytes: import_zod26.z.int().min(1024).max(1048576).default(65536)
+  wait_ms: import_zod27.z.int().min(0).max(25e3).default(0),
+  max_bytes: import_zod27.z.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = import_zod26.z.strictObject({
+var ExecJobOutputResult = import_zod27.z.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: import_zod26.z.string(),
+  output: import_zod27.z.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: import_zod26.z.boolean(),
-  exit_code: import_zod26.z.int().nullable()
+  running: import_zod27.z.boolean(),
+  exit_code: import_zod27.z.int().nullable()
 });
-var ExecJobStopParams = import_zod26.z.strictObject({
+var ExecJobStopParams = import_zod27.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_zod26.z.boolean().default(false)
+  force: import_zod27.z.boolean().default(false)
 });
-var ExecJobStopResult = import_zod26.z.strictObject({ job_id: ExecJobId, exited: import_zod26.z.boolean(), exit_code: import_zod26.z.int().nullable() });
-var ExecJobInfo = import_zod26.z.strictObject({
+var ExecJobStopResult = import_zod27.z.strictObject({ job_id: ExecJobId, exited: import_zod27.z.boolean(), exit_code: import_zod27.z.int().nullable() });
+var ExecJobInfo = import_zod27.z.strictObject({
   job_id: ExecJobId,
-  command: import_zod26.z.string().max(1024),
-  pid: import_zod26.z.int().min(1),
+  command: import_zod27.z.string().max(1024),
+  pid: import_zod27.z.int().min(1),
   cwd: AbsPath,
-  running: import_zod26.z.boolean(),
-  exit_code: import_zod26.z.int().nullable(),
+  running: import_zod27.z.boolean(),
+  exit_code: import_zod27.z.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = import_zod26.z.strictObject({});
-var ExecJobListResult = import_zod26.z.strictObject({ jobs: import_zod26.z.array(ExecJobInfo).max(64) });
+var ExecJobListParams = import_zod27.z.strictObject({});
+var ExecJobListResult = import_zod27.z.strictObject({ jobs: import_zod27.z.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-var import_zod27 = require("zod");
-var CodingServiceCredentials = import_zod27.z.strictObject({
-  access_token: import_zod27.z.string().min(16).max(16384),
-  user_id: import_zod27.z.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/),
+var import_zod28 = require("zod");
+var CodingServiceCredentials = import_zod28.z.strictObject({
+  access_token: import_zod28.z.string().min(16).max(16384),
+  user_id: import_zod28.z.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/),
   /** The AI Matrx server this app talks to (production, or a local server on the nightly copy). */
-  server_url: import_zod27.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: import_zod28.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = import_zod27.z.enum([
+var CodingHistoryBlocked = import_zod28.z.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -2189,11 +2417,11 @@ var CodingHistoryBlocked = import_zod27.z.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = import_zod27.z.strictObject({
-  session_id: import_zod27.z.string().max(64),
-  reason: import_zod27.z.string().max(300)
+var CodingHistoryFailure = import_zod28.z.strictObject({
+  session_id: import_zod28.z.string().max(64),
+  reason: import_zod28.z.string().max(300)
 });
-var CodingHistoryRun = import_zod27.z.strictObject({
+var CodingHistoryRun = import_zod28.z.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -2208,39 +2436,39 @@ var CodingHistoryRun = import_zod27.z.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: import_zod27.z.array(CodingHistoryFailure).max(20),
+  failures: import_zod28.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_zod27.z.string().max(400)
+  summary: import_zod28.z.string().max(400)
 });
-var CodingHistoryStep = import_zod27.z.strictObject({
+var CodingHistoryStep = import_zod28.z.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: import_zod27.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: import_zod27.z.boolean(),
+  plan_id: import_zod28.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: import_zod28.z.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = import_zod27.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = import_zod27.z.strictObject({
-  plan_id: import_zod27.z.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = import_zod28.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = import_zod28.z.strictObject({
+  plan_id: import_zod28.z.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = import_zod27.z.strictObject({
-  phase: import_zod27.z.enum(["checking", "importing"]),
+var CodingServiceProgress = import_zod28.z.strictObject({
+  phase: import_zod28.z.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = import_zod27.z.strictObject({});
-var CodingHistoryImportMissingResult = import_zod27.z.strictObject({
-  state: import_zod27.z.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = import_zod28.z.strictObject({});
+var CodingHistoryImportMissingResult = import_zod28.z.strictObject({
+  state: import_zod28.z.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = import_zod27.z.strictObject({
+var CodingHistoryProgressEvent = import_zod28.z.strictObject({
   request_id: RequestId,
-  phase: import_zod27.z.enum(["checking", "importing"]),
+  phase: import_zod28.z.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -2342,9 +2570,19 @@ var OPS = {
   "power.status": { params: PowerStatusParams, result: PowerStatusResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] },
   "power.prevent_sleep": { params: PowerPreventSleepParams, result: PowerPreventSleepResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "resources.snapshot": { params: ResourcesSnapshotParams, result: ResourcesSnapshotResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] },
+  "resources.activity": { params: ResourcesActivityParams, result: ResourcesActivityResult, kind: "unary", since: "1.17", errors: ["PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "resources.stop_job": { params: ResourcesStopJobParams, result: ResourcesStopJobResult, kind: "unary", since: "1.17", errors: ["NOT_FOUND", "CONFLICT", "AUTH_FORBIDDEN", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "resources.incidents": { params: ResourcesIncidentsParams, result: ResourcesIncidentsResult, kind: "unary", since: "1.17", errors: ["INTERNAL"] },
   "audio.devices": { params: AudioDevicesParams, result: AudioDevicesResult, kind: "unary", since: "1.6", errors: ["PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "audio.record": { params: AudioRecordParams, result: AudioRecordResult, kind: "unary", since: "1.6", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "RESOURCE_BUSY", "INTERNAL"] },
   "audio.play": { params: AudioPlayParams, result: AudioPlayResult, kind: "unary", since: "1.6", errors: ["NOT_FOUND", "INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  // The local AI Matrx servers (aidream's process-compose stack), supervised from Matrx 2's core.
+  "stack.state": { params: StackStateParams, result: StackStateResult, kind: "unary", since: "1.16", errors: ["INTERNAL"] },
+  "stack.start": { params: StackStartParams, result: StackRunResult, kind: "unary", since: "1.16", errors: ["RESOURCE_BUSY", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "stack.stop": { params: StackStopParams, result: StackRunResult, kind: "unary", since: "1.16", errors: ["RESOURCE_BUSY", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "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"] },
   // 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"] }
 };
@@ -2569,6 +2807,20 @@ var NAMED_SCHEMAS = {
   ResourcesDisk,
   ResourcesSnapshotParams,
   ResourcesSnapshotResult,
+  ResourcesJobKind,
+  ResourcesStrain,
+  ResourcesPressure,
+  ResourcesVerdict,
+  ResourcesSample,
+  ResourcesJob,
+  ResourcesProcess,
+  ResourcesActivityParams,
+  ResourcesActivityResult,
+  ResourcesStopJobParams,
+  ResourcesStopJobResult,
+  ResourcesIncident,
+  ResourcesIncidentsParams,
+  ResourcesIncidentsResult,
   AudioDevice,
   AudioDevicesParams,
   AudioDevicesResult,
@@ -2576,6 +2828,21 @@ var NAMED_SCHEMAS = {
   AudioRecordResult,
   AudioPlayParams,
   AudioPlayResult,
+  StackServerName,
+  StackTone,
+  StackServer,
+  StackEvent,
+  StackStateParams,
+  StackStateResult,
+  StackStartParams,
+  StackStopParams,
+  StackRunResult,
+  StackServerActionParams,
+  StackServerActionResult,
+  StackLogsParams,
+  StackLogsResult,
+  StackErrorsParams,
+  StackErrorsResult,
   FsWatchId,
   FsWatchStartParams,
   FsWatchStartResult,
@@ -2705,7 +2972,8 @@ var FIELDS_SINCE = {
   AppsAccountsUsageResult: { problem: "1.12" },
   AppsAccountsResetsResult: { problem: "1.12" },
   ChatRow: { app_project: "1.13", tokens: "1.13", original_title: "1.14", title_source: "1.14", title_override: "1.14", archived: "1.15" },
-  AccountUsage: { plan: "1.13", credits: "1.13" }
+  AccountUsage: { plan: "1.13", credits: "1.13" },
+  ResourcesDisk: { name: "1.17" }
 };
 var NULL_SINCE = {
   "RelayDeviceStatusEvent.since_ms": { since: "1.1", olderPeersGet: 0 }
@@ -2772,7 +3040,8 @@ var NESTED_RESULTS = /* @__PURE__ */ new Map([
   ["apps.projects.move", [["chat", "ChatRow"]]],
   ["apps.chats.star", [["chat", "ChatRow"]]],
   ["apps.chats.place", [["chat", "ChatRow"]]],
-  ["apps.accounts.usage", [["accounts", "AccountUsage"]]]
+  ["apps.accounts.usage", [["accounts", "AccountUsage"]]],
+  ["resources.snapshot", [["disks", "ResourcesDisk"]]]
 ]);
 function stripNested(value, nested, version) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
@@ -2833,7 +3102,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 = "91060640a08d25f693f4d90384da7225299ab8fd287b665ca7d36f226d641267";
+var CONTRACT_SHA256 = "cdfad283c689005856b4161f28a37892d1c3356db077f685a4a659fc2c8fc657";
 
 // src/close-policy.ts
 var CLOSE_RULES = {
@@ -2893,7 +3162,7 @@ var TOOL_CATALOG = [
   { name: "desktop_input", group: "os_control", state: "built", path: "device_op", ops: ["input.type_text", "input.hotkey", "input.mouse_click", "input.mouse_move"], platforms: ALL, summary: "Keyboard and mouse" },
   { name: "desktop_audio", group: "os_control", state: "built", path: "device_op", ops: ["audio.devices", "audio.record", "audio.play"], platforms: ALL, summary: "Audio devices, record, play" },
   { name: "desktop_power", group: "os_control", state: "built", path: "device_op", ops: ["power.status", "power.prevent_sleep"], platforms: ALL, summary: "Battery and keep awake" },
-  { name: "desktop_resources", group: "os_control", state: "built", path: "device_op", ops: ["resources.snapshot"], platforms: ALL, summary: "CPU, memory and disk use" },
+  { name: "desktop_resources", group: "os_control", state: "built", path: "device_op", ops: ["resources.snapshot", "resources.activity", "resources.stop_job", "resources.incidents"], platforms: ALL, summary: "CPU, memory and disk use; what is using them, grouped into jobs; stop a job; the slowdown log" },
   { name: "fs_watch", group: "os_control", state: "built", path: "device_op", ops: ["fs.watch.start", "fs.watch.events", "fs.watch.stop"], platforms: ALL, summary: "Watch a folder; read what changed" },
   // ── 3. Personal apps and automation ──────────────────────────────────────────────────────────
   { name: "desktop_automation", group: "personal_automation", state: "planned", path: "device_op", ops: ["automation.script"], platforms: ["darwin", "win32"], summary: "AppleScript on a Mac, PowerShell on Windows" },