@ai-matrx/desktop-protocol 0.7.0 → 0.10.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { O as OpName } from './registry-Duc_VFN8.js';
-export { B as BEARER_PREFIX, f as CLOSE_RULES, g as CancelMsg, h as ClientToCoreMsg, e as ClientType, j as CloseAction, k as CloseCode, l as CloseCodeValue, C as CloseOutcome, m as CloseRule, n as CoreToClientMsg, o as CreditMsg, D as DesktopProtocolError, d as EVENTS, p as EndMsg, E as EndReason, q as ErrorCode, r as ErrorCodeName, s as ErrorData, t as ErrorMsg, u as ErrorReason, v as ErrorReasonName, w as EventMsg, x as EventName, F as FsPatchEditFailure, H as HelloMsg, L as Limits, N as NAMED_SCHEMAS, y as NamedSchemaId, c as OPS, z as OpDescriptor, a as OpParams, b as OpResult, A as OpSpec, P as PING_TEXT, G as PONG_TEXT, I as ProtocolErrorBody, R as RelayMsg, J as RequestMsg, K as ResponseMsg, M as SUBPROTOCOL, S as StreamMeta, Q as StreamMsg, W as Welcome, T as closeRule, i as isDesktopProtocolError, U as isTerminalClose } from './registry-Duc_VFN8.js';
+import { O as OpName } from './registry-B3NqARgh.js';
+export { B as BEARER_PREFIX, f as CLOSE_RULES, g as CancelMsg, h as ClientToCoreMsg, e as ClientType, j as CloseAction, k as CloseCode, l as CloseCodeValue, C as CloseOutcome, m as CloseRule, n as CoreToClientMsg, o as CreditMsg, D as DesktopProtocolError, d as EVENTS, p as EndMsg, E as EndReason, q as ErrorCode, r as ErrorCodeName, s as ErrorData, t as ErrorMsg, u as ErrorReason, v as ErrorReasonName, w as EventMsg, x as EventName, F as FsPatchEditFailure, H as HelloMsg, L as Limits, N as NAMED_SCHEMAS, y as NamedSchemaId, c as OPS, z as OpDescriptor, a as OpParams, b as OpResult, A as OpSpec, P as PING_TEXT, G as PONG_TEXT, I as ProtocolErrorBody, R as RelayMsg, J as RequestMsg, K as ResponseMsg, M as SERVICES, Q as SUBPROTOCOL, T as ServiceId, U as ServiceOpName, V as ServiceOpSpec, X as ServiceSpec, S as StreamMeta, Y as StreamMsg, W as Welcome, Z as closeRule, i as isDesktopProtocolError, _ as isTerminalClose } from './registry-B3NqARgh.js';
 export { BROADCAST_CID, DecodedFrame, FRAME_HEADER_BYTES, FRAME_STRUCT_FORMAT, FRAME_VERSION, FrameChannel, FrameChannelValue, FrameFlag, assertFrameHeader, connectionEndFrame, decodeFrame, encodeFrame, hasFlag, isConnectionEnd, readCid, stampCid } from './frame.js';
 
 /** @ai-matrx/desktop-protocol — version and primitive schemas. Schema source: lint-enforced rules in scripts/check-schema-source.mjs. */
@@ -11,10 +11,12 @@ declare const PROTOCOL_MAJOR: 1;
  *   1.0 — the first contract.
  *   1.1 — fs.patch per-edit results; /call reports the negotiated version;
  *         device status since_ms is null for a device that never connected.
+ *   1.2 — the `models` capability (local transcription) and its error reasons (REASONS_SINCE);
+ *         the `apps` capability (desktop apps, their profiles and usage).
  */
-declare const PROTOCOL_MINOR: 1;
+declare const PROTOCOL_MINOR: 2;
 /** This package's version as the wire spells it ("major.minor"): hello, welcome, relay status. */
-declare const PROTOCOL_VERSION: "1.1";
+declare const PROTOCOL_VERSION: "1.2";
 /** Internal building blocks — deliberately unnamed in $defs (inlined wherever used). */
 declare const u32: z.ZodInt;
 declare const nonNegInt: z.ZodInt;
@@ -986,6 +988,13 @@ declare const RelayCallResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 resource_expired: "resource_expired";
                 control_taken: "control_taken";
                 window_exhausted: "window_exhausted";
+                runtime_not_installed: "runtime_not_installed";
+                model_not_installed: "model_not_installed";
+                unsupported_media: "unsupported_media";
+                download_failed: "download_failed";
+                service_starting: "service_starting";
+                service_restarted: "service_restarted";
+                service_failed: "service_failed";
             }>>;
             cap: z.ZodOptional<z.ZodString>;
             op: z.ZodOptional<z.ZodString>;
@@ -1032,6 +1041,898 @@ declare const RelayCallEnvelope: z.ZodObject<{
 }, z.core.$strict>;
 type RelayCallEnvelope = z.output<typeof RelayCallEnvelope>;
 
+/**
+ * @ai-matrx/desktop-protocol — the `models` capability (SPEC §6): local AI models on the device,
+ * served by Matrx 2's `ml` Python service (SPEC §3.10). Schema source: lint-enforced rules in
+ * scripts/check-schema-source.mjs.
+ *
+ * Two contracts share these shapes, both generated from this file (SPEC P11):
+ *   - the Router ops `models.*` (every transport: relay, localhost, extension, the app's screen);
+ *   - the internal service ops `ml.*` between the desktop core and the Python service
+ *     (src/schema/service.ts, `SERVICES` in registry.ts). A forwarded op uses the SAME named
+ *     schema on both hops, so the two can never disagree.
+ */
+
+/** The heavy runtime (inference packages) is installed on first use, never shipped in the app. */
+declare const MlRuntimeState: z.ZodEnum<{
+    not_installed: "not_installed";
+    installing: "installing";
+    installed: "installed";
+    failed: "failed";
+}>;
+/** `packages`: the locked inference wheels; `model`: one model's weights; `verifying`: hashes and a load test. */
+declare const MlInstallPhase: z.ZodEnum<{
+    model: "model";
+    packages: "packages";
+    verifying: "verifying";
+}>;
+declare const MlInstallProgress: z.ZodObject<{
+    phase: z.ZodEnum<{
+        model: "model";
+        packages: "packages";
+        verifying: "verifying";
+    }>;
+    item: z.ZodString;
+    bytes_done: z.ZodInt;
+    bytes_total: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+declare const TranscriptionModelInfo: z.ZodObject<{
+    id: z.ZodEnum<{
+        tiny: "tiny";
+        base: "base";
+        small: "small";
+        "large-v3-turbo": "large-v3-turbo";
+    }>;
+    size_bytes: z.ZodInt;
+    multilingual: z.ZodBoolean;
+    installed: z.ZodBoolean;
+}, z.core.$strict>;
+/** What the `ml` service itself reports (the core adds the supervisor's view in ModelsStatusResult). */
+declare const MlStatusParams: z.ZodObject<{}, z.core.$strict>;
+/** The supervisor's view of the `ml` service process. */
+declare const MlServiceState: z.ZodEnum<{
+    failed: "failed";
+    starting: "starting";
+    ready: "ready";
+    restarting: "restarting";
+    stopped: "stopped";
+}>;
+declare const MlServiceStatus: z.ZodObject<{
+    state: z.ZodEnum<{
+        failed: "failed";
+        starting: "starting";
+        ready: "ready";
+        restarting: "restarting";
+        stopped: "stopped";
+    }>;
+    pid: z.ZodNullable<z.ZodInt>;
+    restarts: z.ZodInt;
+    python: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+declare const ModelsStatusParams: z.ZodObject<{}, z.core.$strict>;
+/** Whisper sizes the device can run (CTranslate2 weights). Larger = slower, more accurate. */
+declare const TranscriptionModelId: z.ZodEnum<{
+    tiny: "tiny";
+    base: "base";
+    small: "small";
+    "large-v3-turbo": "large-v3-turbo";
+}>;
+type TranscriptionModelId = z.output<typeof TranscriptionModelId>;
+declare const MlStatusResult: z.ZodObject<{
+    runtime: z.ZodEnum<{
+        not_installed: "not_installed";
+        installing: "installing";
+        installed: "installed";
+        failed: "failed";
+    }>;
+    install: z.ZodNullable<z.ZodObject<{
+        phase: z.ZodEnum<{
+            model: "model";
+            packages: "packages";
+            verifying: "verifying";
+        }>;
+        item: z.ZodString;
+        bytes_done: z.ZodInt;
+        bytes_total: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>;
+    error: z.ZodNullable<z.ZodString>;
+    accelerator: z.ZodEnum<{
+        cpu: "cpu";
+        cuda: "cuda";
+    }>;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            tiny: "tiny";
+            base: "base";
+            small: "small";
+            "large-v3-turbo": "large-v3-turbo";
+        }>;
+        size_bytes: z.ZodInt;
+        multilingual: z.ZodBoolean;
+        installed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    default_model: z.ZodEnum<{
+        tiny: "tiny";
+        base: "base";
+        small: "small";
+        "large-v3-turbo": "large-v3-turbo";
+    }>;
+}, z.core.$strict>;
+type MlStatusResult = z.output<typeof MlStatusResult>;
+/** A progress report while `ml.install` / `ml.transcribe` runs. */
+declare const MlProgress: z.ZodObject<{
+    kind: z.ZodEnum<{
+        install: "install";
+        transcribe: "transcribe";
+    }>;
+    fraction: z.ZodNullable<z.ZodNumber>;
+    install: z.ZodNullable<z.ZodObject<{
+        phase: z.ZodEnum<{
+            model: "model";
+            packages: "packages";
+            verifying: "verifying";
+        }>;
+        item: z.ZodString;
+        bytes_done: z.ZodInt;
+        bytes_total: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>;
+    segment: z.ZodNullable<z.ZodObject<{
+        start_s: z.ZodNumber;
+        end_s: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type MlProgress = z.output<typeof MlProgress>;
+declare const ModelsStatusResult: z.ZodObject<{
+    service: z.ZodObject<{
+        state: z.ZodEnum<{
+            failed: "failed";
+            starting: "starting";
+            ready: "ready";
+            restarting: "restarting";
+            stopped: "stopped";
+        }>;
+        pid: z.ZodNullable<z.ZodInt>;
+        restarts: z.ZodInt;
+        python: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    transcription: z.ZodNullable<z.ZodObject<{
+        runtime: z.ZodEnum<{
+            not_installed: "not_installed";
+            installing: "installing";
+            installed: "installed";
+            failed: "failed";
+        }>;
+        install: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                model: "model";
+                packages: "packages";
+                verifying: "verifying";
+            }>;
+            item: z.ZodString;
+            bytes_done: z.ZodInt;
+            bytes_total: z.ZodNullable<z.ZodInt>;
+        }, z.core.$strict>>;
+        error: z.ZodNullable<z.ZodString>;
+        accelerator: z.ZodEnum<{
+            cpu: "cpu";
+            cuda: "cuda";
+        }>;
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodEnum<{
+                tiny: "tiny";
+                base: "base";
+                small: "small";
+                "large-v3-turbo": "large-v3-turbo";
+            }>;
+            size_bytes: z.ZodInt;
+            multilingual: z.ZodBoolean;
+            installed: z.ZodBoolean;
+        }, z.core.$strict>>;
+        default_model: z.ZodEnum<{
+            tiny: "tiny";
+            base: "base";
+            small: "small";
+            "large-v3-turbo": "large-v3-turbo";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type ModelsStatusResult = z.output<typeof ModelsStatusResult>;
+/**
+ * Transcribe an audio or video file on the device. Any format the bundled decoder reads (wav, mp3,
+ * m4a, webm/opus, mp4…). `language` is ISO 639-1; omitted = detect. `translate` = into English.
+ */
+declare const ModelsTranscribeParams: z.ZodObject<{
+    path: z.ZodString;
+    model: z.ZodOptional<z.ZodEnum<{
+        tiny: "tiny";
+        base: "base";
+        small: "small";
+        "large-v3-turbo": "large-v3-turbo";
+    }>>;
+    language: z.ZodOptional<z.ZodString>;
+    task: z.ZodDefault<z.ZodEnum<{
+        transcribe: "transcribe";
+        translate: "translate";
+    }>>;
+}, z.core.$strict>;
+type ModelsTranscribeParams = z.output<typeof ModelsTranscribeParams>;
+declare const ModelsTranscribeResult: z.ZodObject<{
+    text: z.ZodString;
+    language: z.ZodString;
+    language_probability: z.ZodNumber;
+    duration_s: z.ZodNumber;
+    model: z.ZodEnum<{
+        tiny: "tiny";
+        base: "base";
+        small: "small";
+        "large-v3-turbo": "large-v3-turbo";
+    }>;
+    segments: z.ZodArray<z.ZodObject<{
+        start_s: z.ZodNumber;
+        end_s: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    elapsed_ms: z.ZodInt;
+}, z.core.$strict>;
+type ModelsTranscribeResult = z.output<typeof ModelsTranscribeResult>;
+/** Install the runtime (if missing) and one model's weights (default: the default model). */
+declare const ModelsInstallParams: z.ZodObject<{
+    model: z.ZodOptional<z.ZodEnum<{
+        tiny: "tiny";
+        base: "base";
+        small: "small";
+        "large-v3-turbo": "large-v3-turbo";
+    }>>;
+}, z.core.$strict>;
+type ModelsInstallParams = z.output<typeof ModelsInstallParams>;
+declare const ModelsInstallResult: z.ZodObject<{
+    model: z.ZodEnum<{
+        tiny: "tiny";
+        base: "base";
+        small: "small";
+        "large-v3-turbo": "large-v3-turbo";
+    }>;
+    elapsed_ms: z.ZodInt;
+}, z.core.$strict>;
+type ModelsInstallResult = z.output<typeof ModelsInstallResult>;
+/** Sent to the client that started a `models.install` or `models.transcribe`, for that request. */
+declare const ModelsProgressEvent: z.ZodObject<{
+    request_id: z.ZodString;
+    progress: z.ZodObject<{
+        kind: z.ZodEnum<{
+            install: "install";
+            transcribe: "transcribe";
+        }>;
+        fraction: z.ZodNullable<z.ZodNumber>;
+        install: z.ZodNullable<z.ZodObject<{
+            phase: z.ZodEnum<{
+                model: "model";
+                packages: "packages";
+                verifying: "verifying";
+            }>;
+            item: z.ZodString;
+            bytes_done: z.ZodInt;
+            bytes_total: z.ZodNullable<z.ZodInt>;
+        }, z.core.$strict>>;
+        segment: z.ZodNullable<z.ZodObject<{
+            start_s: z.ZodNumber;
+            end_s: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ModelsProgressEvent = z.output<typeof ModelsProgressEvent>;
+declare const TranscriptSegment: z.ZodObject<{
+    start_s: z.ZodNumber;
+    end_s: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strict>;
+type TranscriptSegment = z.output<typeof TranscriptSegment>;
+
+/**
+ * @ai-matrx/desktop-protocol — cap apps (SPEC §6): the desktop apps a person uses (Claude, Codex,
+ * Cursor, VS Code, Antigravity, and any app a later adapter adds), their profiles and usage.
+ * Schema source: lint-enforced rules in scripts/check-schema-source.mjs.
+ *
+ * A profile is one data folder of one app on one device, so several accounts of the same app run
+ * side by side. Profiles are the person's own rows in `users.desktop_app_profile` (the one
+ * database); folders found on disk that no row names yet are listed with `id: null` so they can be
+ * added. Nothing here is ever a credential: signing in happens inside the app.
+ */
+
+/** An adapter key: lowercase, open-ended (a new app needs only a new adapter). */
+declare const AppKey: z.ZodString;
+type AppKey = z.output<typeof AppKey>;
+/** A users.desktop_app_profile id. Plain pattern (see DeviceId for why not z.uuid()). */
+declare const AppProfileId: z.ZodString;
+type AppProfileId = z.output<typeof AppProfileId>;
+/**
+ * Where a profile's folder lives, RELATIVE to the app adapter's data root on that device: one or
+ * more plain names joined by "/" (none starting with a dot, so never "." or ".."), never absolute.
+ * Null on a profile means the app's own default profile. No lookaround: Pydantic's regex engine
+ * has none.
+ */
+declare const AppProfileLocator: z.ZodString;
+type AppProfileLocator = z.output<typeof AppProfileLocator>;
+/** supported: proven here; partial: works with a stated gap; unsupported: not on this OS. */
+declare const AppSupport: z.ZodEnum<{
+    supported: "supported";
+    partial: "partial";
+    unsupported: "unsupported";
+}>;
+type AppSupport = z.output<typeof AppSupport>;
+declare const AppFeatureStatus: z.ZodObject<{
+    status: z.ZodEnum<{
+        supported: "supported";
+        partial: "partial";
+        unsupported: "unsupported";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+type AppFeatureStatus = z.output<typeof AppFeatureStatus>;
+declare const AppInfo: z.ZodObject<{
+    app_key: z.ZodString;
+    name: z.ZodString;
+    installed: z.ZodBoolean;
+    version: z.ZodNullable<z.ZodString>;
+    location: z.ZodNullable<z.ZodString>;
+    open: z.ZodObject<{
+        status: z.ZodEnum<{
+            supported: "supported";
+            partial: "partial";
+            unsupported: "unsupported";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    profiles: z.ZodObject<{
+        status: z.ZodEnum<{
+            supported: "supported";
+            partial: "partial";
+            unsupported: "unsupported";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    usage: z.ZodObject<{
+        status: z.ZodEnum<{
+            supported: "supported";
+            partial: "partial";
+            unsupported: "unsupported";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type AppInfo = z.output<typeof AppInfo>;
+/** One plan-usage figure, as the app itself last recorded it. */
+declare const AppUsageReading: z.ZodObject<{
+    window: z.ZodEnum<{
+        five_hour: "five_hour";
+        weekly: "weekly";
+        extra: "extra";
+    }>;
+    percent: z.ZodNumber;
+    sampled_at_ms: z.ZodInt;
+    reset_since: z.ZodBoolean;
+}, z.core.$strict>;
+type AppUsageReading = z.output<typeof AppUsageReading>;
+declare const AppProfile: z.ZodObject<{
+    id: z.ZodNullable<z.ZodString>;
+    app_key: z.ZodString;
+    display_name: z.ZodString;
+    account_identity: z.ZodNullable<z.ZodString>;
+    profile_locator: z.ZodNullable<z.ZodString>;
+    device_id: z.ZodNullable<z.ZodString>;
+    folder: z.ZodNullable<z.ZodString>;
+    on_disk: z.ZodBoolean;
+    running: z.ZodNullable<z.ZodBoolean>;
+    usage: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        window: z.ZodEnum<{
+            five_hour: "five_hour";
+            weekly: "weekly";
+            extra: "extra";
+        }>;
+        percent: z.ZodNumber;
+        sampled_at_ms: z.ZodInt;
+        reset_since: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    last_opened_ms: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+type AppProfile = z.output<typeof AppProfile>;
+declare const AppsListParams: z.ZodObject<{}, z.core.$strict>;
+type AppsListParams = z.output<typeof AppsListParams>;
+declare const AppsListResult: z.ZodObject<{
+    apps: z.ZodArray<z.ZodObject<{
+        app_key: z.ZodString;
+        name: z.ZodString;
+        installed: z.ZodBoolean;
+        version: z.ZodNullable<z.ZodString>;
+        location: z.ZodNullable<z.ZodString>;
+        open: z.ZodObject<{
+            status: z.ZodEnum<{
+                supported: "supported";
+                partial: "partial";
+                unsupported: "unsupported";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        profiles: z.ZodObject<{
+            status: z.ZodEnum<{
+                supported: "supported";
+                partial: "partial";
+                unsupported: "unsupported";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        usage: z.ZodObject<{
+            status: z.ZodEnum<{
+                supported: "supported";
+                partial: "partial";
+                unsupported: "unsupported";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type AppsListResult = z.output<typeof AppsListResult>;
+declare const AppsProfilesListParams: z.ZodObject<{
+    app_key: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AppsProfilesListParams = z.output<typeof AppsProfilesListParams>;
+declare const AppsProfilesListResult: z.ZodObject<{
+    profiles: z.ZodArray<z.ZodObject<{
+        id: z.ZodNullable<z.ZodString>;
+        app_key: z.ZodString;
+        display_name: z.ZodString;
+        account_identity: z.ZodNullable<z.ZodString>;
+        profile_locator: z.ZodNullable<z.ZodString>;
+        device_id: z.ZodNullable<z.ZodString>;
+        folder: z.ZodNullable<z.ZodString>;
+        on_disk: z.ZodBoolean;
+        running: z.ZodNullable<z.ZodBoolean>;
+        usage: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            window: z.ZodEnum<{
+                five_hour: "five_hour";
+                weekly: "weekly";
+                extra: "extra";
+            }>;
+            percent: z.ZodNumber;
+            sampled_at_ms: z.ZodInt;
+            reset_since: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        last_opened_ms: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>;
+    registry: z.ZodEnum<{
+        ok: "ok";
+        signed_out: "signed_out";
+        unavailable: "unavailable";
+    }>;
+}, z.core.$strict>;
+type AppsProfilesListResult = z.output<typeof AppsProfilesListResult>;
+/** Create (no id) or update (id) the person's own profile row. */
+declare const AppsProfilesSaveParams: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    app_key: z.ZodString;
+    display_name: z.ZodString;
+    account_identity: z.ZodNullable<z.ZodString>;
+    profile_locator: z.ZodNullable<z.ZodString>;
+    new_folder: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+type AppsProfilesSaveParams = z.output<typeof AppsProfilesSaveParams>;
+declare const AppsProfilesSaveResult: z.ZodObject<{
+    id: z.ZodNullable<z.ZodString>;
+    app_key: z.ZodString;
+    display_name: z.ZodString;
+    account_identity: z.ZodNullable<z.ZodString>;
+    profile_locator: z.ZodNullable<z.ZodString>;
+    device_id: z.ZodNullable<z.ZodString>;
+    folder: z.ZodNullable<z.ZodString>;
+    on_disk: z.ZodBoolean;
+    running: z.ZodNullable<z.ZodBoolean>;
+    usage: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        window: z.ZodEnum<{
+            five_hour: "five_hour";
+            weekly: "weekly";
+            extra: "extra";
+        }>;
+        percent: z.ZodNumber;
+        sampled_at_ms: z.ZodInt;
+        reset_since: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    last_opened_ms: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+type AppsProfilesSaveResult = z.output<typeof AppsProfilesSaveResult>;
+/** Remove the row (soft delete). The folder on disk is never touched. */
+declare const AppsProfilesRemoveParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>;
+type AppsProfilesRemoveParams = z.output<typeof AppsProfilesRemoveParams>;
+declare const AppsProfilesRemoveResult: z.ZodObject<{
+    removed: z.ZodBoolean;
+}, z.core.$strict>;
+type AppsProfilesRemoveResult = z.output<typeof AppsProfilesRemoveResult>;
+/** Open the app with a profile (its default profile when profile_id is absent). */
+declare const AppsOpenParams: z.ZodObject<{
+    app_key: z.ZodString;
+    profile_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AppsOpenParams = z.output<typeof AppsOpenParams>;
+declare const AppsOpenResult: z.ZodObject<{
+    already_running: z.ZodBoolean;
+    folder: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+type AppsOpenResult = z.output<typeof AppsOpenResult>;
+
+/**
+ * @ai-matrx/desktop-protocol — the internal envelope between Matrx 2's core and its supervised
+ * Python services (SPEC §3.10). Schema source: lint-enforced rules in scripts/check-schema-source.mjs.
+ *
+ * Never seen by a client: clients speak the Router protocol (envelope.ts); a capability owner in
+ * the core forwards a Router op to its service op (SERVICES in registry.ts). One local socket per
+ * service (a Unix socket on macOS/Linux, a named pipe on Windows). Each message is one frame:
+ * a 4-byte big-endian length, then that many bytes of UTF-8 JSON (at most SERVICE_MAX_FRAME_BYTES).
+ *
+ * The first message on a connection is `hello` (the per-launch token the core handed the service
+ * in its environment, plus the contract hash it was built against). A wrong token or a different
+ * contract is answered with `error` id 0 and the connection is closed: the two sides of the
+ * connection were generated from different contracts and must never talk (SPEC P11).
+ */
+
+/** The largest frame either side accepts (16 MiB). */
+declare const SERVICE_MAX_FRAME_BYTES: 16777216;
+/** SHA-256 (hex) of generated/desktop-protocol.schema.json: CONTRACT_SHA256 on both sides. */
+declare const ContractHash: z.ZodString;
+/** The per-launch secret: 32 random bytes, base64url (43 characters). Passed by environment, never argv. */
+declare const ServiceToken: z.ZodString;
+declare const ServiceHello: z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    token: z.ZodString;
+    contract: z.ZodString;
+}, z.core.$strict>;
+declare const ServiceRequest: z.ZodObject<{
+    type: z.ZodLiteral<"request">;
+    id: z.ZodInt;
+    op: z.ZodString;
+    params: z.ZodUnknown;
+}, z.core.$strict>;
+declare const ServiceResponse: z.ZodObject<{
+    type: z.ZodLiteral<"response">;
+    id: z.ZodInt;
+    result: z.ZodUnknown;
+}, z.core.$strict>;
+declare const ServiceErrorMsg: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    id: z.ZodInt;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            AUTH_REQUIRED: "AUTH_REQUIRED";
+            AUTH_INVALID: "AUTH_INVALID";
+            AUTH_EXPIRED: "AUTH_EXPIRED";
+            AUTH_FORBIDDEN: "AUTH_FORBIDDEN";
+            AUTH_DEVICE_REVOKED: "AUTH_DEVICE_REVOKED";
+            PERMISSION_DENIED_OS: "PERMISSION_DENIED_OS";
+            NOT_FOUND: "NOT_FOUND";
+            CONFLICT: "CONFLICT";
+            INVALID_PARAMS: "INVALID_PARAMS";
+            RESOURCE_BUSY: "RESOURCE_BUSY";
+            RESOURCE_GONE: "RESOURCE_GONE";
+            CANCELLED: "CANCELLED";
+            TIMEOUT: "TIMEOUT";
+            PLATFORM_UNSUPPORTED: "PLATFORM_UNSUPPORTED";
+            RATE_LIMITED: "RATE_LIMITED";
+            INTERNAL: "INTERNAL";
+            PROTOCOL_VERSION_UNSUPPORTED: "PROTOCOL_VERSION_UNSUPPORTED";
+            PROTOCOL_ERROR: "PROTOCOL_ERROR";
+            UNKNOWN_OPERATION: "UNKNOWN_OPERATION";
+            DEVICE_OFFLINE: "DEVICE_OFFLINE";
+            PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodOptional<z.ZodEnum<{
+                not_a_directory: "not_a_directory";
+                is_a_directory: "is_a_directory";
+                directory_not_empty: "directory_not_empty";
+                already_exists: "already_exists";
+                stale_write: "stale_write";
+                binary_content: "binary_content";
+                not_utf8_boundary: "not_utf8_boundary";
+                patch_no_match: "patch_no_match";
+                patch_ambiguous: "patch_ambiguous";
+                resource_exited: "resource_exited";
+                resource_expired: "resource_expired";
+                control_taken: "control_taken";
+                window_exhausted: "window_exhausted";
+                runtime_not_installed: "runtime_not_installed";
+                model_not_installed: "model_not_installed";
+                unsupported_media: "unsupported_media";
+                download_failed: "download_failed";
+                service_starting: "service_starting";
+                service_restarted: "service_restarted";
+                service_failed: "service_failed";
+            }>>;
+            cap: z.ZodOptional<z.ZodString>;
+            op: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            settings_url: z.ZodOptional<z.ZodString>;
+            retry_after_ms: z.ZodOptional<z.ZodInt>;
+            limit_bytes: z.ZodOptional<z.ZodInt>;
+            edits_failed: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                edit_index: z.ZodInt;
+                reason: z.ZodString;
+            }, z.core.$strict>>>;
+            upgrade: z.ZodOptional<z.ZodObject<{
+                min_version: z.ZodString;
+                max_version: z.ZodString;
+                download_url: z.ZodOptional<z.ZodURL>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** A running request's progress (validated against the service's progress schema). */
+declare const ServiceProgressMsg: z.ZodObject<{
+    type: z.ZodLiteral<"progress">;
+    id: z.ZodInt;
+    progress: z.ZodUnknown;
+}, z.core.$strict>;
+declare const ServiceCancel: z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+    id: z.ZodInt;
+}, z.core.$strict>;
+/** Health check: the service answers `pong` at once from its event loop, even while it works. */
+declare const ServicePing: z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    id: z.ZodInt;
+}, z.core.$strict>;
+declare const ServicePong: z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    id: z.ZodInt;
+    busy: z.ZodInt;
+}, z.core.$strict>;
+/** Finish quickly: cancel running work, answer nothing more, exit 0. */
+declare const ServiceShutdown: z.ZodObject<{
+    type: z.ZodLiteral<"shutdown">;
+}, z.core.$strict>;
+/** Supervised Python services. `tools` joins when it is built. */
+declare const ServiceName: z.ZodEnum<{
+    ml: "ml";
+}>;
+type ServiceName = z.output<typeof ServiceName>;
+declare const CoreToServiceMsg: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    token: z.ZodString;
+    contract: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"request">;
+    id: z.ZodInt;
+    op: z.ZodString;
+    params: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+    id: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    id: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"shutdown">;
+}, z.core.$strict>], "type">;
+type CoreToServiceMsg = z.output<typeof CoreToServiceMsg>;
+declare const ServiceToCoreMsg: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"welcome">;
+    service: z.ZodEnum<{
+        ml: "ml";
+    }>;
+    contract: z.ZodString;
+    pid: z.ZodInt;
+    python: z.ZodString;
+    ops: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"response">;
+    id: z.ZodInt;
+    result: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    id: z.ZodInt;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            AUTH_REQUIRED: "AUTH_REQUIRED";
+            AUTH_INVALID: "AUTH_INVALID";
+            AUTH_EXPIRED: "AUTH_EXPIRED";
+            AUTH_FORBIDDEN: "AUTH_FORBIDDEN";
+            AUTH_DEVICE_REVOKED: "AUTH_DEVICE_REVOKED";
+            PERMISSION_DENIED_OS: "PERMISSION_DENIED_OS";
+            NOT_FOUND: "NOT_FOUND";
+            CONFLICT: "CONFLICT";
+            INVALID_PARAMS: "INVALID_PARAMS";
+            RESOURCE_BUSY: "RESOURCE_BUSY";
+            RESOURCE_GONE: "RESOURCE_GONE";
+            CANCELLED: "CANCELLED";
+            TIMEOUT: "TIMEOUT";
+            PLATFORM_UNSUPPORTED: "PLATFORM_UNSUPPORTED";
+            RATE_LIMITED: "RATE_LIMITED";
+            INTERNAL: "INTERNAL";
+            PROTOCOL_VERSION_UNSUPPORTED: "PROTOCOL_VERSION_UNSUPPORTED";
+            PROTOCOL_ERROR: "PROTOCOL_ERROR";
+            UNKNOWN_OPERATION: "UNKNOWN_OPERATION";
+            DEVICE_OFFLINE: "DEVICE_OFFLINE";
+            PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodOptional<z.ZodEnum<{
+                not_a_directory: "not_a_directory";
+                is_a_directory: "is_a_directory";
+                directory_not_empty: "directory_not_empty";
+                already_exists: "already_exists";
+                stale_write: "stale_write";
+                binary_content: "binary_content";
+                not_utf8_boundary: "not_utf8_boundary";
+                patch_no_match: "patch_no_match";
+                patch_ambiguous: "patch_ambiguous";
+                resource_exited: "resource_exited";
+                resource_expired: "resource_expired";
+                control_taken: "control_taken";
+                window_exhausted: "window_exhausted";
+                runtime_not_installed: "runtime_not_installed";
+                model_not_installed: "model_not_installed";
+                unsupported_media: "unsupported_media";
+                download_failed: "download_failed";
+                service_starting: "service_starting";
+                service_restarted: "service_restarted";
+                service_failed: "service_failed";
+            }>>;
+            cap: z.ZodOptional<z.ZodString>;
+            op: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            settings_url: z.ZodOptional<z.ZodString>;
+            retry_after_ms: z.ZodOptional<z.ZodInt>;
+            limit_bytes: z.ZodOptional<z.ZodInt>;
+            edits_failed: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                edit_index: z.ZodInt;
+                reason: z.ZodString;
+            }, z.core.$strict>>>;
+            upgrade: z.ZodOptional<z.ZodObject<{
+                min_version: z.ZodString;
+                max_version: z.ZodString;
+                download_url: z.ZodOptional<z.ZodURL>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"progress">;
+    id: z.ZodInt;
+    progress: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    id: z.ZodInt;
+    busy: z.ZodInt;
+}, z.core.$strict>], "type">;
+type ServiceToCoreMsg = z.output<typeof ServiceToCoreMsg>;
+declare const ServiceWelcome: z.ZodObject<{
+    type: z.ZodLiteral<"welcome">;
+    service: z.ZodEnum<{
+        ml: "ml";
+    }>;
+    contract: z.ZodString;
+    pid: z.ZodInt;
+    python: z.ZodString;
+    ops: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type ServiceWelcome = z.output<typeof ServiceWelcome>;
+
+/**
+ * @ai-matrx/desktop-protocol — local tool proof records (SPEC §10). Schema source: lint-enforced
+ * rules in scripts/check-schema-source.mjs.
+ *
+ * A tool is "working" only when three levels pass: programmatic (its owner, called directly on the
+ * real OS), protocol (through the transports, including the relay), chat (a real platform agent in a
+ * real chat calls it and gets the right result). Every harness that proves a level — the desktop's
+ * vitest suites, aidream's live pytest — writes `ToolResultsFile`s; the status table is generated
+ * from them (src/tools/status.ts) and is never written by hand. This file is the one contract
+ * between those harnesses: the Pydantic twin in aidream/_generated/desktop_protocol.py is generated
+ * from it, so the Python writers and the TS reader cannot drift.
+ */
+
+/** Tool names are the platform registry's (`tool.definition.name`): `fs_read`, `shell_execute`… */
+declare const ToolName: z.ZodString;
+declare const ToolLevel: z.ZodEnum<{
+    programmatic: "programmatic";
+    protocol: "protocol";
+    chat: "chat";
+}>;
+type ToolLevel = z.output<typeof ToolLevel>;
+declare const ToolOutcome: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+    skip: "skip";
+}>;
+type ToolOutcome = z.output<typeof ToolOutcome>;
+declare const ToolPlatform: z.ZodEnum<{
+    darwin: "darwin";
+    win32: "win32";
+    linux: "linux";
+}>;
+type ToolPlatform = z.output<typeof ToolPlatform>;
+/**
+ * How the call reached the owner. `in_process` is level 1; `localhost` and `relay` are level 2;
+ * `agent` is level 3 (a model chose the call). `relay` means the platform's real path: a matrx-ai
+ * tool → aidream local-proxy → the relay → the device.
+ */
+declare const ToolTransport: z.ZodEnum<{
+    relay: "relay";
+    in_process: "in_process";
+    localhost: "localhost";
+    agent: "agent";
+}>;
+type ToolTransport = z.output<typeof ToolTransport>;
+declare const ToolLevelResult: z.ZodObject<{
+    tool: z.ZodString;
+    level: z.ZodEnum<{
+        programmatic: "programmatic";
+        protocol: "protocol";
+        chat: "chat";
+    }>;
+    platform: z.ZodEnum<{
+        darwin: "darwin";
+        win32: "win32";
+        linux: "linux";
+    }>;
+    transport: z.ZodEnum<{
+        relay: "relay";
+        in_process: "in_process";
+        localhost: "localhost";
+        agent: "agent";
+    }>;
+    outcome: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        skip: "skip";
+    }>;
+    remote_network: z.ZodBoolean;
+    detail: z.ZodString;
+    suite: z.ZodString;
+    test: z.ZodString;
+    run_at_ms: z.ZodInt;
+}, z.core.$strict>;
+type ToolLevelResult = z.output<typeof ToolLevelResult>;
+declare const ToolResultsFile: z.ZodObject<{
+    schema: z.ZodLiteral<"matrx.tool-results.v1">;
+    commit: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        level: z.ZodEnum<{
+            programmatic: "programmatic";
+            protocol: "protocol";
+            chat: "chat";
+        }>;
+        platform: z.ZodEnum<{
+            darwin: "darwin";
+            win32: "win32";
+            linux: "linux";
+        }>;
+        transport: z.ZodEnum<{
+            relay: "relay";
+            in_process: "in_process";
+            localhost: "localhost";
+            agent: "agent";
+        }>;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            skip: "skip";
+        }>;
+        remote_network: z.ZodBoolean;
+        detail: z.ZodString;
+        suite: z.ZodString;
+        test: z.ZodString;
+        run_at_ms: z.ZodInt;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type ToolResultsFile = z.output<typeof ToolResultsFile>;
+
 /**
  * Version skew is the normal state: a phone, the server and a desktop app in the field run
  * different package versions, and a minor protocol bump must never make any of them fail.
@@ -1076,6 +1977,20 @@ declare const NULL_SINCE: {
         readonly olderPeersGet: 0;
     };
 };
+/**
+ * Error reasons added after x.0, with the minor that added each. An older peer's strict enum would
+ * refuse the whole error body, so `forPeer` drops a reason the peer does not know (the code, the
+ * message and `retryable` still tell it what happened).
+ */
+declare const REASONS_SINCE: {
+    readonly runtime_not_installed: "1.2";
+    readonly model_not_installed: "1.2";
+    readonly unsupported_media: "1.2";
+    readonly download_failed: "1.2";
+    readonly service_starting: "1.2";
+    readonly service_restarted: "1.2";
+    readonly service_failed: "1.2";
+};
 /** A device status for a reader at `version`: `since_ms` null ("never") becomes 0 before 1.1. */
 declare function statusForPeer<T extends {
     since_ms: number | null;
@@ -1103,4 +2018,132 @@ declare function forPeer(op: OpName | null, part: "error", value: unknown, versi
 /** Every op whose result has a versioned field is wired into forPeer (checked by the test). */
 declare const VERSIONED_RESULT_OPS: readonly OpName[];
 
-export { AbsPath, DEFAULT_MAX_FRAME_PAYLOAD_BYTES, DEFAULT_MAX_MESSAGE_BYTES, DEFAULT_WINDOW_BYTES, DeviceId, ExecCwdEvent, ExecExitedEvent, ExecListParams, ExecListResult, ExecPtyKillParams, ExecPtyKillResult, ExecPtyResizeParams, ExecPtyResizeResult, ExecPtySignalParams, ExecPtySignalResult, ExecPtyStartParams, ExecPtyStartResult, ExecPtyWriteParams, ExecPtyWriteResult, ExecRunParams, ExecRunResult, ExecTitleEvent, FIELDS_SINCE, type FieldsSincePath, FrameHeader, FsChange, FsChangedEvent, FsDeleteParams, FsDeleteResult, FsEncoding, FsEntry, FsKind, FsListParams, FsListResult, FsMkdirParams, FsMkdirResult, FsMoveParams, FsMoveResult, FsPatchEditApplied, FsPatchParams, FsPatchResult, FsReadParams, FsReadResult, FsReadStreamParams, FsReadStreamResult, FsSearchContentParams, FsSearchContentResult, FsSearchPathsParams, FsSearchPathsResult, FsStatParams, FsStatResult, FsWatchParams, FsWatchResult, FsWriteParams, FsWriteResult, NULL_SINCE, OpName, OsPermissionName, PROTOCOL_MAJOR, PROTOCOL_MINOR, PROTOCOL_VERSION, ProtocolVersion, PtyInfo, RELAY_CALL_HELLO_ID, RELAY_CALL_REQUEST_ID, RELAY_CALL_VERSION_HEADER, RelayAuthExpiringEvent, RelayCallEnvelope, RelayCallHello, RelayCallRequest, RelayCallResponse, RelayDeviceStatusEvent, RelayHopConnectionEnd, RelayHopEnvelopeHeader, RelayStatusResponse, RequestId, ResourceId, ResourceInfo, SessionAttachParams, SessionAttachResult, SessionControlChangedEvent, SessionDetachParams, SessionDetachResult, SessionListParams, SessionListResult, SessionReleaseParams, SessionReleaseResult, Signal, SysinfoGetParams, SysinfoGetResult, VERSIONED_RESULT_OPS, announcedVersion, compareVersions, epochMs, forPeer, knows, negotiate, nonNegInt, statusForPeer, u32, versionSubprotocol };
+/** SHA-256 of generated/desktop-protocol.schema.json: the contract both sides of a service connection were built from. */
+declare const CONTRACT_SHA256: "ef9fd8c8ab611bf450730452a6cf48a4ebd566218b6e17e2834ef030fc2044cb";
+
+/**
+ * The local tool catalog (SPEC §10): every tool a platform agent calls on a person's computer, the
+ * protocol ops it reaches, the group it ships in, and what became of each of matrx-local's 139
+ * handlers (120 actions + the 19 action-enum dispatchers that fanned out to them).
+ *
+ * Data only. The status table (./status.ts) joins it with the harnesses' results, so a tool listed
+ * here with no passing result reads "untested", never "working". Design and the reasons behind each
+ * group: matrx-desktop/design/local-tools.md.
+ */
+
+type ToolGroupId = "files_shell" | "os_control" | "personal_automation" | "tools_service" | "ml_service" | "windows_admin";
+interface ToolGroup {
+    readonly id: ToolGroupId;
+    readonly order: number;
+    readonly title: string;
+    /** Who implements the ops: a TS capability owner in the core, or a Python service. */
+    readonly owner: "core" | "python_tools" | "python_ml";
+}
+declare const TOOL_GROUPS: readonly ToolGroup[];
+/**
+ * How an agent's call reaches the device. Both end at the relay's `POST /v1/devices/{id}/call`:
+ * - `sandbox_proxy`: the cloud-sandbox-shaped tools (fs_*, shell_*). matrx-ai's `_sandbox_proxy`
+ *   calls aidream `/api/local-proxy/{device}/{fs|search|exec}/…`, which maps the route to its op.
+ *   Agent code never knows a laptop from a cloud box (SPEC §6.1).
+ * - `device_op`: desktop-only capabilities. One generic route, `/api/local-proxy/{device}/op/{cap.op}`,
+ *   params and result exactly the op's schema; the tool definition is generated from that schema.
+ * - `server`: runs on the aidream server even when the turn is bound to a device (a defect when
+ *   the tool reads a local path; see `note`).
+ */
+type ToolPath = "sandbox_proxy" | "device_op" | "server";
+/** `built`: the ops exist and the tool is registered; `planned`: designed, not built; `broken`: registered but wrong on a device. */
+type ToolState = "built" | "planned" | "broken";
+interface CatalogTool {
+    /** The platform registry name (`tool.definition.name`). */
+    readonly name: string;
+    readonly group: ToolGroupId;
+    readonly state: ToolState;
+    readonly path: ToolPath;
+    /** Ops the tool sends. For `built` tools every one is in OPS (a test enforces it). */
+    readonly ops: readonly string[];
+    readonly platforms: readonly ToolPlatform[];
+    /** One line for the status table. */
+    readonly summary: string;
+    /** Required for `broken`: what is wrong. */
+    readonly note?: string;
+}
+declare const TOOL_CATALOG: readonly CatalogTool[];
+/** What became of one matrx-local handler. */
+type LegacyDisposition = {
+    readonly kind: "tool";
+    readonly tool: string;
+} | {
+    readonly kind: "dropped";
+    readonly reason: string;
+};
+/** matrx-local's 120 actions (`app/tools/actions.py` ACTION_GROUPS), keyed `<mega tool>.<action>`. */
+declare const LEGACY_ACTIONS: Readonly<Record<string, LegacyDisposition>>;
+/**
+ * matrx-local's 19 action-enum dispatchers. Each fanned an `action` out to the handlers above and
+ * did nothing else; they retire with the `matrx-local` executor binding (the platform reaches a
+ * device through the relay now, never by client delegation).
+ */
+declare const LEGACY_DISPATCHERS: readonly string[];
+/** Built tools' ops, typed: a built tool naming an op the protocol does not have fails to compile in the test. */
+declare function builtOps(): OpName[];
+
+/**
+ * The generated tool status table (SPEC §10): tool × level × platform, built ONLY from harness
+ * results (`ToolResultsFile`) joined with the catalog. Never written by hand; the one status anyone
+ * cites. `renderToolStatusMarkdown` is the committed text form; screens render `ToolStatus` itself.
+ */
+
+declare const TOOL_LEVELS: readonly ToolLevel[];
+declare const TOOL_PLATFORMS: readonly ToolPlatform[];
+/**
+ * `pass`: every required proof passed and none failed. `partial`: passes so far, a required proof
+ * missing (`missing` says which). `fail`: the latest run of some proof failed. `untested`: nothing
+ * ran. `not_built`: the tool is planned. `unsupported`: the tool does not exist on this platform.
+ */
+type CellState = "pass" | "partial" | "fail" | "untested" | "not_built" | "unsupported";
+interface StatusEvidence {
+    readonly suite: string;
+    readonly test: string;
+    readonly transport: ToolTransport;
+    readonly outcome: ToolLevelResult["outcome"];
+    readonly remote_network: boolean;
+    readonly commit: string;
+    readonly run_at_ms: number;
+    readonly detail: string;
+}
+interface StatusCell {
+    readonly state: CellState;
+    /** Required proofs not yet passed, e.g. "relay from another network". */
+    readonly missing: readonly string[];
+    readonly last_run_at_ms: number | null;
+    readonly evidence: readonly StatusEvidence[];
+}
+interface StatusRow {
+    readonly tool: string;
+    readonly group: ToolGroupId;
+    readonly tool_state: ToolState;
+    readonly summary: string;
+    readonly note: string | null;
+    readonly cells: Readonly<Record<ToolPlatform, Readonly<Record<ToolLevel, StatusCell>>>>;
+    /** Working on a platform = all three levels pass there (SPEC §10). */
+    readonly working: Readonly<Record<ToolPlatform, boolean>>;
+}
+interface ToolStatus {
+    readonly schema: "matrx.tool-status.v1";
+    readonly generated_at_ms: number;
+    readonly commits: readonly string[];
+    readonly rows: readonly StatusRow[];
+    readonly totals: Readonly<Record<ToolPlatform, {
+        readonly working: number;
+        readonly built: number;
+        readonly tools: number;
+    }>>;
+}
+/** Build the table from every results file. Throws when a file is off-contract (never silently skipped). */
+declare function buildToolStatus(files: readonly unknown[], opts: {
+    readonly generatedAtMs: number;
+}): ToolStatus;
+/** The committed text form. Columns: per platform, the three levels (P = programmatic, R = protocol, C = chat). */
+declare function renderToolStatusMarkdown(status: ToolStatus): string;
+
+export { AbsPath, AppFeatureStatus, AppInfo, AppKey, AppProfile, AppProfileId, AppProfileLocator, AppSupport, AppUsageReading, AppsListParams, AppsListResult, AppsOpenParams, AppsOpenResult, AppsProfilesListParams, AppsProfilesListResult, AppsProfilesRemoveParams, AppsProfilesRemoveResult, AppsProfilesSaveParams, AppsProfilesSaveResult, CONTRACT_SHA256, type CatalogTool, type CellState, ContractHash, CoreToServiceMsg, DEFAULT_MAX_FRAME_PAYLOAD_BYTES, DEFAULT_MAX_MESSAGE_BYTES, DEFAULT_WINDOW_BYTES, DeviceId, ExecCwdEvent, ExecExitedEvent, ExecListParams, ExecListResult, ExecPtyKillParams, ExecPtyKillResult, ExecPtyResizeParams, ExecPtyResizeResult, ExecPtySignalParams, ExecPtySignalResult, ExecPtyStartParams, ExecPtyStartResult, ExecPtyWriteParams, ExecPtyWriteResult, ExecRunParams, ExecRunResult, ExecTitleEvent, FIELDS_SINCE, type FieldsSincePath, FrameHeader, FsChange, FsChangedEvent, FsDeleteParams, FsDeleteResult, FsEncoding, FsEntry, FsKind, FsListParams, FsListResult, FsMkdirParams, FsMkdirResult, FsMoveParams, FsMoveResult, FsPatchEditApplied, FsPatchParams, FsPatchResult, FsReadParams, FsReadResult, FsReadStreamParams, FsReadStreamResult, FsSearchContentParams, FsSearchContentResult, FsSearchPathsParams, FsSearchPathsResult, FsStatParams, FsStatResult, FsWatchParams, FsWatchResult, FsWriteParams, FsWriteResult, LEGACY_ACTIONS, LEGACY_DISPATCHERS, type LegacyDisposition, MlInstallPhase, MlInstallProgress, MlProgress, MlRuntimeState, MlServiceState, MlServiceStatus, MlStatusParams, MlStatusResult, ModelsInstallParams, ModelsInstallResult, ModelsProgressEvent, ModelsStatusParams, ModelsStatusResult, ModelsTranscribeParams, ModelsTranscribeResult, NULL_SINCE, OpName, OsPermissionName, PROTOCOL_MAJOR, PROTOCOL_MINOR, PROTOCOL_VERSION, ProtocolVersion, PtyInfo, REASONS_SINCE, RELAY_CALL_HELLO_ID, RELAY_CALL_REQUEST_ID, RELAY_CALL_VERSION_HEADER, RelayAuthExpiringEvent, RelayCallEnvelope, RelayCallHello, RelayCallRequest, RelayCallResponse, RelayDeviceStatusEvent, RelayHopConnectionEnd, RelayHopEnvelopeHeader, RelayStatusResponse, RequestId, ResourceId, ResourceInfo, SERVICE_MAX_FRAME_BYTES, ServiceCancel, ServiceErrorMsg, ServiceHello, ServiceName, ServicePing, ServicePong, ServiceProgressMsg, ServiceRequest, ServiceResponse, ServiceShutdown, ServiceToCoreMsg, ServiceToken, ServiceWelcome, SessionAttachParams, SessionAttachResult, SessionControlChangedEvent, SessionDetachParams, SessionDetachResult, SessionListParams, SessionListResult, SessionReleaseParams, SessionReleaseResult, Signal, type StatusCell, type StatusEvidence, type StatusRow, SysinfoGetParams, SysinfoGetResult, TOOL_CATALOG, TOOL_GROUPS, TOOL_LEVELS, TOOL_PLATFORMS, type ToolGroup, type ToolGroupId, ToolLevel, ToolLevelResult, ToolName, ToolOutcome, type ToolPath, ToolPlatform, ToolResultsFile, type ToolState, type ToolStatus, ToolTransport, TranscriptSegment, TranscriptionModelId, TranscriptionModelInfo, VERSIONED_RESULT_OPS, announcedVersion, buildToolStatus, builtOps, compareVersions, epochMs, forPeer, knows, negotiate, nonNegInt, renderToolStatusMarkdown, statusForPeer, u32, versionSubprotocol };