@ai-matrx/desktop-protocol 0.16.1 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.17.0 (protocol 1.6)
+
+- The `audio` capability: `audio.devices` (microphones and speakers), `audio.record` (a clip to a
+  WAV file, with its loudest sample so silence is visible), `audio.play` (a file).
+- TOOL_CATALOG: desktop_audio is built; group 2 is complete.
+
+Consumer action: none (new ops only; an older app answers UNKNOWN_OPERATION).
+
 ## 0.16.1
 
 - `coding.plan_missing` / `coding.import_next`: `credentials` may be null (nobody signed in); the

package/dist/client.cjs

@@ -126,7 +126,7 @@ var import_zod2 = require("zod");
 // src/schema/primitives.ts
 var import_zod = require("zod");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 5;
+var PROTOCOL_MINOR = 6;
 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_-]+$/);
@@ -1109,117 +1109,147 @@ var PowerPreventSleepResult = import_zod17.z.strictObject({
   awake_until_ms: epochMs.nullable()
 });
 
-// src/schema/resources.ts
+// src/schema/audio.ts
 var import_zod18 = require("zod");
-var ResourcesDisk = import_zod18.z.strictObject({
+var AudioDevice = import_zod18.z.strictObject({
+  /** The OS's name for it, as audio.record takes it. */
+  id: import_zod18.z.string().min(1).max(256),
+  name: import_zod18.z.string().max(256),
+  default: import_zod18.z.boolean()
+});
+var AudioDevicesParams = import_zod18.z.strictObject({});
+var AudioDevicesResult = import_zod18.z.strictObject({
+  inputs: import_zod18.z.array(AudioDevice).max(64),
+  outputs: import_zod18.z.array(AudioDevice).max(64)
+});
+var AudioRecordParams = import_zod18.z.strictObject({
+  seconds: import_zod18.z.number().min(0.5).max(600),
+  /** The microphone (from audio.devices); the default input when absent. */
+  device_id: import_zod18.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_zod18.z.strictObject({
+  path: AbsPath,
+  seconds: import_zod18.z.number().min(0),
+  bytes: nonNegInt,
+  /** Loudest sample, 0–1: 0 means the device gave silence. */
+  peak: import_zod18.z.number().min(0).max(1)
+});
+var AudioPlayParams = import_zod18.z.strictObject({ path: AbsPath });
+var AudioPlayResult = import_zod18.z.strictObject({ path: AbsPath, seconds: import_zod18.z.number().min(0) });
+
+// src/schema/resources.ts
+var import_zod19 = require("zod");
+var ResourcesDisk = import_zod19.z.strictObject({
   /** Where it is mounted ("/", "C:"). */
-  mount: import_zod18.z.string().max(512),
+  mount: import_zod19.z.string().max(512),
   /** The file system ("apfs", "NTFS", "ext4"). */
-  fs: import_zod18.z.string().max(64),
+  fs: import_zod19.z.string().max(64),
   size_bytes: nonNegInt,
   used_bytes: nonNegInt,
   available_bytes: nonNegInt
 });
-var ResourcesSnapshotParams = import_zod18.z.strictObject({});
-var ResourcesSnapshotResult = import_zod18.z.strictObject({
-  cpu: import_zod18.z.strictObject({
+var ResourcesSnapshotParams = import_zod19.z.strictObject({});
+var ResourcesSnapshotResult = import_zod19.z.strictObject({
+  cpu: import_zod19.z.strictObject({
     /** Busy share of all cores, 0–100, measured now. */
-    percent: import_zod18.z.number().min(0).max(100),
-    cores: import_zod18.z.int().min(1),
+    percent: import_zod19.z.number().min(0).max(100),
+    cores: import_zod19.z.int().min(1),
     /** 1, 5 and 15 minute load averages; null on Windows. */
-    load: import_zod18.z.array(import_zod18.z.number().min(0)).length(3).nullable()
+    load: import_zod19.z.array(import_zod19.z.number().min(0)).length(3).nullable()
   }),
-  memory: import_zod18.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
-  swap: import_zod18.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
-  disks: import_zod18.z.array(ResourcesDisk).max(64),
+  memory: import_zod19.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: import_zod19.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: import_zod19.z.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
 
 // src/schema/fs-watch.ts
-var import_zod19 = require("zod");
-var FsWatchId = import_zod19.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = import_zod19.z.strictObject({
+var import_zod20 = require("zod");
+var FsWatchId = import_zod20.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = import_zod20.z.strictObject({
   path: AbsPath,
-  recursive: import_zod19.z.boolean().default(true),
+  recursive: import_zod20.z.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: import_zod19.z.array(import_zod19.z.string().max(256)).max(64).default([])
+  ignore: import_zod20.z.array(import_zod20.z.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = import_zod19.z.strictObject({
+var FsWatchStartResult = import_zod20.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_zod19.z.strictObject({
+var FsWatchEventsParams = import_zod20.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_zod19.z.int().min(0).max(25e3).default(0)
+  wait_ms: import_zod20.z.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = import_zod19.z.strictObject({
+var FsWatchEventsResult = import_zod20.z.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: import_zod19.z.array(FsChange).max(1e3),
+  changes: import_zod20.z.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: import_zod19.z.boolean(),
+  overflow: import_zod20.z.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = import_zod19.z.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = import_zod19.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = import_zod20.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = import_zod20.z.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-var import_zod20 = require("zod");
-var ExecJobId = import_zod20.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = import_zod20.z.strictObject({
-  command: import_zod20.z.string().min(1).max(131072),
+var import_zod21 = require("zod");
+var ExecJobId = import_zod21.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = import_zod21.z.strictObject({
+  command: import_zod21.z.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: import_zod20.z.record(import_zod20.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod20.z.string().max(32768)).optional()
+  env: import_zod21.z.record(import_zod21.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod21.z.string().max(32768)).optional()
 });
-var ExecJobStartResult = import_zod20.z.strictObject({ job_id: ExecJobId, pid: import_zod20.z.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = import_zod20.z.strictObject({
+var ExecJobStartResult = import_zod21.z.strictObject({ job_id: ExecJobId, pid: import_zod21.z.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = import_zod21.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_zod20.z.int().min(0).max(25e3).default(0),
-  max_bytes: import_zod20.z.int().min(1024).max(1048576).default(65536)
+  wait_ms: import_zod21.z.int().min(0).max(25e3).default(0),
+  max_bytes: import_zod21.z.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = import_zod20.z.strictObject({
+var ExecJobOutputResult = import_zod21.z.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: import_zod20.z.string(),
+  output: import_zod21.z.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: import_zod20.z.boolean(),
-  exit_code: import_zod20.z.int().nullable()
+  running: import_zod21.z.boolean(),
+  exit_code: import_zod21.z.int().nullable()
 });
-var ExecJobStopParams = import_zod20.z.strictObject({
+var ExecJobStopParams = import_zod21.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_zod20.z.boolean().default(false)
+  force: import_zod21.z.boolean().default(false)
 });
-var ExecJobStopResult = import_zod20.z.strictObject({ job_id: ExecJobId, exited: import_zod20.z.boolean(), exit_code: import_zod20.z.int().nullable() });
-var ExecJobInfo = import_zod20.z.strictObject({
+var ExecJobStopResult = import_zod21.z.strictObject({ job_id: ExecJobId, exited: import_zod21.z.boolean(), exit_code: import_zod21.z.int().nullable() });
+var ExecJobInfo = import_zod21.z.strictObject({
   job_id: ExecJobId,
-  command: import_zod20.z.string().max(1024),
-  pid: import_zod20.z.int().min(1),
+  command: import_zod21.z.string().max(1024),
+  pid: import_zod21.z.int().min(1),
   cwd: AbsPath,
-  running: import_zod20.z.boolean(),
-  exit_code: import_zod20.z.int().nullable(),
+  running: import_zod21.z.boolean(),
+  exit_code: import_zod21.z.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = import_zod20.z.strictObject({});
-var ExecJobListResult = import_zod20.z.strictObject({ jobs: import_zod20.z.array(ExecJobInfo).max(64) });
+var ExecJobListParams = import_zod21.z.strictObject({});
+var ExecJobListResult = import_zod21.z.strictObject({ jobs: import_zod21.z.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-var import_zod21 = require("zod");
-var CodingServiceCredentials = import_zod21.z.strictObject({
-  access_token: import_zod21.z.string().min(16).max(16384),
-  user_id: import_zod21.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_zod22 = require("zod");
+var CodingServiceCredentials = import_zod22.z.strictObject({
+  access_token: import_zod22.z.string().min(16).max(16384),
+  user_id: import_zod22.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_zod21.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: import_zod22.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = import_zod21.z.enum([
+var CodingHistoryBlocked = import_zod22.z.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -1227,11 +1257,11 @@ var CodingHistoryBlocked = import_zod21.z.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = import_zod21.z.strictObject({
-  session_id: import_zod21.z.string().max(64),
-  reason: import_zod21.z.string().max(300)
+var CodingHistoryFailure = import_zod22.z.strictObject({
+  session_id: import_zod22.z.string().max(64),
+  reason: import_zod22.z.string().max(300)
 });
-var CodingHistoryRun = import_zod21.z.strictObject({
+var CodingHistoryRun = import_zod22.z.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -1246,39 +1276,39 @@ var CodingHistoryRun = import_zod21.z.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: import_zod21.z.array(CodingHistoryFailure).max(20),
+  failures: import_zod22.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_zod21.z.string().max(400)
+  summary: import_zod22.z.string().max(400)
 });
-var CodingHistoryStep = import_zod21.z.strictObject({
+var CodingHistoryStep = import_zod22.z.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: import_zod21.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: import_zod21.z.boolean(),
+  plan_id: import_zod22.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: import_zod22.z.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = import_zod21.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = import_zod21.z.strictObject({
-  plan_id: import_zod21.z.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = import_zod22.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = import_zod22.z.strictObject({
+  plan_id: import_zod22.z.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = import_zod21.z.strictObject({
-  phase: import_zod21.z.enum(["checking", "importing"]),
+var CodingServiceProgress = import_zod22.z.strictObject({
+  phase: import_zod22.z.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = import_zod21.z.strictObject({});
-var CodingHistoryImportMissingResult = import_zod21.z.strictObject({
-  state: import_zod21.z.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = import_zod22.z.strictObject({});
+var CodingHistoryImportMissingResult = import_zod22.z.strictObject({
+  state: import_zod22.z.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = import_zod21.z.strictObject({
+var CodingHistoryProgressEvent = import_zod22.z.strictObject({
   request_id: RequestId,
-  phase: import_zod21.z.enum(["checking", "importing"]),
+  phase: import_zod22.z.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -1287,22 +1317,22 @@ var CodingHistoryProgressEvent = import_zod21.z.strictObject({
 });
 
 // src/schema/apps.ts
-var import_zod22 = require("zod");
-var AppKey = import_zod22.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
-var AppProfileId = import_zod22.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 AppProfileLocator = import_zod22.z.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
-var AppSupport = import_zod22.z.enum(["supported", "partial", "unsupported"]);
-var AppFeatureStatus = import_zod22.z.strictObject({
+var import_zod23 = require("zod");
+var AppKey = import_zod23.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+var AppProfileId = import_zod23.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 AppProfileLocator = import_zod23.z.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
+var AppSupport = import_zod23.z.enum(["supported", "partial", "unsupported"]);
+var AppFeatureStatus = import_zod23.z.strictObject({
   status: AppSupport,
   /** One line, set whenever status is not "supported". */
-  reason: import_zod22.z.string().max(140).nullable()
+  reason: import_zod23.z.string().max(140).nullable()
 });
-var AppInfo = import_zod22.z.strictObject({
+var AppInfo = import_zod23.z.strictObject({
   app_key: AppKey,
-  name: import_zod22.z.string().max(64),
-  installed: import_zod22.z.boolean(),
+  name: import_zod23.z.string().max(64),
+  installed: import_zod23.z.boolean(),
   /** The app's own version string, or null when it is not installed or does not say. */
-  version: import_zod22.z.string().max(64).nullable(),
+  version: import_zod23.z.string().max(64).nullable(),
   /** The install found (an .app bundle, an .exe, a binary), or null. */
   location: AbsPath.nullable(),
   /** Open the app at all on this OS. */
@@ -1312,69 +1342,69 @@ var AppInfo = import_zod22.z.strictObject({
   /** Plan usage read from the app's own files on this OS. */
   usage: AppFeatureStatus
 });
-var AppUsageReading = import_zod22.z.strictObject({
-  window: import_zod22.z.enum(["five_hour", "weekly", "extra"]),
+var AppUsageReading = import_zod23.z.strictObject({
+  window: import_zod23.z.enum(["five_hour", "weekly", "extra"]),
   /** 0–100 for five_hour and weekly; extra-usage spend as a percent of its cap (may pass 100). */
-  percent: import_zod22.z.number().min(0).max(1e4),
+  percent: import_zod23.z.number().min(0).max(1e4),
   /** When the app recorded it. */
   sampled_at_ms: epochMs,
   /** True when the window has rolled over since the sample, so the figure has reset. */
-  reset_since: import_zod22.z.boolean()
+  reset_since: import_zod23.z.boolean()
 });
-var AppProfile = import_zod22.z.strictObject({
+var AppProfile = import_zod23.z.strictObject({
   /** The row's id; null for a folder found on disk that no row names yet. */
   id: AppProfileId.nullable(),
   app_key: AppKey,
-  display_name: import_zod22.z.string().min(1).max(120),
+  display_name: import_zod23.z.string().min(1).max(120),
   /** The account the person means to be signed in here; null when not stated (never guessed). */
-  account_identity: import_zod22.z.string().min(3).max(320).nullable(),
+  account_identity: import_zod23.z.string().min(3).max(320).nullable(),
   profile_locator: AppProfileLocator.nullable(),
   /** The device the row is tied to; null when the row names none. */
   device_id: DeviceId.nullable(),
   /** The folder this profile resolves to on this device; null for a row tied to another device. */
   folder: AbsPath.nullable(),
   /** The folder exists on this device. */
-  on_disk: import_zod22.z.boolean(),
+  on_disk: import_zod23.z.boolean(),
   /** An instance with this profile is running; null when it could not be determined. */
-  running: import_zod22.z.boolean().nullable(),
+  running: import_zod23.z.boolean().nullable(),
   /** Usage the app recorded for this profile; null when the app exposes none here. */
-  usage: import_zod22.z.array(AppUsageReading).nullable(),
+  usage: import_zod23.z.array(AppUsageReading).nullable(),
   last_opened_ms: epochMs.nullable()
 });
-var AppsListParams = import_zod22.z.strictObject({});
-var AppsListResult = import_zod22.z.strictObject({ apps: import_zod22.z.array(AppInfo) });
-var AppsProfilesListParams = import_zod22.z.strictObject({
+var AppsListParams = import_zod23.z.strictObject({});
+var AppsListResult = import_zod23.z.strictObject({ apps: import_zod23.z.array(AppInfo) });
+var AppsProfilesListParams = import_zod23.z.strictObject({
   /** Only this app's profiles; every app's when absent. */
   app_key: AppKey.optional()
 });
-var AppsProfilesListResult = import_zod22.z.strictObject({
-  profiles: import_zod22.z.array(AppProfile),
+var AppsProfilesListResult = import_zod23.z.strictObject({
+  profiles: import_zod23.z.array(AppProfile),
   /**
    * Whether the saved rows could be read: false while signed out or offline, when only folders
    * found on disk are listed.
    */
-  registry: import_zod22.z.enum(["ok", "signed_out", "unavailable"])
+  registry: import_zod23.z.enum(["ok", "signed_out", "unavailable"])
 });
-var AppsProfilesSaveParams = import_zod22.z.strictObject({
+var AppsProfilesSaveParams = import_zod23.z.strictObject({
   id: AppProfileId.optional(),
   app_key: AppKey,
-  display_name: import_zod22.z.string().min(1).max(120),
-  account_identity: import_zod22.z.string().min(3).max(320).nullable(),
+  display_name: import_zod23.z.string().min(1).max(120),
+  account_identity: import_zod23.z.string().min(3).max(320).nullable(),
   /** On create: the folder to use (one found on disk), or null for the app's default profile. Ignored on update. */
   profile_locator: AppProfileLocator.nullable(),
   /** On create with profile_locator null: make a new folder named after display_name instead. */
-  new_folder: import_zod22.z.boolean().default(false)
+  new_folder: import_zod23.z.boolean().default(false)
 });
 var AppsProfilesSaveResult = AppProfile;
-var AppsProfilesRemoveParams = import_zod22.z.strictObject({ id: AppProfileId });
-var AppsProfilesRemoveResult = import_zod22.z.strictObject({ removed: import_zod22.z.boolean() });
-var AppsOpenParams = import_zod22.z.strictObject({
+var AppsProfilesRemoveParams = import_zod23.z.strictObject({ id: AppProfileId });
+var AppsProfilesRemoveResult = import_zod23.z.strictObject({ removed: import_zod23.z.boolean() });
+var AppsOpenParams = import_zod23.z.strictObject({
   app_key: AppKey,
   profile_id: AppProfileId.optional()
 });
-var AppsOpenResult = import_zod22.z.strictObject({
+var AppsOpenResult = import_zod23.z.strictObject({
   /** True when an instance with this profile was already running; it is brought forward. */
-  already_running: import_zod22.z.boolean(),
+  already_running: import_zod23.z.boolean(),
   folder: AbsPath.nullable()
 });
 
@@ -1443,6 +1473,9 @@ 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"] },
+  "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"] },
   // 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"] }
 };