@ai-matrx/desktop-protocol 0.14.0 → 0.16.0

package/dist/index.cjs

@@ -52,6 +52,17 @@ __export(src_exports, {
   ClipboardWriteResult: () => ClipboardWriteResult,
   CloseCode: () => CloseCode,
   CloseCodeValue: () => CloseCodeValue,
+  CodingHistoryBlocked: () => CodingHistoryBlocked,
+  CodingHistoryFailure: () => CodingHistoryFailure,
+  CodingHistoryImportMissingParams: () => CodingHistoryImportMissingParams,
+  CodingHistoryImportMissingResult: () => CodingHistoryImportMissingResult,
+  CodingHistoryProgressEvent: () => CodingHistoryProgressEvent,
+  CodingHistoryRun: () => CodingHistoryRun,
+  CodingHistoryStep: () => CodingHistoryStep,
+  CodingImportNextParams: () => CodingImportNextParams,
+  CodingPlanMissingParams: () => CodingPlanMissingParams,
+  CodingServiceCredentials: () => CodingServiceCredentials,
+  CodingServiceProgress: () => CodingServiceProgress,
   ContractHash: () => ContractHash,
   CoreToClientMsg: () => CoreToClientMsg,
   CoreToServiceMsg: () => CoreToServiceMsg,
@@ -71,6 +82,16 @@ __export(src_exports, {
   EventMsg: () => EventMsg,
   ExecCwdEvent: () => ExecCwdEvent,
   ExecExitedEvent: () => ExecExitedEvent,
+  ExecJobId: () => ExecJobId,
+  ExecJobInfo: () => ExecJobInfo,
+  ExecJobListParams: () => ExecJobListParams,
+  ExecJobListResult: () => ExecJobListResult,
+  ExecJobOutputParams: () => ExecJobOutputParams,
+  ExecJobOutputResult: () => ExecJobOutputResult,
+  ExecJobStartParams: () => ExecJobStartParams,
+  ExecJobStartResult: () => ExecJobStartResult,
+  ExecJobStopParams: () => ExecJobStopParams,
+  ExecJobStopResult: () => ExecJobStopResult,
   ExecListParams: () => ExecListParams,
   ExecListResult: () => ExecListResult,
   ExecPtyKillParams: () => ExecPtyKillParams,
@@ -120,11 +141,28 @@ __export(src_exports, {
   FsSearchPathsResult: () => FsSearchPathsResult,
   FsStatParams: () => FsStatParams,
   FsStatResult: () => FsStatResult,
+  FsWatchEventsParams: () => FsWatchEventsParams,
+  FsWatchEventsResult: () => FsWatchEventsResult,
+  FsWatchId: () => FsWatchId,
   FsWatchParams: () => FsWatchParams,
   FsWatchResult: () => FsWatchResult,
+  FsWatchStartParams: () => FsWatchStartParams,
+  FsWatchStartResult: () => FsWatchStartResult,
+  FsWatchStopParams: () => FsWatchStopParams,
+  FsWatchStopResult: () => FsWatchStopResult,
   FsWriteParams: () => FsWriteParams,
   FsWriteResult: () => FsWriteResult,
   HelloMsg: () => HelloMsg,
+  InputHotkeyParams: () => InputHotkeyParams,
+  InputHotkeyResult: () => InputHotkeyResult,
+  InputKey: () => InputKey,
+  InputMouseClickParams: () => InputMouseClickParams,
+  InputMouseClickResult: () => InputMouseClickResult,
+  InputMouseMoveParams: () => InputMouseMoveParams,
+  InputMouseMoveResult: () => InputMouseMoveResult,
+  InputPoint: () => InputPoint,
+  InputTypeTextParams: () => InputTypeTextParams,
+  InputTypeTextResult: () => InputTypeTextResult,
   LEGACY_ACTIONS: () => LEGACY_ACTIONS,
   LEGACY_DISPATCHERS: () => LEGACY_DISPATCHERS,
   Limits: () => Limits,
@@ -153,6 +191,10 @@ __export(src_exports, {
   PROTOCOL_MAJOR: () => PROTOCOL_MAJOR,
   PROTOCOL_MINOR: () => PROTOCOL_MINOR,
   PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  PowerPreventSleepParams: () => PowerPreventSleepParams,
+  PowerPreventSleepResult: () => PowerPreventSleepResult,
+  PowerStatusParams: () => PowerStatusParams,
+  PowerStatusResult: () => PowerStatusResult,
   ProcInfo: () => ProcInfo,
   ProcKillParams: () => ProcKillParams,
   ProcKillResult: () => ProcKillResult,
@@ -183,10 +225,18 @@ __export(src_exports, {
   RequestMsg: () => RequestMsg,
   ResourceId: () => ResourceId,
   ResourceInfo: () => ResourceInfo,
+  ResourcesDisk: () => ResourcesDisk,
+  ResourcesSnapshotParams: () => ResourcesSnapshotParams,
+  ResourcesSnapshotResult: () => ResourcesSnapshotResult,
   ResponseMsg: () => ResponseMsg,
   SERVICES: () => SERVICES,
   SERVICE_MAX_FRAME_BYTES: () => SERVICE_MAX_FRAME_BYTES,
   SUBPROTOCOL: () => SUBPROTOCOL,
+  ScreenCaptureParams: () => ScreenCaptureParams,
+  ScreenCaptureResult: () => ScreenCaptureResult,
+  ScreenDisplay: () => ScreenDisplay,
+  ScreenListParams: () => ScreenListParams,
+  ScreenListResult: () => ScreenListResult,
   ServiceCancel: () => ServiceCancel,
   ServiceErrorMsg: () => ServiceErrorMsg,
   ServiceHello: () => ServiceHello,
@@ -214,6 +264,12 @@ __export(src_exports, {
   StreamMsg: () => StreamMsg,
   SysinfoGetParams: () => SysinfoGetParams,
   SysinfoGetResult: () => SysinfoGetResult,
+  SystemNotifyParams: () => SystemNotifyParams,
+  SystemNotifyResult: () => SystemNotifyResult,
+  SystemOpenPathParams: () => SystemOpenPathParams,
+  SystemOpenPathResult: () => SystemOpenPathResult,
+  SystemOpenUrlParams: () => SystemOpenUrlParams,
+  SystemOpenUrlResult: () => SystemOpenUrlResult,
   TOOL_CATALOG: () => TOOL_CATALOG,
   TOOL_GROUPS: () => TOOL_GROUPS,
   TOOL_LEVELS: () => TOOL_LEVELS,
@@ -230,6 +286,15 @@ __export(src_exports, {
   TranscriptionModelInfo: () => TranscriptionModelInfo,
   VERSIONED_RESULT_OPS: () => VERSIONED_RESULT_OPS,
   Welcome: () => Welcome,
+  WindowFocusParams: () => WindowFocusParams,
+  WindowFocusResult: () => WindowFocusResult,
+  WindowInfo: () => WindowInfo,
+  WindowListParams: () => WindowListParams,
+  WindowListResult: () => WindowListResult,
+  WindowMinimizeParams: () => WindowMinimizeParams,
+  WindowMinimizeResult: () => WindowMinimizeResult,
+  WindowMoveParams: () => WindowMoveParams,
+  WindowMoveResult: () => WindowMoveResult,
   announcedVersion: () => announcedVersion,
   assertFrameHeader: () => assertFrameHeader,
   buildToolStatus: () => buildToolStatus,
@@ -260,7 +325,7 @@ module.exports = __toCommonJS(src_exports);
 // src/schema/primitives.ts
 var import_zod = require("zod");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 3;
+var PROTOCOL_MINOR = 5;
 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_-]+$/);
@@ -1136,7 +1201,7 @@ var AppsOpenResult = import_zod11.z.strictObject({
 // src/schema/service.ts
 var import_zod12 = require("zod");
 var SERVICE_MAX_FRAME_BYTES = 16777216;
-var ServiceName = import_zod12.z.enum(["ml"]);
+var ServiceName = import_zod12.z.enum(["ml", "coding"]);
 var ContractHash = import_zod12.z.string().regex(/^[0-9a-f]{64}$/);
 var ServiceToken = import_zod12.z.string().regex(/^[A-Za-z0-9_-]{43}$/);
 var ServiceRequestId = u32;
@@ -1271,6 +1336,416 @@ var ClipboardReadResult = import_zod15.z.strictObject({
 var ClipboardWriteParams = import_zod15.z.strictObject({ text: import_zod15.z.string().max(1048576) });
 var ClipboardWriteResult = import_zod15.z.strictObject({ bytes: nonNegInt });
 
+// src/schema/system.ts
+var import_zod16 = require("zod");
+var SystemOpenUrlParams = import_zod16.z.strictObject({
+  /** http, https or mailto; opened in the person's default app for it. */
+  url: import_zod16.z.string().min(1).max(4096)
+});
+var SystemOpenUrlResult = import_zod16.z.strictObject({ url: import_zod16.z.string().max(4096) });
+var SystemOpenPathParams = import_zod16.z.strictObject({
+  path: AbsPath,
+  /** Show it in the file manager (Finder, Explorer) instead of opening it. */
+  reveal: import_zod16.z.boolean().default(false)
+});
+var SystemOpenPathResult = import_zod16.z.strictObject({ path: AbsPath, revealed: import_zod16.z.boolean() });
+var SystemNotifyParams = import_zod16.z.strictObject({
+  title: import_zod16.z.string().min(1).max(128),
+  body: import_zod16.z.string().max(1024).default("")
+});
+var SystemNotifyResult = import_zod16.z.strictObject({
+  /** False when this computer has no notification service to show it (a bare Linux box). */
+  shown: import_zod16.z.boolean()
+});
+
+// src/schema/screen.ts
+var import_zod17 = require("zod");
+var ScreenDisplay = import_zod17.z.strictObject({
+  /** The OS's display id; pass it to screen.capture. */
+  id: nonNegInt,
+  name: import_zod17.z.string().max(128),
+  /** Position and size in the OS's logical points (x and y may be negative left of or above the main display). */
+  x: import_zod17.z.int(),
+  y: import_zod17.z.int(),
+  width: import_zod17.z.int().min(1),
+  height: import_zod17.z.int().min(1),
+  /** Pixels per point (2 on a Retina display). */
+  scale: import_zod17.z.number().min(0.1).max(8),
+  primary: import_zod17.z.boolean()
+});
+var ScreenListParams = import_zod17.z.strictObject({});
+var ScreenListResult = import_zod17.z.strictObject({ displays: import_zod17.z.array(ScreenDisplay).max(32) });
+var ScreenCaptureParams = import_zod17.z.strictObject({
+  /** The display (from screen.list); the primary display when absent. */
+  display_id: nonNegInt.optional(),
+  format: import_zod17.z.enum(["jpeg", "png"]).default("jpeg"),
+  /** Scale the picture down to at most this width in pixels (kept when already smaller). */
+  max_width: import_zod17.z.int().min(160).max(7680).default(1600)
+});
+var ScreenCaptureResult = import_zod17.z.strictObject({
+  display_id: nonNegInt,
+  mime_type: import_zod17.z.enum(["image/jpeg", "image/png"]),
+  width: import_zod17.z.int().min(1),
+  height: import_zod17.z.int().min(1),
+  /** The display's full resolution in pixels, before scaling. */
+  source_width: import_zod17.z.int().min(1),
+  source_height: import_zod17.z.int().min(1),
+  /** The image, base64 (at most 6 MiB of text). */
+  data_base64: import_zod17.z.string().max(6291456)
+});
+
+// src/schema/window.ts
+var import_zod18 = require("zod");
+var WindowInfo = import_zod18.z.strictObject({
+  /** The OS's window handle (macOS window number, Windows HWND, X11 window id). */
+  id: nonNegInt,
+  title: import_zod18.z.string().max(512),
+  /** Position and size in logical points. */
+  x: import_zod18.z.int(),
+  y: import_zod18.z.int(),
+  width: import_zod18.z.int().min(0),
+  height: import_zod18.z.int().min(0)
+});
+var WindowListParams = import_zod18.z.strictObject({
+  /** Case-insensitive substring of the window title. */
+  title: import_zod18.z.string().min(1).max(256).optional(),
+  limit: import_zod18.z.int().min(1).max(500).default(100)
+});
+var WindowListResult = import_zod18.z.strictObject({
+  windows: import_zod18.z.array(WindowInfo).max(500),
+  total: nonNegInt,
+  truncated: import_zod18.z.boolean()
+});
+var WindowFocusParams = import_zod18.z.strictObject({ id: nonNegInt });
+var WindowFocusResult = import_zod18.z.strictObject({ window: WindowInfo });
+var WindowMoveParams = import_zod18.z.strictObject({
+  id: nonNegInt,
+  /** New top-left corner; unchanged when absent. */
+  x: import_zod18.z.int().optional(),
+  y: import_zod18.z.int().optional(),
+  /** New size; unchanged when absent. */
+  width: import_zod18.z.int().min(50).max(16384).optional(),
+  height: import_zod18.z.int().min(50).max(16384).optional()
+});
+var WindowMoveResult = import_zod18.z.strictObject({ window: WindowInfo });
+var WindowMinimizeParams = import_zod18.z.strictObject({ id: nonNegInt });
+var WindowMinimizeResult = import_zod18.z.strictObject({ id: nonNegInt });
+
+// src/schema/input.ts
+var import_zod19 = require("zod");
+var InputKey = import_zod19.z.enum([
+  "cmd",
+  "ctrl",
+  "alt",
+  "shift",
+  "meta",
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "f1",
+  "f2",
+  "f3",
+  "f4",
+  "f5",
+  "f6",
+  "f7",
+  "f8",
+  "f9",
+  "f10",
+  "f11",
+  "f12",
+  "enter",
+  "tab",
+  "escape",
+  "space",
+  "backspace",
+  "delete",
+  "up",
+  "down",
+  "left",
+  "right",
+  "home",
+  "end",
+  "pageup",
+  "pagedown",
+  "minus",
+  "equal",
+  "comma",
+  "period",
+  "slash",
+  "semicolon",
+  "quote",
+  "bracketleft",
+  "bracketright",
+  "backslash",
+  "grave"
+]);
+var InputTypeTextParams = import_zod19.z.strictObject({ text: import_zod19.z.string().min(1).max(1e4) });
+var InputTypeTextResult = import_zod19.z.strictObject({ characters: import_zod19.z.int().min(1) });
+var InputHotkeyParams = import_zod19.z.strictObject({
+  /** Pressed together in order and released in reverse: ["cmd", "shift", "t"]. */
+  keys: import_zod19.z.array(InputKey).min(1).max(6)
+});
+var InputHotkeyResult = import_zod19.z.strictObject({ keys: import_zod19.z.array(InputKey) });
+var InputPoint = import_zod19.z.strictObject({ x: import_zod19.z.int(), y: import_zod19.z.int() });
+var InputMouseMoveParams = import_zod19.z.strictObject({
+  /** Screen position in logical points (the coordinates screen.list and window.list report). */
+  x: import_zod19.z.int(),
+  y: import_zod19.z.int()
+});
+var InputMouseMoveResult = import_zod19.z.strictObject({
+  /** Where the pointer is now, read back from the OS. */
+  position: InputPoint
+});
+var InputMouseClickParams = import_zod19.z.strictObject({
+  /** Move here first; clicks where the pointer is when absent. */
+  x: import_zod19.z.int().optional(),
+  y: import_zod19.z.int().optional(),
+  button: import_zod19.z.enum(["left", "right", "middle"]).default("left"),
+  double: import_zod19.z.boolean().default(false)
+});
+var InputMouseClickResult = import_zod19.z.strictObject({
+  position: InputPoint,
+  button: import_zod19.z.enum(["left", "right", "middle"]),
+  double: import_zod19.z.boolean()
+});
+
+// src/schema/power.ts
+var import_zod20 = require("zod");
+var PowerStatusParams = import_zod20.z.strictObject({});
+var PowerStatusResult = import_zod20.z.strictObject({
+  has_battery: import_zod20.z.boolean(),
+  /** 0–100; null without a battery. */
+  percent: import_zod20.z.number().min(0).max(100).nullable(),
+  charging: import_zod20.z.boolean().nullable(),
+  /** On wall power; null where the OS does not say. */
+  plugged_in: import_zod20.z.boolean().nullable(),
+  /** Minutes of battery left; null when charging, unknown or without a battery. */
+  minutes_left: nonNegInt.nullable(),
+  /** Matrx 2 is keeping the computer awake (power.prevent_sleep) until this time; null when it is not. */
+  awake_until_ms: epochMs.nullable()
+});
+var PowerPreventSleepParams = import_zod20.z.strictObject({
+  /** Keep the computer awake this long; 0 lets it sleep again now. */
+  seconds: import_zod20.z.int().min(0).max(86400),
+  /** Shown where the OS lists what keeps it awake. */
+  reason: import_zod20.z.string().min(1).max(128).default("Matrx 2 is working")
+});
+var PowerPreventSleepResult = import_zod20.z.strictObject({
+  /** When it may sleep again; null after seconds 0. */
+  awake_until_ms: epochMs.nullable()
+});
+
+// src/schema/resources.ts
+var import_zod21 = require("zod");
+var ResourcesDisk = import_zod21.z.strictObject({
+  /** Where it is mounted ("/", "C:"). */
+  mount: import_zod21.z.string().max(512),
+  /** The file system ("apfs", "NTFS", "ext4"). */
+  fs: import_zod21.z.string().max(64),
+  size_bytes: nonNegInt,
+  used_bytes: nonNegInt,
+  available_bytes: nonNegInt
+});
+var ResourcesSnapshotParams = import_zod21.z.strictObject({});
+var ResourcesSnapshotResult = import_zod21.z.strictObject({
+  cpu: import_zod21.z.strictObject({
+    /** Busy share of all cores, 0–100, measured now. */
+    percent: import_zod21.z.number().min(0).max(100),
+    cores: import_zod21.z.int().min(1),
+    /** 1, 5 and 15 minute load averages; null on Windows. */
+    load: import_zod21.z.array(import_zod21.z.number().min(0)).length(3).nullable()
+  }),
+  memory: import_zod21.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: import_zod21.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: import_zod21.z.array(ResourcesDisk).max(64),
+  uptime_seconds: nonNegInt
+});
+
+// src/schema/fs-watch.ts
+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_zod22.z.boolean().default(true),
+  /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
+  ignore: import_zod22.z.array(import_zod22.z.string().max(256)).max(64).default([])
+});
+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_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_zod22.z.int().min(0).max(25e3).default(0)
+});
+var FsWatchEventsResult = import_zod22.z.strictObject({
+  /** What changed since the last read, oldest first; re-checked against the disk when read. */
+  changes: import_zod22.z.array(FsChange).max(1e3),
+  /** Changes were dropped (more than 1000 waited): list the folder again. */
+  overflow: import_zod22.z.boolean(),
+  expires_at_ms: epochMs
+});
+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_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_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_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_zod23.z.int().min(0).max(25e3).default(0),
+  max_bytes: import_zod23.z.int().min(1024).max(1048576).default(65536)
+});
+var ExecJobOutputResult = import_zod23.z.strictObject({
+  /** stdout and stderr interleaved as they arrived (UTF-8). */
+  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_zod23.z.boolean(),
+  exit_code: import_zod23.z.int().nullable()
+});
+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_zod23.z.boolean().default(false)
+});
+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_zod23.z.string().max(1024),
+  pid: import_zod23.z.int().min(1),
+  cwd: AbsPath,
+  running: import_zod23.z.boolean(),
+  exit_code: import_zod23.z.int().nullable(),
+  started_at_ms: epochMs,
+  output_bytes: nonNegInt
+});
+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_zod24 = require("zod");
+var CodingServiceCredentials = import_zod24.z.strictObject({
+  access_token: import_zod24.z.string().min(16).max(16384),
+  user_id: import_zod24.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_zod24.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+});
+var CodingHistoryBlocked = import_zod24.z.enum([
+  "signed_out",
+  "offline",
+  "organization_required",
+  "claude_unavailable",
+  "cloud_list_unavailable",
+  "history_too_large"
+]);
+var CodingHistoryFailure = import_zod24.z.strictObject({
+  session_id: import_zod24.z.string().max(64),
+  reason: import_zod24.z.string().max(300)
+});
+var CodingHistoryRun = import_zod24.z.strictObject({
+  /** Claude Code sessions found on this computer. */
+  local_sessions: nonNegInt,
+  /** Of those, already complete in AI Matrx. */
+  in_cloud: nonNegInt,
+  /** In AI Matrx under neither of its identities. */
+  missing: nonNegInt,
+  /** In AI Matrx, but changed here after the last turn AI Matrx received (turns the hook lost). */
+  behind: nonNegInt,
+  /** Over the importer's size cap; never imported. */
+  too_large: nonNegInt,
+  imported: nonNegInt,
+  /** Changed while being read; a later run takes them. */
+  changed: nonNegInt,
+  failed: nonNegInt,
+  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_zod24.z.string().max(400)
+});
+var CodingHistoryStep = import_zod24.z.strictObject({
+  /** Null when the run could not start (blocked before a plan existed). */
+  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_zod24.z.strictObject({ credentials: CodingServiceCredentials });
+var CodingImportNextParams = import_zod24.z.strictObject({
+  plan_id: import_zod24.z.string().regex(/^[0-9a-f]{32}$/),
+  credentials: CodingServiceCredentials
+});
+var CodingServiceProgress = import_zod24.z.strictObject({
+  phase: import_zod24.z.enum(["checking", "importing"]),
+  done: nonNegInt,
+  total: nonNegInt
+});
+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_zod24.z.strictObject({
+  request_id: RequestId,
+  phase: import_zod24.z.enum(["checking", "importing"]),
+  /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
+  done: nonNegInt,
+  total: nonNegInt,
+  imported: nonNegInt,
+  failed: nonNegInt
+});
+
 // src/schema/registry.ts
 var FS_ERR = ["NOT_FOUND", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "RESOURCE_BUSY", "INTERNAL"];
 var OPS = {
@@ -1312,7 +1787,32 @@ var OPS = {
   "proc.ports": { params: ProcPortsParams, result: ProcPortsResult, kind: "unary", since: "1.3", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   "proc.kill": { params: ProcKillParams, result: ProcKillResult, kind: "unary", since: "1.3", errors: ["NOT_FOUND", "AUTH_FORBIDDEN", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "INTERNAL"] },
   "clipboard.read": { params: ClipboardReadParams, result: ClipboardReadResult, kind: "unary", since: "1.3", errors: ["PLATFORM_UNSUPPORTED", "INTERNAL"] },
-  "clipboard.write": { params: ClipboardWriteParams, result: ClipboardWriteResult, kind: "unary", since: "1.3", errors: ["PLATFORM_UNSUPPORTED", "PAYLOAD_TOO_LARGE", "INTERNAL"] }
+  "clipboard.write": { params: ClipboardWriteParams, result: ClipboardWriteResult, kind: "unary", since: "1.3", errors: ["PLATFORM_UNSUPPORTED", "PAYLOAD_TOO_LARGE", "INTERNAL"] },
+  "fs.watch.start": { params: FsWatchStartParams, result: FsWatchStartResult, kind: "unary", since: "1.4", errors: [...FS_ERR, "RATE_LIMITED"] },
+  "fs.watch.events": { params: FsWatchEventsParams, result: FsWatchEventsResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS", "INTERNAL"] },
+  "fs.watch.stop": { params: FsWatchStopParams, result: FsWatchStopResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS"] },
+  "exec.job.start": { params: ExecJobStartParams, result: ExecJobStartResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "NOT_FOUND", "RATE_LIMITED", "INTERNAL"] },
+  "exec.job.output": { params: ExecJobOutputParams, result: ExecJobOutputResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS"] },
+  "exec.job.stop": { params: ExecJobStopParams, result: ExecJobStopResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS", "INTERNAL"] },
+  "exec.job.list": { params: ExecJobListParams, result: ExecJobListResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] },
+  "system.open_url": { params: SystemOpenUrlParams, result: SystemOpenUrlResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "system.open_path": { params: SystemOpenPathParams, result: SystemOpenPathResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "system.notify": { params: SystemNotifyParams, result: SystemNotifyResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "INTERNAL"] },
+  "screen.list": { params: ScreenListParams, result: ScreenListResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "screen.capture": { params: ScreenCaptureParams, result: ScreenCaptureResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "PAYLOAD_TOO_LARGE", "INTERNAL"] },
+  "window.list": { params: WindowListParams, result: WindowListResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "window.focus": { params: WindowFocusParams, result: WindowFocusResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "window.move": { params: WindowMoveParams, result: WindowMoveResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "window.minimize": { params: WindowMinimizeParams, result: WindowMinimizeResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.type_text": { params: InputTypeTextParams, result: InputTypeTextResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.hotkey": { params: InputHotkeyParams, result: InputHotkeyResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.mouse_move": { params: InputMouseMoveParams, result: InputMouseMoveResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.mouse_click": { params: InputMouseClickParams, result: InputMouseClickResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "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"] },
+  // 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"] }
 };
 var EVENTS = {
   "fs.changed": FsChangedEvent,
@@ -1321,6 +1821,7 @@ var EVENTS = {
   "exec.cwd": ExecCwdEvent,
   "session.control_changed": SessionControlChangedEvent,
   "models.progress": ModelsProgressEvent,
+  "coding.history.progress": CodingHistoryProgressEvent,
   "relay.device_status": RelayDeviceStatusEvent,
   "relay.auth_expiring": RelayAuthExpiringEvent
 };
@@ -1332,6 +1833,13 @@ var SERVICES = {
       "ml.install": { params: ModelsInstallParams, result: ModelsInstallResult },
       "ml.transcribe": { params: ModelsTranscribeParams, result: ModelsTranscribeResult }
     }
+  },
+  coding: {
+    progress: CodingServiceProgress,
+    ops: {
+      "coding.plan_missing": { params: CodingPlanMissingParams, result: CodingHistoryStep },
+      "coding.import_next": { params: CodingImportNextParams, result: CodingHistoryStep }
+    }
   }
 };
 var NAMED_SCHEMAS = {
@@ -1440,6 +1948,17 @@ var NAMED_SCHEMAS = {
   ModelsStatusParams,
   ModelsStatusResult,
   ModelsProgressEvent,
+  CodingServiceCredentials,
+  CodingHistoryBlocked,
+  CodingHistoryFailure,
+  CodingHistoryRun,
+  CodingHistoryStep,
+  CodingPlanMissingParams,
+  CodingImportNextParams,
+  CodingServiceProgress,
+  CodingHistoryImportMissingParams,
+  CodingHistoryImportMissingResult,
+  CodingHistoryProgressEvent,
   ServiceName,
   ContractHash,
   ServiceToken,
@@ -1477,6 +1996,60 @@ var NAMED_SCHEMAS = {
   ClipboardReadResult,
   ClipboardWriteParams,
   ClipboardWriteResult,
+  SystemOpenUrlParams,
+  SystemOpenUrlResult,
+  SystemOpenPathParams,
+  SystemOpenPathResult,
+  SystemNotifyParams,
+  SystemNotifyResult,
+  ScreenDisplay,
+  ScreenListParams,
+  ScreenListResult,
+  ScreenCaptureParams,
+  ScreenCaptureResult,
+  WindowInfo,
+  WindowListParams,
+  WindowListResult,
+  WindowFocusParams,
+  WindowFocusResult,
+  WindowMoveParams,
+  WindowMoveResult,
+  WindowMinimizeParams,
+  WindowMinimizeResult,
+  InputKey,
+  InputPoint,
+  InputTypeTextParams,
+  InputTypeTextResult,
+  InputHotkeyParams,
+  InputHotkeyResult,
+  InputMouseMoveParams,
+  InputMouseMoveResult,
+  InputMouseClickParams,
+  InputMouseClickResult,
+  PowerStatusParams,
+  PowerStatusResult,
+  PowerPreventSleepParams,
+  PowerPreventSleepResult,
+  ResourcesDisk,
+  ResourcesSnapshotParams,
+  ResourcesSnapshotResult,
+  FsWatchId,
+  FsWatchStartParams,
+  FsWatchStartResult,
+  FsWatchEventsParams,
+  FsWatchEventsResult,
+  FsWatchStopParams,
+  FsWatchStopResult,
+  ExecJobId,
+  ExecJobStartParams,
+  ExecJobStartResult,
+  ExecJobOutputParams,
+  ExecJobOutputResult,
+  ExecJobStopParams,
+  ExecJobStopResult,
+  ExecJobInfo,
+  ExecJobListParams,
+  ExecJobListResult,
   ToolLevel,
   ToolOutcome,
   ToolPlatform,
@@ -1582,7 +2155,7 @@ function forPeer(op, part, value, version) {
 var VERSIONED_RESULT_OPS = [...RESULT_PATH.keys()];
 
 // src/contract.ts
-var CONTRACT_SHA256 = "0354e634fd50ffdc4c83b7ede7f9c31f3b2c877c4574557a6b264d2998470fd6";
+var CONTRACT_SHA256 = "c536cb055d02ce0704cee4693f08b4af9e83a38e00e6879160037c1006f2e72e";
 
 // src/close-policy.ts
 var CLOSE_RULES = {
@@ -1631,19 +2204,19 @@ var TOOL_CATALOG = [
   { name: "fs_search", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.search_paths", "fs.search_content"], platforms: ALL, summary: "Find files by name or content" },
   { name: "shell_execute", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["exec.run"], platforms: ALL, summary: "Run a command; cd carries over" },
   { name: "shell_python", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["exec.run"], platforms: ALL, summary: "Run a Python script" },
-  { name: "shell_job", group: "files_shell", state: "planned", path: "device_op", ops: ["exec.job.start", "exec.job.output", "exec.job.stop"], platforms: ALL, summary: "Background commands: start, read output, stop" },
+  { name: "shell_job", group: "files_shell", state: "built", path: "device_op", ops: ["exec.job.start", "exec.job.output", "exec.job.stop", "exec.job.list"], platforms: ALL, summary: "Background commands: start, read output, stop" },
   // ── 2. Computer control (TS owners) ──────────────────────────────────────────────────────────
   { name: "desktop_process", group: "os_control", state: "built", path: "device_op", ops: ["proc.list", "proc.ports", "proc.kill"], platforms: ALL, summary: "Running processes and ports; stop one" },
-  { name: "desktop_apps", group: "os_control", state: "planned", path: "device_op", ops: ["apps.list", "apps.open"], platforms: ALL, summary: "Installed apps; open or bring one forward" },
-  { name: "desktop_system", group: "os_control", state: "planned", path: "device_op", ops: ["sysinfo.get", "system.open_url", "system.open_path", "system.notify"], platforms: ALL, summary: "System facts, open, notify" },
+  { name: "desktop_apps", group: "os_control", state: "built", path: "device_op", ops: ["apps.list", "apps.open"], platforms: ALL, summary: "Installed apps; open or bring one forward" },
+  { name: "desktop_system", group: "os_control", state: "built", path: "device_op", ops: ["sysinfo.get", "system.open_url", "system.open_path", "system.notify"], platforms: ALL, summary: "System facts, open, notify" },
   { name: "desktop_clipboard", group: "os_control", state: "built", path: "device_op", ops: ["clipboard.read", "clipboard.write"], platforms: ALL, summary: "Read and write the clipboard's text" },
-  { name: "desktop_screen", group: "os_control", state: "planned", path: "device_op", ops: ["screen.list", "screen.capture"], platforms: ALL, summary: "Displays and screenshots" },
-  { name: "desktop_window", group: "os_control", state: "planned", path: "device_op", ops: ["window.list", "window.focus", "window.move", "window.minimize"], platforms: ALL, summary: "Find, focus and arrange windows" },
-  { name: "desktop_input", group: "os_control", state: "planned", path: "device_op", ops: ["input.type_text", "input.hotkey", "input.mouse_click", "input.mouse_move"], platforms: ALL, summary: "Keyboard and mouse" },
+  { name: "desktop_screen", group: "os_control", state: "built", path: "device_op", ops: ["screen.list", "screen.capture"], platforms: ALL, summary: "Displays and screenshots" },
+  { name: "desktop_window", group: "os_control", state: "built", path: "device_op", ops: ["window.list", "window.focus", "window.move", "window.minimize"], platforms: ALL, summary: "Find, focus and arrange windows" },
+  { 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: "planned", path: "device_op", ops: ["audio.devices", "audio.record", "audio.play"], platforms: ALL, summary: "Audio devices, record, play" },
-  { name: "desktop_power", group: "os_control", state: "planned", path: "device_op", ops: ["power.status", "power.prevent_sleep"], platforms: ALL, summary: "Battery and keep awake" },
-  { name: "desktop_resources", group: "os_control", state: "planned", path: "device_op", ops: ["resources.snapshot", "resources.top"], platforms: ALL, summary: "CPU, memory and disk use" },
-  { name: "fs_watch", group: "os_control", state: "planned", path: "device_op", ops: ["fs.watch"], platforms: ALL, summary: "Watch a folder for changes" },
+  { 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: "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" },
   { name: "desktop_mail", group: "personal_automation", state: "planned", path: "device_op", ops: ["mail.accounts", "mail.list", "mail.send"], platforms: ["darwin"], summary: "The Mail app" },
@@ -1744,7 +2317,7 @@ var LEGACY_ACTIONS = {
   "local_monitor.resources": tool("desktop_resources"),
   "local_monitor.battery": tool("desktop_power"),
   "local_monitor.disk_usage": tool("desktop_resources"),
-  "local_monitor.top_processes": tool("desktop_resources"),
+  "local_monitor.top_processes": tool("desktop_process"),
   "local_monitor.watch_directory": tool("fs_watch"),
   "local_monitor.watch_events": tool("fs_watch"),
   "local_monitor.stop_watch": tool("fs_watch"),