@ai-matrx/desktop-protocol 0.7.0 → 0.10.0

package/dist/index.cjs

@@ -21,15 +21,36 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AbsPath: () => AbsPath,
+  AppFeatureStatus: () => AppFeatureStatus,
+  AppInfo: () => AppInfo,
+  AppKey: () => AppKey,
+  AppProfile: () => AppProfile,
+  AppProfileId: () => AppProfileId,
+  AppProfileLocator: () => AppProfileLocator,
+  AppSupport: () => AppSupport,
+  AppUsageReading: () => AppUsageReading,
+  AppsListParams: () => AppsListParams,
+  AppsListResult: () => AppsListResult,
+  AppsOpenParams: () => AppsOpenParams,
+  AppsOpenResult: () => AppsOpenResult,
+  AppsProfilesListParams: () => AppsProfilesListParams,
+  AppsProfilesListResult: () => AppsProfilesListResult,
+  AppsProfilesRemoveParams: () => AppsProfilesRemoveParams,
+  AppsProfilesRemoveResult: () => AppsProfilesRemoveResult,
+  AppsProfilesSaveParams: () => AppsProfilesSaveParams,
+  AppsProfilesSaveResult: () => AppsProfilesSaveResult,
   BEARER_PREFIX: () => BEARER_PREFIX,
   BROADCAST_CID: () => BROADCAST_CID,
   CLOSE_RULES: () => CLOSE_RULES,
+  CONTRACT_SHA256: () => CONTRACT_SHA256,
   CancelMsg: () => CancelMsg,
   ClientToCoreMsg: () => ClientToCoreMsg,
   ClientType: () => ClientType,
   CloseCode: () => CloseCode,
   CloseCodeValue: () => CloseCodeValue,
+  ContractHash: () => ContractHash,
   CoreToClientMsg: () => CoreToClientMsg,
+  CoreToServiceMsg: () => CoreToServiceMsg,
   CreditMsg: () => CreditMsg,
   DEFAULT_MAX_FRAME_PAYLOAD_BYTES: () => DEFAULT_MAX_FRAME_PAYLOAD_BYTES,
   DEFAULT_MAX_MESSAGE_BYTES: () => DEFAULT_MAX_MESSAGE_BYTES,
@@ -99,7 +120,24 @@ __export(src_exports, {
   FsWriteParams: () => FsWriteParams,
   FsWriteResult: () => FsWriteResult,
   HelloMsg: () => HelloMsg,
+  LEGACY_ACTIONS: () => LEGACY_ACTIONS,
+  LEGACY_DISPATCHERS: () => LEGACY_DISPATCHERS,
   Limits: () => Limits,
+  MlInstallPhase: () => MlInstallPhase,
+  MlInstallProgress: () => MlInstallProgress,
+  MlProgress: () => MlProgress,
+  MlRuntimeState: () => MlRuntimeState,
+  MlServiceState: () => MlServiceState,
+  MlServiceStatus: () => MlServiceStatus,
+  MlStatusParams: () => MlStatusParams,
+  MlStatusResult: () => MlStatusResult,
+  ModelsInstallParams: () => ModelsInstallParams,
+  ModelsInstallResult: () => ModelsInstallResult,
+  ModelsProgressEvent: () => ModelsProgressEvent,
+  ModelsStatusParams: () => ModelsStatusParams,
+  ModelsStatusResult: () => ModelsStatusResult,
+  ModelsTranscribeParams: () => ModelsTranscribeParams,
+  ModelsTranscribeResult: () => ModelsTranscribeResult,
   NAMED_SCHEMAS: () => NAMED_SCHEMAS,
   NULL_SINCE: () => NULL_SINCE,
   OPS: () => OPS,
@@ -113,6 +151,7 @@ __export(src_exports, {
   ProtocolErrorBody: () => ProtocolErrorBody,
   ProtocolVersion: () => ProtocolVersion,
   PtyInfo: () => PtyInfo,
+  REASONS_SINCE: () => REASONS_SINCE,
   RELAY_CALL_HELLO_ID: () => RELAY_CALL_HELLO_ID,
   RELAY_CALL_REQUEST_ID: () => RELAY_CALL_REQUEST_ID,
   RELAY_CALL_VERSION_HEADER: () => RELAY_CALL_VERSION_HEADER,
@@ -131,7 +170,22 @@ __export(src_exports, {
   ResourceId: () => ResourceId,
   ResourceInfo: () => ResourceInfo,
   ResponseMsg: () => ResponseMsg,
+  SERVICES: () => SERVICES,
+  SERVICE_MAX_FRAME_BYTES: () => SERVICE_MAX_FRAME_BYTES,
   SUBPROTOCOL: () => SUBPROTOCOL,
+  ServiceCancel: () => ServiceCancel,
+  ServiceErrorMsg: () => ServiceErrorMsg,
+  ServiceHello: () => ServiceHello,
+  ServiceName: () => ServiceName,
+  ServicePing: () => ServicePing,
+  ServicePong: () => ServicePong,
+  ServiceProgressMsg: () => ServiceProgressMsg,
+  ServiceRequest: () => ServiceRequest,
+  ServiceResponse: () => ServiceResponse,
+  ServiceShutdown: () => ServiceShutdown,
+  ServiceToCoreMsg: () => ServiceToCoreMsg,
+  ServiceToken: () => ServiceToken,
+  ServiceWelcome: () => ServiceWelcome,
   SessionAttachParams: () => SessionAttachParams,
   SessionAttachResult: () => SessionAttachResult,
   SessionControlChangedEvent: () => SessionControlChangedEvent,
@@ -146,10 +200,26 @@ __export(src_exports, {
   StreamMsg: () => StreamMsg,
   SysinfoGetParams: () => SysinfoGetParams,
   SysinfoGetResult: () => SysinfoGetResult,
+  TOOL_CATALOG: () => TOOL_CATALOG,
+  TOOL_GROUPS: () => TOOL_GROUPS,
+  TOOL_LEVELS: () => TOOL_LEVELS,
+  TOOL_PLATFORMS: () => TOOL_PLATFORMS,
+  ToolLevel: () => ToolLevel,
+  ToolLevelResult: () => ToolLevelResult,
+  ToolName: () => ToolName,
+  ToolOutcome: () => ToolOutcome,
+  ToolPlatform: () => ToolPlatform,
+  ToolResultsFile: () => ToolResultsFile,
+  ToolTransport: () => ToolTransport,
+  TranscriptSegment: () => TranscriptSegment,
+  TranscriptionModelId: () => TranscriptionModelId,
+  TranscriptionModelInfo: () => TranscriptionModelInfo,
   VERSIONED_RESULT_OPS: () => VERSIONED_RESULT_OPS,
   Welcome: () => Welcome,
   announcedVersion: () => announcedVersion,
   assertFrameHeader: () => assertFrameHeader,
+  buildToolStatus: () => buildToolStatus,
+  builtOps: () => builtOps,
   closeRule: () => closeRule,
   compareVersions: () => compareVersions,
   connectionEndFrame: () => connectionEndFrame,
@@ -165,6 +235,7 @@ __export(src_exports, {
   negotiate: () => negotiate,
   nonNegInt: () => nonNegInt,
   readCid: () => readCid,
+  renderToolStatusMarkdown: () => renderToolStatusMarkdown,
   stampCid: () => stampCid,
   statusForPeer: () => statusForPeer,
   u32: () => u32,
@@ -175,7 +246,7 @@ module.exports = __toCommonJS(src_exports);
 // src/schema/primitives.ts
 var import_zod = require("zod");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 1;
+var PROTOCOL_MINOR = 2;
 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_-]+$/);
@@ -234,7 +305,22 @@ var ErrorReason = import_zod2.z.enum([
   "resource_expired",
   "control_taken",
   // another client of the same user took control
-  "window_exhausted"
+  "window_exhausted",
+  // 1.2 (REASONS_SINCE): the `models` capability and its supervised Python service
+  "runtime_not_installed",
+  // NOT_FOUND: install the inference runtime first (models.install)
+  "model_not_installed",
+  // NOT_FOUND: that model's weights are not on the device
+  "unsupported_media",
+  // INVALID_PARAMS: the file is not audio or video the decoder reads
+  "download_failed",
+  // install could not fetch a package or model file
+  "service_starting",
+  // RESOURCE_BUSY (retryable): the service is starting or restarting
+  "service_restarted",
+  // RESOURCE_GONE: the service died while this request ran
+  "service_failed"
+  // INTERNAL: the service could not be started (see models.status)
 ]);
 var FsPatchEditFailure = import_zod2.z.strictObject({ edit_index: nonNegInt, reason: import_zod2.z.string().max(300) });
 var ProtocolErrorBody = import_zod2.z.strictObject({
@@ -860,6 +946,254 @@ var RelayCallEnvelope = import_zod9.z.strictObject({
 });
 var RelayStatusResponse = RelayDeviceStatusEvent;
 
+// src/schema/models.ts
+var import_zod10 = require("zod");
+var TranscriptionModelId = import_zod10.z.enum(["tiny", "base", "small", "large-v3-turbo"]);
+var MlRuntimeState = import_zod10.z.enum(["not_installed", "installing", "installed", "failed"]);
+var MlInstallPhase = import_zod10.z.enum(["packages", "model", "verifying"]);
+var MlInstallProgress = import_zod10.z.strictObject({
+  phase: MlInstallPhase,
+  /** What is being fetched now: a package or a model file name. */
+  item: import_zod10.z.string().max(200),
+  bytes_done: nonNegInt,
+  /** Null while the total is not known yet. */
+  bytes_total: nonNegInt.nullable()
+});
+var TranscriptionModelInfo = import_zod10.z.strictObject({
+  id: TranscriptionModelId,
+  /** Download size of the weights. */
+  size_bytes: nonNegInt,
+  multilingual: import_zod10.z.boolean(),
+  installed: import_zod10.z.boolean()
+});
+var TranscriptSegment = import_zod10.z.strictObject({
+  start_s: import_zod10.z.number().min(0),
+  end_s: import_zod10.z.number().min(0),
+  text: import_zod10.z.string().max(4e3)
+});
+var MlStatusParams = import_zod10.z.strictObject({});
+var MlStatusResult = import_zod10.z.strictObject({
+  runtime: MlRuntimeState,
+  /** Non-null while runtime or model files are being installed. */
+  install: MlInstallProgress.nullable(),
+  /** The last install failure, one human line; null when the last install succeeded or none ran. */
+  error: import_zod10.z.string().max(300).nullable(),
+  /** Where inference runs once the runtime is installed: `cuda` only when a usable GPU is present. */
+  accelerator: import_zod10.z.enum(["cpu", "cuda"]),
+  models: import_zod10.z.array(TranscriptionModelInfo).max(16),
+  default_model: TranscriptionModelId
+});
+var ModelsInstallParams = import_zod10.z.strictObject({ model: TranscriptionModelId.optional() });
+var ModelsInstallResult = import_zod10.z.strictObject({ model: TranscriptionModelId, elapsed_ms: nonNegInt });
+var ModelsTranscribeParams = import_zod10.z.strictObject({
+  path: AbsPath,
+  model: TranscriptionModelId.optional(),
+  language: import_zod10.z.string().regex(/^[a-z]{2,3}$/).optional(),
+  task: import_zod10.z.enum(["transcribe", "translate"]).default("transcribe")
+});
+var ModelsTranscribeResult = import_zod10.z.strictObject({
+  text: import_zod10.z.string().max(4e5),
+  language: import_zod10.z.string().max(8),
+  language_probability: import_zod10.z.number().min(0).max(1),
+  duration_s: import_zod10.z.number().min(0),
+  model: TranscriptionModelId,
+  segments: import_zod10.z.array(TranscriptSegment).max(2e4),
+  elapsed_ms: nonNegInt
+});
+var MlProgress = import_zod10.z.strictObject({
+  kind: import_zod10.z.enum(["install", "transcribe"]),
+  /** 0–1 when known (transcribe: audio covered so far; install: bytes so far). */
+  fraction: import_zod10.z.number().min(0).max(1).nullable(),
+  install: MlInstallProgress.nullable(),
+  /** The segment just transcribed (transcribe only): text appears as it is recognised. */
+  segment: TranscriptSegment.nullable()
+});
+var MlServiceState = import_zod10.z.enum(["starting", "ready", "restarting", "failed", "stopped"]);
+var MlServiceStatus = import_zod10.z.strictObject({
+  state: MlServiceState,
+  pid: nonNegInt.nullable(),
+  /** Restarts since the app started (crashes, missed health checks). */
+  restarts: nonNegInt,
+  /** The bundled interpreter's version once the service has answered, e.g. "3.13.15". */
+  python: import_zod10.z.string().max(32).nullable(),
+  /** Why the service is restarting or failed, one human line. */
+  error: import_zod10.z.string().max(300).nullable()
+});
+var ModelsStatusParams = import_zod10.z.strictObject({});
+var ModelsStatusResult = import_zod10.z.strictObject({
+  service: MlServiceStatus,
+  /** Null until the service has answered (starting, restarting, failed). */
+  transcription: MlStatusResult.nullable()
+});
+var ModelsProgressEvent = import_zod10.z.strictObject({ request_id: RequestId, progress: MlProgress });
+
+// src/schema/apps.ts
+var import_zod11 = require("zod");
+var AppKey = import_zod11.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+var AppProfileId = import_zod11.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_zod11.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_zod11.z.enum(["supported", "partial", "unsupported"]);
+var AppFeatureStatus = import_zod11.z.strictObject({
+  status: AppSupport,
+  /** One line, set whenever status is not "supported". */
+  reason: import_zod11.z.string().max(140).nullable()
+});
+var AppInfo = import_zod11.z.strictObject({
+  app_key: AppKey,
+  name: import_zod11.z.string().max(64),
+  installed: import_zod11.z.boolean(),
+  /** The app's own version string, or null when it is not installed or does not say. */
+  version: import_zod11.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. */
+  open: AppFeatureStatus,
+  /** Separate profiles (one account each) on this OS. */
+  profiles: AppFeatureStatus,
+  /** Plan usage read from the app's own files on this OS. */
+  usage: AppFeatureStatus
+});
+var AppUsageReading = import_zod11.z.strictObject({
+  window: import_zod11.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_zod11.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_zod11.z.boolean()
+});
+var AppProfile = import_zod11.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_zod11.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_zod11.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_zod11.z.boolean(),
+  /** An instance with this profile is running; null when it could not be determined. */
+  running: import_zod11.z.boolean().nullable(),
+  /** Usage the app recorded for this profile; null when the app exposes none here. */
+  usage: import_zod11.z.array(AppUsageReading).nullable(),
+  last_opened_ms: epochMs.nullable()
+});
+var AppsListParams = import_zod11.z.strictObject({});
+var AppsListResult = import_zod11.z.strictObject({ apps: import_zod11.z.array(AppInfo) });
+var AppsProfilesListParams = import_zod11.z.strictObject({
+  /** Only this app's profiles; every app's when absent. */
+  app_key: AppKey.optional()
+});
+var AppsProfilesListResult = import_zod11.z.strictObject({
+  profiles: import_zod11.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_zod11.z.enum(["ok", "signed_out", "unavailable"])
+});
+var AppsProfilesSaveParams = import_zod11.z.strictObject({
+  id: AppProfileId.optional(),
+  app_key: AppKey,
+  display_name: import_zod11.z.string().min(1).max(120),
+  account_identity: import_zod11.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_zod11.z.boolean().default(false)
+});
+var AppsProfilesSaveResult = AppProfile;
+var AppsProfilesRemoveParams = import_zod11.z.strictObject({ id: AppProfileId });
+var AppsProfilesRemoveResult = import_zod11.z.strictObject({ removed: import_zod11.z.boolean() });
+var AppsOpenParams = import_zod11.z.strictObject({
+  app_key: AppKey,
+  profile_id: AppProfileId.optional()
+});
+var AppsOpenResult = import_zod11.z.strictObject({
+  /** True when an instance with this profile was already running; it is brought forward. */
+  already_running: import_zod11.z.boolean(),
+  folder: AbsPath.nullable()
+});
+
+// src/schema/service.ts
+var import_zod12 = require("zod");
+var SERVICE_MAX_FRAME_BYTES = 16777216;
+var ServiceName = import_zod12.z.enum(["ml"]);
+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;
+var ServiceHello = import_zod12.z.strictObject({ type: import_zod12.z.literal("hello"), token: ServiceToken, contract: ContractHash });
+var ServiceWelcome = import_zod12.z.strictObject({
+  type: import_zod12.z.literal("welcome"),
+  service: ServiceName,
+  contract: ContractHash,
+  pid: nonNegInt,
+  /** The interpreter's version, e.g. "3.13.15". */
+  python: import_zod12.z.string().max(32),
+  /** Every op this service serves; must equal SERVICES[service] exactly. */
+  ops: import_zod12.z.array(import_zod12.z.string().min(1).max(64)).max(64)
+});
+var ServiceRequest = import_zod12.z.strictObject({
+  type: import_zod12.z.literal("request"),
+  id: ServiceRequestId,
+  op: import_zod12.z.string().min(1).max(64),
+  params: import_zod12.z.unknown()
+  // validated by the service against SERVICES[service][op].params
+});
+var ServiceResponse = import_zod12.z.strictObject({
+  type: import_zod12.z.literal("response"),
+  id: ServiceRequestId,
+  result: import_zod12.z.unknown()
+  // validated by the core against SERVICES[service][op].result
+});
+var ServiceErrorMsg = import_zod12.z.strictObject({ type: import_zod12.z.literal("error"), id: ServiceRequestId, error: ProtocolErrorBody });
+var ServiceProgressMsg = import_zod12.z.strictObject({ type: import_zod12.z.literal("progress"), id: ServiceRequestId, progress: import_zod12.z.unknown() });
+var ServiceCancel = import_zod12.z.strictObject({ type: import_zod12.z.literal("cancel"), id: ServiceRequestId });
+var ServicePing = import_zod12.z.strictObject({ type: import_zod12.z.literal("ping"), id: ServiceRequestId });
+var ServicePong = import_zod12.z.strictObject({
+  type: import_zod12.z.literal("pong"),
+  id: ServiceRequestId,
+  /** Requests running now. */
+  busy: nonNegInt
+});
+var ServiceShutdown = import_zod12.z.strictObject({ type: import_zod12.z.literal("shutdown") });
+var CoreToServiceMsg = import_zod12.z.discriminatedUnion("type", [ServiceHello, ServiceRequest, ServiceCancel, ServicePing, ServiceShutdown]);
+var ServiceToCoreMsg = import_zod12.z.discriminatedUnion("type", [ServiceWelcome, ServiceResponse, ServiceErrorMsg, ServiceProgressMsg, ServicePong]);
+
+// src/schema/tools.ts
+var import_zod13 = require("zod");
+var ToolLevel = import_zod13.z.enum(["programmatic", "protocol", "chat"]);
+var ToolOutcome = import_zod13.z.enum(["pass", "fail", "skip"]);
+var ToolPlatform = import_zod13.z.enum(["darwin", "win32", "linux"]);
+var ToolTransport = import_zod13.z.enum(["in_process", "localhost", "relay", "agent"]);
+var ToolName = import_zod13.z.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/);
+var ToolLevelResult = import_zod13.z.strictObject({
+  tool: ToolName,
+  level: ToolLevel,
+  platform: ToolPlatform,
+  transport: ToolTransport,
+  outcome: ToolOutcome,
+  /** True when the caller sat on a different network from the device (a phone on cellular, CI). */
+  remote_network: import_zod13.z.boolean(),
+  /** One line: what was asserted, or why it failed. Never a token, a file's contents or a path under a real home. */
+  detail: import_zod13.z.string().max(500),
+  /** The harness that produced it, e.g. `matrx-desktop test/tools/programmatic.test.ts`. */
+  suite: import_zod13.z.string().min(1).max(200),
+  /** The test case inside the suite. */
+  test: import_zod13.z.string().min(1).max(300),
+  run_at_ms: import_zod13.z.int().min(0)
+});
+var ToolResultsFile = import_zod13.z.strictObject({
+  schema: import_zod13.z.literal("matrx.tool-results.v1"),
+  /** The producing repo's commit (short or full SHA). */
+  commit: import_zod13.z.string().min(4).max(64),
+  results: import_zod13.z.array(ToolLevelResult).max(1e4)
+});
+
 // src/schema/registry.ts
 var FS_ERR = ["NOT_FOUND", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "RESOURCE_BUSY", "INTERNAL"];
 var OPS = {
@@ -886,7 +1220,17 @@ var OPS = {
   "session.attach": { params: SessionAttachParams, result: SessionAttachResult, kind: "stream", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN", "RESOURCE_BUSY"] },
   "session.detach": { params: SessionDetachParams, result: SessionDetachResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE"] },
   "session.release": { params: SessionReleaseParams, result: SessionReleaseResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN"] },
-  "session.list": { params: SessionListParams, result: SessionListResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] }
+  "session.list": { params: SessionListParams, result: SessionListResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] },
+  // Local models (SPEC §6), served by the `ml` Python service through SERVICES below.
+  "models.status": { params: ModelsStatusParams, result: ModelsStatusResult, kind: "unary", since: "1.2", errors: ["INTERNAL"] },
+  "models.install": { params: ModelsInstallParams, result: ModelsInstallResult, kind: "unary", since: "1.2", errors: ["RESOURCE_BUSY", "RESOURCE_GONE", "TIMEOUT", "CANCELLED", "INTERNAL"] },
+  "models.transcribe": { params: ModelsTranscribeParams, result: ModelsTranscribeResult, kind: "unary", since: "1.2", errors: ["NOT_FOUND", "INVALID_PARAMS", "PERMISSION_DENIED_OS", "RESOURCE_BUSY", "RESOURCE_GONE", "CANCELLED", "PAYLOAD_TOO_LARGE", "INTERNAL"] },
+  // Desktop apps and their profiles (SPEC §6 apps); profiles are rows in users.desktop_app_profile.
+  "apps.list": { params: AppsListParams, result: AppsListResult, kind: "unary", since: "1.2", errors: ["INTERNAL"] },
+  "apps.profiles.list": { params: AppsProfilesListParams, result: AppsProfilesListResult, kind: "unary", since: "1.2", errors: ["NOT_FOUND", "INVALID_PARAMS", "INTERNAL"] },
+  "apps.profiles.save": { params: AppsProfilesSaveParams, result: AppsProfilesSaveResult, kind: "unary", since: "1.2", errors: ["AUTH_REQUIRED", "AUTH_FORBIDDEN", "NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "DEVICE_OFFLINE", "INTERNAL"] },
+  "apps.profiles.remove": { params: AppsProfilesRemoveParams, result: AppsProfilesRemoveResult, kind: "unary", since: "1.2", errors: ["AUTH_REQUIRED", "AUTH_FORBIDDEN", "NOT_FOUND", "DEVICE_OFFLINE", "INTERNAL"] },
+  "apps.open": { params: AppsOpenParams, result: AppsOpenResult, kind: "unary", since: "1.2", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "AUTH_REQUIRED", "DEVICE_OFFLINE", "INTERNAL"] }
 };
 var EVENTS = {
   "fs.changed": FsChangedEvent,
@@ -894,9 +1238,20 @@ var EVENTS = {
   "exec.title": ExecTitleEvent,
   "exec.cwd": ExecCwdEvent,
   "session.control_changed": SessionControlChangedEvent,
+  "models.progress": ModelsProgressEvent,
   "relay.device_status": RelayDeviceStatusEvent,
   "relay.auth_expiring": RelayAuthExpiringEvent
 };
+var SERVICES = {
+  ml: {
+    progress: MlProgress,
+    ops: {
+      "ml.status": { params: MlStatusParams, result: MlStatusResult },
+      "ml.install": { params: ModelsInstallParams, result: ModelsInstallResult },
+      "ml.transcribe": { params: ModelsTranscribeParams, result: ModelsTranscribeResult }
+    }
+  }
+};
 var NAMED_SCHEMAS = {
   ProtocolVersion,
   RequestId,
@@ -985,6 +1340,39 @@ var NAMED_SCHEMAS = {
   SessionListParams,
   SessionListResult,
   SessionControlChangedEvent,
+  TranscriptionModelId,
+  MlRuntimeState,
+  MlInstallPhase,
+  MlInstallProgress,
+  TranscriptionModelInfo,
+  TranscriptSegment,
+  MlStatusParams,
+  MlStatusResult,
+  ModelsInstallParams,
+  ModelsInstallResult,
+  ModelsTranscribeParams,
+  ModelsTranscribeResult,
+  MlProgress,
+  MlServiceState,
+  MlServiceStatus,
+  ModelsStatusParams,
+  ModelsStatusResult,
+  ModelsProgressEvent,
+  ServiceName,
+  ContractHash,
+  ServiceToken,
+  ServiceHello,
+  ServiceWelcome,
+  ServiceRequest,
+  ServiceResponse,
+  ServiceErrorMsg,
+  ServiceProgressMsg,
+  ServiceCancel,
+  ServicePing,
+  ServicePong,
+  ServiceShutdown,
+  CoreToServiceMsg,
+  ServiceToCoreMsg,
   RelayDeviceStatusEvent,
   RelayAuthExpiringEvent,
   RelayCallRequest,
@@ -993,7 +1381,31 @@ var NAMED_SCHEMAS = {
   RelayCallEnvelope,
   RelayHopEnvelopeHeader,
   RelayHopConnectionEnd,
-  CloseCodeValue
+  CloseCodeValue,
+  ToolLevel,
+  ToolOutcome,
+  ToolPlatform,
+  ToolTransport,
+  ToolName,
+  ToolLevelResult,
+  ToolResultsFile,
+  AppKey,
+  AppProfileId,
+  AppProfileLocator,
+  AppSupport,
+  AppFeatureStatus,
+  AppInfo,
+  AppUsageReading,
+  AppProfile,
+  AppsListParams,
+  AppsListResult,
+  AppsProfilesListParams,
+  AppsProfilesListResult,
+  AppsProfilesSaveParams,
+  AppsProfilesRemoveParams,
+  AppsProfilesRemoveResult,
+  AppsOpenParams,
+  AppsOpenResult
 };
 
 // src/versioning.ts
@@ -1006,6 +1418,15 @@ var FIELDS_SINCE = {
 var NULL_SINCE = {
   "RelayDeviceStatusEvent.since_ms": { since: "1.1", olderPeersGet: 0 }
 };
+var REASONS_SINCE = {
+  runtime_not_installed: "1.2",
+  model_not_installed: "1.2",
+  unsupported_media: "1.2",
+  download_failed: "1.2",
+  service_starting: "1.2",
+  service_restarted: "1.2",
+  service_failed: "1.2"
+};
 function statusForPeer(status, version) {
   const rule = NULL_SINCE["RelayDeviceStatusEvent.since_ms"];
   return status.since_ms === null && !knows(version, rule.since) ? { ...status, since_ms: rule.olderPeersGet } : status;
@@ -1054,11 +1475,20 @@ function forPeer(op, part, value, version) {
   if (value === null || typeof value !== "object") return value;
   const body = value;
   if (body.data === void 0) return value;
-  const data = strip(body.data, FIELDS_SINCE["ProtocolErrorBody.data"], version);
+  let data = strip(body.data, FIELDS_SINCE["ProtocolErrorBody.data"], version);
+  const reason = data.reason;
+  const reasonSince = typeof reason === "string" ? REASONS_SINCE[reason] : void 0;
+  if (reasonSince && !knows(version, reasonSince)) {
+    const { reason: _dropped, ...rest } = data;
+    data = rest;
+  }
   return data === body.data ? value : { ...body, data };
 }
 var VERSIONED_RESULT_OPS = [...RESULT_PATH.keys()];
 
+// src/contract.ts
+var CONTRACT_SHA256 = "ef9fd8c8ab611bf450730452a6cf48a4ebd566218b6e17e2834ef030fc2044cb";
+
 // src/close-policy.ts
 var CLOSE_RULES = {
   [CloseCode.NORMAL]: { action: "reconnect", error: ["DEVICE_OFFLINE", "Connection closed"] },
@@ -1084,4 +1514,316 @@ function closeRule(code) {
 function isTerminalClose(code) {
   return closeRule(code).action === "stop";
 }
+
+// src/tools/catalog.ts
+var TOOL_GROUPS = [
+  { id: "files_shell", order: 1, title: "Files and shell", owner: "core" },
+  { id: "os_control", order: 2, title: "Computer control", owner: "core" },
+  { id: "personal_automation", order: 3, title: "Personal apps and automation", owner: "core" },
+  { id: "tools_service", order: 4, title: "Documents, OCR and entities", owner: "python_tools" },
+  { id: "ml_service", order: 5, title: "Speech", owner: "python_ml" },
+  { id: "windows_admin", order: 6, title: "Windows administration", owner: "core" }
+];
+var ALL = ["darwin", "win32", "linux"];
+var TOOL_CATALOG = [
+  // ── 1. Files and shell (core `fs`, `exec`; the cloud sandbox's agent tools) ──────────────────
+  { name: "fs_read", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.read"], platforms: ALL, summary: "Read a file, paged" },
+  { name: "fs_write", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.read", "fs.write"], platforms: ALL, summary: "Create or overwrite a file" },
+  { name: "fs_edit", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.read", "fs.patch"], platforms: ALL, summary: "Replace one exact string" },
+  { name: "fs_patch", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.read", "fs.patch"], platforms: ALL, summary: "Apply several exact edits at once" },
+  { name: "fs_list", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.list"], platforms: ALL, summary: "List a folder" },
+  { name: "fs_mkdir", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.mkdir"], platforms: ALL, summary: "Create a folder" },
+  { 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 in a folder" },
+  { name: "shell_python", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["exec.run"], platforms: ALL, summary: "Run a Python script" },
+  {
+    name: "git_ingest",
+    group: "files_shell",
+    state: "broken",
+    path: "server",
+    ops: [],
+    platforms: ALL,
+    summary: "Digest a repository",
+    note: "Armed with the files tools, but a local path is read on the server, not the bound device"
+  },
+  { 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" },
+  // ── 2. Computer control (TS owners) ──────────────────────────────────────────────────────────
+  { name: "desktop_process", group: "os_control", state: "planned", path: "device_op", ops: ["proc.list", "proc.ports", "proc.kill", "proc.launch_app", "proc.focus_app", "proc.installed_apps"], platforms: ALL, summary: "Processes, ports and apps" },
+  { 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_clipboard", group: "os_control", state: "planned", path: "device_op", ops: ["clipboard.read", "clipboard.write"], platforms: ALL, summary: "Read and write the clipboard" },
+  { 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_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" },
+  // ── 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" },
+  { name: "desktop_messages", group: "personal_automation", state: "planned", path: "device_op", ops: ["messages.conversations", "messages.list", "messages.send"], platforms: ["darwin"], summary: "The Messages app" },
+  { name: "desktop_contacts", group: "personal_automation", state: "planned", path: "device_op", ops: ["contacts.search", "contacts.get"], platforms: ["darwin"], summary: "Contacts" },
+  { name: "desktop_calendar", group: "personal_automation", state: "planned", path: "device_op", ops: ["calendar.list", "calendar.create", "reminders.list", "reminders.create"], platforms: ["darwin"], summary: "Calendar and reminders" },
+  { name: "desktop_photos", group: "personal_automation", state: "planned", path: "device_op", ops: ["photos.search", "photos.get"], platforms: ["darwin"], summary: "Photos library" },
+  { name: "desktop_location", group: "personal_automation", state: "planned", path: "device_op", ops: ["location.get"], platforms: ["darwin", "win32"], summary: "Where the computer is" },
+  { name: "desktop_net", group: "personal_automation", state: "planned", path: "device_op", ops: ["net.info", "net.wifi", "net.bluetooth", "net.devices", "net.mdns", "net.scan", "net.download"], platforms: ALL, summary: "Local network and downloads" },
+  // ── 4. Python `tools` service ────────────────────────────────────────────────────────────────
+  { name: "desktop_documents", group: "tools_service", state: "planned", path: "device_op", ops: ["tools.pdf_extract", "tools.office_generate", "tools.ocr", "tools.image_resize"], platforms: ALL, summary: "PDF text, Office files, OCR, images" },
+  { name: "desktop_entities", group: "tools_service", state: "planned", path: "device_op", ops: ["tools.ner", "tools.pii"], platforms: ALL, summary: "Names and private data, found on the device" },
+  // ── 5. Python `ml` service ───────────────────────────────────────────────────────────────────
+  { name: "desktop_transcribe", group: "ml_service", state: "planned", path: "device_op", ops: ["models.transcribe", "models.speech_locales"], platforms: ALL, summary: "Speech to text on the device" },
+  // ── 6. Windows administration ────────────────────────────────────────────────────────────────
+  { name: "desktop_windows_admin", group: "windows_admin", state: "planned", path: "device_op", ops: ["windows.registry_read", "windows.registry_write", "windows.services", "windows.service_control", "windows.event_log", "windows.features"], platforms: ["win32"], summary: "Registry, services, event log" }
+];
+var tool = (name) => ({ kind: "tool", tool: name });
+var dropped = (reason) => ({ kind: "dropped", reason });
+var SHELL_COVERS = "Done with shell_execute (mv, cp, rm, tar), as every coding agent does";
+var CLOUD_SCRAPER = "The cloud scraper and research tools run with this computer as their network (the `proxy` capability)";
+var LEGACY_ACTIONS = {
+  "local_file.read": tool("fs_read"),
+  "local_file.write": tool("fs_write"),
+  "local_file.edit": tool("fs_edit"),
+  "local_file.move": dropped(SHELL_COVERS),
+  "local_file.copy": dropped(SHELL_COVERS),
+  "local_file.delete": dropped(SHELL_COVERS),
+  "local_file.rename": dropped(SHELL_COVERS),
+  "local_file.mkdir": tool("fs_mkdir"),
+  "local_file.glob": tool("fs_search"),
+  "local_file.grep": tool("fs_search"),
+  "local_file.list": tool("fs_list"),
+  "local_file.places": dropped("The device's home and folders reach the agent in its binding briefing (sysinfo.get)"),
+  "local_file.find": tool("fs_search"),
+  "local_file.semantic_find": dropped("Needs a local embedding index; returns with file sync's index, not before"),
+  "local_shell.run": tool("shell_execute"),
+  "local_shell.output": tool("shell_job"),
+  "local_shell.stop": tool("shell_job"),
+  "local_window.list": tool("desktop_window"),
+  "local_window.focus": tool("desktop_window"),
+  "local_window.move": tool("desktop_window"),
+  "local_window.minimize": tool("desktop_window"),
+  "local_process.list": tool("desktop_process"),
+  "local_process.ports": tool("desktop_process"),
+  "local_process.launch_app": tool("desktop_process"),
+  "local_process.kill": tool("desktop_process"),
+  "local_process.focus_app": tool("desktop_process"),
+  "local_process.terminals": dropped("Matrx 2 terminals are exec sessions; the person's own terminal windows are not the agent's"),
+  "local_process.tail_terminal": dropped("Matrx 2 terminals are exec sessions; the person's own terminal windows are not the agent's"),
+  "local_process.installed_apps": tool("desktop_process"),
+  "local_input.type_text": tool("desktop_input"),
+  "local_input.hotkey": tool("desktop_input"),
+  "local_input.mouse_click": tool("desktop_input"),
+  "local_input.mouse_move": tool("desktop_input"),
+  "local_audio.devices": tool("desktop_audio"),
+  "local_audio.record": tool("desktop_audio"),
+  "local_audio.play": tool("desktop_audio"),
+  "local_audio.transcribe": tool("desktop_transcribe"),
+  "local_audio.transcribe_with_speech": tool("desktop_transcribe"),
+  "local_audio.speech_locales": tool("desktop_transcribe"),
+  "local_clipboard.read": tool("desktop_clipboard"),
+  "local_clipboard.write": tool("desktop_clipboard"),
+  "local_screen.screenshot": tool("desktop_screen"),
+  "local_screen.list": tool("desktop_screen"),
+  "local_screen.capture_book": dropped("A one-off loop of screenshot plus page turn; the agent composes it from desktop_screen and desktop_input"),
+  "local_system.info": tool("desktop_system"),
+  "local_system.open_url": tool("desktop_system"),
+  "local_system.open_path": tool("desktop_system"),
+  "local_system.notify": tool("desktop_system"),
+  "local_browser.navigate": dropped("The browser agent is the extension (matrx-extend) and the cloud browser; a second Playwright on the device duplicates it"),
+  "local_browser.click": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
+  "local_browser.type_text": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
+  "local_browser.extract": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
+  "local_browser.screenshot": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
+  "local_browser.eval": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
+  "local_browser.tabs": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
+  "local_browser.close": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
+  "local_web.fetch": dropped(CLOUD_SCRAPER),
+  "local_web.fetch_with_browser": dropped(CLOUD_SCRAPER),
+  "local_web.scrape": dropped(CLOUD_SCRAPER),
+  "local_web.search": dropped(CLOUD_SCRAPER),
+  "local_web.research": dropped(CLOUD_SCRAPER),
+  "local_web.download": tool("desktop_net"),
+  "local_web.upload": dropped("Uploads are cloud files (matrx-files) and file sync, one upload path"),
+  "local_net.info": tool("desktop_net"),
+  "local_net.scan": tool("desktop_net"),
+  "local_net.port_scan": tool("desktop_net"),
+  "local_net.mdns_discover": tool("desktop_net"),
+  "local_net.wifi_networks": tool("desktop_net"),
+  "local_net.bluetooth_devices": tool("desktop_net"),
+  "local_net.connected_devices": tool("desktop_net"),
+  "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.watch_directory": tool("fs_watch"),
+  "local_monitor.watch_events": tool("fs_watch"),
+  "local_monitor.stop_watch": tool("fs_watch"),
+  "local_monitor.heartbeat": dropped("The relay's device status replaces the heartbeat"),
+  "local_schedule.create": dropped("One scheduler: the platform's runs the agent on time and reaches the device through the relay"),
+  "local_schedule.list": dropped("One scheduler: the platform's runs the agent on time and reaches the device through the relay"),
+  "local_schedule.cancel": dropped("One scheduler: the platform's runs the agent on time and reaches the device through the relay"),
+  "local_schedule.prevent_sleep": tool("desktop_power"),
+  "local_documents.list": dropped("matrx-local's private document store is gone; documents are files (fs_*) or cloud Knowledge"),
+  "local_documents.folders": dropped("matrx-local's private document store is gone; documents are files (fs_*) or cloud Knowledge"),
+  "local_documents.read": dropped("matrx-local's private document store is gone; documents are files (fs_*) or cloud Knowledge"),
+  "local_documents.write": dropped("matrx-local's private document store is gone; documents are files (fs_*) or cloud Knowledge"),
+  "local_documents.search": dropped("matrx-local's private document store is gone; documents are files (fs_*) or cloud Knowledge"),
+  "local_media.ocr": tool("desktop_documents"),
+  "local_media.resize": tool("desktop_documents"),
+  "local_media.pdf_extract": tool("desktop_documents"),
+  "local_media.office_generate": tool("desktop_documents"),
+  "local_media.archive_create": dropped(SHELL_COVERS),
+  "local_media.archive_extract": dropped(SHELL_COVERS),
+  "local_ner.entities": tool("desktop_entities"),
+  "local_ner.pii": tool("desktop_entities"),
+  "local_mac_apps.applescript": tool("desktop_automation"),
+  "local_mac_apps.list_emails": tool("desktop_mail"),
+  "local_mac_apps.send_email": tool("desktop_mail"),
+  "local_mac_apps.email_accounts": tool("desktop_mail"),
+  "local_mac_apps.list_messages": tool("desktop_messages"),
+  "local_mac_apps.list_conversations": tool("desktop_messages"),
+  "local_mac_apps.send_message": tool("desktop_messages"),
+  "local_mac_apps.search_contacts": tool("desktop_contacts"),
+  "local_mac_apps.get_contact": tool("desktop_contacts"),
+  "local_mac_apps.list_events": tool("desktop_calendar"),
+  "local_mac_apps.create_event": tool("desktop_calendar"),
+  "local_mac_apps.list_reminders": tool("desktop_calendar"),
+  "local_mac_apps.create_reminder": tool("desktop_calendar"),
+  "local_mac_apps.search_photos": tool("desktop_photos"),
+  "local_mac_apps.get_photo": tool("desktop_photos"),
+  "local_mac_apps.location": tool("desktop_location"),
+  "local_windows_ps.run": tool("desktop_automation"),
+  "local_windows_ps.get_env": dropped("Read with shell_execute; a per-command env rides exec.run"),
+  "local_windows_ps.set_env": dropped("Changing the person's persistent environment is not an agent tool"),
+  "local_windows_ps.registry_read": tool("desktop_windows_admin"),
+  "local_windows_ps.registry_write": tool("desktop_windows_admin"),
+  "local_windows_ps.service_list": tool("desktop_windows_admin"),
+  "local_windows_ps.service_control": tool("desktop_windows_admin"),
+  "local_windows_ps.event_log": tool("desktop_windows_admin"),
+  "local_windows_ps.windows_features": tool("desktop_windows_admin")
+};
+var LEGACY_DISPATCHERS = [
+  "local_file",
+  "local_shell",
+  "local_window",
+  "local_process",
+  "local_input",
+  "local_audio",
+  "local_clipboard",
+  "local_screen",
+  "local_system",
+  "local_browser",
+  "local_web",
+  "local_net",
+  "local_monitor",
+  "local_schedule",
+  "local_documents",
+  "local_media",
+  "local_ner",
+  "local_mac_apps",
+  "local_windows_ps"
+];
+function builtOps() {
+  return TOOL_CATALOG.filter((t) => t.state === "built").flatMap((t) => t.ops);
+}
+
+// src/tools/status.ts
+var TOOL_LEVELS = ["programmatic", "protocol", "chat"];
+var TOOL_PLATFORMS = ["darwin", "win32", "linux"];
+var REQUIRED = {
+  programmatic: [{ label: "in process", ok: (e) => e.transport === "in_process" }],
+  protocol: [
+    { label: "localhost", ok: (e) => e.transport === "localhost" },
+    { label: "relay", ok: (e) => e.transport === "relay" },
+    { label: "relay from another network", ok: (e) => e.transport === "relay" && e.remote_network }
+  ],
+  chat: [{ label: "a real agent in a real chat", ok: (e) => e.transport === "agent" }]
+};
+function cellFor(tool2, platform, level, evidence) {
+  if (!tool2.platforms.includes(platform)) return { state: "unsupported", missing: [], last_run_at_ms: null, evidence: [] };
+  const latest = /* @__PURE__ */ new Map();
+  for (const e of evidence) {
+    const key = `${e.suite}\0${e.test}\0${e.transport}\0${e.remote_network}`;
+    const prev = latest.get(key);
+    if (!prev || prev.run_at_ms < e.run_at_ms) latest.set(key, e);
+  }
+  const runs = [...latest.values()].filter((e) => e.outcome !== "skip").sort((a, b) => b.run_at_ms - a.run_at_ms);
+  const last = runs[0]?.run_at_ms ?? null;
+  if (tool2.state === "planned" && runs.length === 0) return { state: "not_built", missing: [], last_run_at_ms: null, evidence: [] };
+  if (runs.length === 0) return { state: "untested", missing: REQUIRED[level].map((r) => r.label), last_run_at_ms: null, evidence: [...latest.values()] };
+  if (runs.some((e) => e.outcome === "fail")) return { state: "fail", missing: [], last_run_at_ms: last, evidence: runs };
+  const missing = REQUIRED[level].filter((r) => !runs.some((e) => e.outcome === "pass" && r.ok(e))).map((r) => r.label);
+  return { state: missing.length === 0 ? "pass" : "partial", missing, last_run_at_ms: last, evidence: runs };
+}
+function buildToolStatus(files, opts) {
+  const parsed = files.map((f, i) => {
+    const r = ToolResultsFile.safeParse(f);
+    if (!r.success) throw new Error(`tool results file #${i} is off-contract: ${r.error.issues[0]?.path.join(".")} ${r.error.issues[0]?.message}`);
+    return r.data;
+  });
+  const known = new Set(TOOL_CATALOG.map((t) => t.name));
+  const byKey = /* @__PURE__ */ new Map();
+  for (const file of parsed) {
+    for (const r of file.results) {
+      if (!known.has(r.tool)) throw new Error(`a result names ${r.tool}, which is not in the tool catalog`);
+      const key = `${r.tool}|${r.platform}|${r.level}`;
+      const list = byKey.get(key) ?? [];
+      list.push({ suite: r.suite, test: r.test, transport: r.transport, outcome: r.outcome, remote_network: r.remote_network, commit: file.commit, run_at_ms: r.run_at_ms, detail: r.detail });
+      byKey.set(key, list);
+    }
+  }
+  const groupOrder = new Map(TOOL_GROUPS.map((g) => [g.id, g.order]));
+  const tools = [...TOOL_CATALOG].sort((a, b) => (groupOrder.get(a.group) ?? 99) - (groupOrder.get(b.group) ?? 99));
+  const rows2 = tools.map((tool2) => {
+    const cells = {};
+    const working = {};
+    for (const platform of TOOL_PLATFORMS) {
+      const perLevel = {};
+      for (const level of TOOL_LEVELS) perLevel[level] = cellFor(tool2, platform, level, byKey.get(`${tool2.name}|${platform}|${level}`) ?? []);
+      cells[platform] = perLevel;
+      working[platform] = TOOL_LEVELS.every((l) => perLevel[l].state === "pass");
+    }
+    return { tool: tool2.name, group: tool2.group, tool_state: tool2.state, summary: tool2.summary, note: tool2.note ?? null, cells, working };
+  });
+  const totals = {};
+  for (const platform of TOOL_PLATFORMS) {
+    const onPlatform = TOOL_CATALOG.filter((t) => t.platforms.includes(platform));
+    totals[platform] = {
+      working: rows2.filter((r) => r.working[platform]).length,
+      built: onPlatform.filter((t) => t.state !== "planned").length,
+      tools: onPlatform.length
+    };
+  }
+  const commits = [...new Set(parsed.map((f) => f.commit))].sort();
+  return { schema: "matrx.tool-status.v1", generated_at_ms: opts.generatedAtMs, commits, rows: rows2, totals };
+}
+var MARK = { pass: "\u2713", partial: "\u25D0", fail: "\u2717", untested: "\xB7", not_built: "\u2014", unsupported: " " };
+function renderToolStatusMarkdown(status) {
+  const lines = [
+    "<!-- GENERATED by `pnpm tools:status` from test results. Never edit by hand. -->",
+    "# Local tools: status",
+    "",
+    `Generated ${new Date(status.generated_at_ms).toISOString()} from commits ${status.commits.join(", ") || "none"}.`,
+    "",
+    "\u2713 pass \xB7 \u25D0 passing so far, a required proof missing \xB7 \u2717 fail \xB7 `\xB7` untested \xB7 \u2014 not built. Levels: P programmatic, R protocol, C chat.",
+    "",
+    "| Platform | Working | Built | Tools |",
+    "|---|---|---|---|",
+    ...TOOL_PLATFORMS.map((p) => `| ${p} | ${status.totals[p].working} | ${status.totals[p].built} | ${status.totals[p].tools} |`),
+    ""
+  ];
+  for (const group of TOOL_GROUPS) {
+    const rows2 = status.rows.filter((r) => r.group === group.id);
+    if (rows2.length === 0) continue;
+    lines.push(`## ${group.order}. ${group.title}`, "", "| Tool | darwin P R C | win32 P R C | linux P R C | Missing |", "|---|---|---|---|---|");
+    for (const r of rows2) {
+      const cols2 = TOOL_PLATFORMS.map((p) => TOOL_LEVELS.map((l) => MARK[r.cells[p][l].state]).join(" "));
+      const missing = /* @__PURE__ */ new Set();
+      for (const p of TOOL_PLATFORMS) for (const l of TOOL_LEVELS) for (const m of r.cells[p][l].missing) if (r.cells[p][l].state !== "untested") missing.add(`${p} ${l}: ${m}`);
+      const name = r.tool_state === "broken" ? `${r.tool} (broken: ${r.note ?? ""})` : r.tool;
+      lines.push(`| ${name} | ${cols2.join(" | ")} | ${[...missing].join("; ")} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 //# sourceMappingURL=index.cjs.map