@aria-cli/tools 1.0.0

package/dist-cjs/network-runtime/local-control-contract.d.ts

@@ -0,0 +1,752 @@
+import { z } from "zod";
+import type { Message } from "@aria/types";
+import { AcceptInviteRequestSchema } from "./pair-route-contract.js";
+import type { AcceptInviteRequest } from "./pair-route-contract.js";
+export { AcceptInviteRequestSchema };
+export type { AcceptInviteRequest };
+export declare const RunRequestSchema: z.ZodObject<{
+    task: z.ZodString;
+    arion: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    history: z.ZodOptional<z.ZodArray<z.ZodCustom<Message, Message>>>;
+    preferredTier: z.ZodOptional<z.ZodEnum<{
+        fast: "fast";
+        balanced: "balanced";
+        powerful: "powerful";
+        ensemble: "ensemble";
+    }>>;
+    budget: z.ZodOptional<z.ZodNumber>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    autonomy: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        minimal: "minimal";
+        high: "high";
+        full: "full";
+    }>>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deniedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noMemory: z.ZodOptional<z.ZodBoolean>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    approvalMode: z.ZodOptional<z.ZodEnum<{
+        pause: "pause";
+        approve: "approve";
+        deny: "deny";
+    }>>;
+    askUserAnswers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type RunRequest = z.infer<typeof RunRequestSchema>;
+export declare const RuntimeErrorDiagnosticSchema: z.ZodType<Record<string, unknown>>;
+export type RuntimeErrorDiagnostic = z.infer<typeof RuntimeErrorDiagnosticSchema>;
+export declare function resolveTrustedRuntimeErrorMessage(message: string | undefined, diagnostic: unknown): string | undefined;
+export declare function createTrustedRuntimeError(message: string | undefined, diagnostic: unknown): Error;
+export declare const RunResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    output: z.ZodOptional<z.ZodString>;
+    messages: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    usage: z.ZodOptional<z.ZodUnknown>;
+    turnCount: z.ZodOptional<z.ZodNumber>;
+    thinking: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    nativeToolResults: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    traces: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    pipelineTiming: z.ZodOptional<z.ZodUnknown>;
+    guardrailEvents: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    handoffs: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    state: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    diagnostic: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+}, z.core.$strict>;
+export type RunResult = z.infer<typeof RunResultSchema>;
+export declare const ResumeRunRequestSchema: z.ZodObject<{
+    state: z.ZodUnknown;
+    arion: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    preferredTier: z.ZodOptional<z.ZodEnum<{
+        fast: "fast";
+        balanced: "balanced";
+        powerful: "powerful";
+        ensemble: "ensemble";
+    }>>;
+    budget: z.ZodOptional<z.ZodNumber>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    autonomy: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        minimal: "minimal";
+        high: "high";
+        full: "full";
+    }>>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deniedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noMemory: z.ZodOptional<z.ZodBoolean>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    approvalMode: z.ZodOptional<z.ZodEnum<{
+        pause: "pause";
+        approve: "approve";
+        deny: "deny";
+    }>>;
+    askUserAnswers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ResumeRunRequest = z.infer<typeof ResumeRunRequestSchema>;
+export declare const RuntimeRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text_delta">;
+    content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_start">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"approval_needed">;
+    toolName: z.ZodString;
+    toolInput: z.ZodOptional<z.ZodUnknown>;
+    riskLevel: z.ZodOptional<z.ZodString>;
+    issues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    id: z.ZodString;
+    name: z.ZodString;
+    durationMs: z.ZodNumber;
+    result: z.ZodUnknown;
+    input: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"usage_update">;
+    usage: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"turn_complete">;
+    turnNumber: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"guardrail_rejected">;
+    stage: z.ZodEnum<{
+        input: "input";
+        output: "output";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pipeline_timing">;
+    report: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"messages_snapshot">;
+    messages: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        message: z.ZodString;
+        diagnostic: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"native_tool_result">;
+    metadata: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"thinking_start">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"thinking_delta">;
+    content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"thinking_end">;
+    blocks: z.ZodArray<z.ZodUnknown>;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_args_delta">;
+    id: z.ZodString;
+    args: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"span_start">;
+    spanId: z.ZodString;
+    spanType: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"span_end">;
+    spanId: z.ZodString;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"handoff_start">;
+    target: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"handoff_result">;
+    target: z.ZodString;
+    result: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"paused">;
+    state: z.ZodUnknown;
+}, z.core.$strip>], "type">;
+export type RuntimeRunEvent = z.infer<typeof RuntimeRunEventSchema>;
+export declare const RuntimeQueuedReceiptSchema: z.ZodPipe<z.ZodObject<{
+    transport: z.ZodEnum<{
+        in_process: "in_process";
+        local_runtime: "local_runtime";
+        tunnel: "tunnel";
+        relay: "relay";
+    }>;
+    delivered: z.ZodBoolean;
+    queued: z.ZodBoolean;
+    accepted: z.ZodOptional<z.ZodBoolean>;
+    deliveryState: z.ZodOptional<z.ZodEnum<{
+        accepted: "accepted";
+        queued_for_route: "queued_for_route";
+        dispatching: "dispatching";
+        sent: "sent";
+        acked: "acked";
+        expired: "expired";
+        failed: "failed";
+        rejected: "rejected";
+    }>>;
+    sessionState: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        handshaking: "handshaking";
+        connected: "connected";
+        reconnecting: "reconnecting";
+        dead: "dead";
+    }>>;
+    deliveryReadiness: z.ZodOptional<z.ZodEnum<{
+        cannot_address: "cannot_address";
+        can_queue_only: "can_queue_only";
+        can_send_now: "can_send_now";
+    }>>;
+    queuedReason: z.ZodOptional<z.ZodEnum<{
+        route_not_established: "route_not_established";
+        awaiting_remote_ack: "awaiting_remote_ack";
+        transport_unavailable: "transport_unavailable";
+    }>>;
+}, z.core.$strict>, z.ZodTransform<import("./delivery-receipts.js").CanonicalDeliveryReceipt, {
+    transport: "in_process" | "local_runtime" | "tunnel" | "relay";
+    delivered: boolean;
+    queued: boolean;
+    accepted?: boolean | undefined;
+    deliveryState?: "accepted" | "queued_for_route" | "dispatching" | "sent" | "acked" | "expired" | "failed" | "rejected" | undefined;
+    sessionState?: "none" | "handshaking" | "connected" | "reconnecting" | "dead" | undefined;
+    deliveryReadiness?: "cannot_address" | "can_queue_only" | "can_send_now" | undefined;
+    queuedReason?: "route_not_established" | "awaiting_remote_ack" | "transport_unavailable" | undefined;
+}>>;
+export type RuntimeQueuedReceipt = z.infer<typeof RuntimeQueuedReceiptSchema>;
+export declare const RuntimeDeliveryReceiptSchema: z.ZodPipe<z.ZodObject<{
+    transport: z.ZodEnum<{
+        in_process: "in_process";
+        local_runtime: "local_runtime";
+        tunnel: "tunnel";
+        relay: "relay";
+    }>;
+    delivered: z.ZodBoolean;
+    queued: z.ZodBoolean;
+    accepted: z.ZodOptional<z.ZodBoolean>;
+    deliveryState: z.ZodOptional<z.ZodEnum<{
+        accepted: "accepted";
+        queued_for_route: "queued_for_route";
+        dispatching: "dispatching";
+        sent: "sent";
+        acked: "acked";
+        expired: "expired";
+        failed: "failed";
+        rejected: "rejected";
+    }>>;
+    sessionState: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        handshaking: "handshaking";
+        connected: "connected";
+        reconnecting: "reconnecting";
+        dead: "dead";
+    }>>;
+    deliveryReadiness: z.ZodOptional<z.ZodEnum<{
+        cannot_address: "cannot_address";
+        can_queue_only: "can_queue_only";
+        can_send_now: "can_send_now";
+    }>>;
+    queuedReason: z.ZodOptional<z.ZodEnum<{
+        route_not_established: "route_not_established";
+        awaiting_remote_ack: "awaiting_remote_ack";
+        transport_unavailable: "transport_unavailable";
+    }>>;
+    storedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    storedAt?: number | undefined;
+    transport: import("./delivery-receipts.js").RuntimeTransport;
+    delivered: boolean;
+    queued: boolean;
+    accepted: boolean;
+    deliveryState: import("./delivery-receipts.js").DeliveryState;
+    sessionState: import("./delivery-receipts.js").SessionState;
+    deliveryReadiness: import("./delivery-receipts.js").DeliveryReadiness;
+    queuedReason?: import("./delivery-receipts.js").QueuedReason;
+}, {
+    transport: "in_process" | "local_runtime" | "tunnel" | "relay";
+    delivered: boolean;
+    queued: boolean;
+    accepted?: boolean | undefined;
+    deliveryState?: "accepted" | "queued_for_route" | "dispatching" | "sent" | "acked" | "expired" | "failed" | "rejected" | undefined;
+    sessionState?: "none" | "handshaking" | "connected" | "reconnecting" | "dead" | undefined;
+    deliveryReadiness?: "cannot_address" | "can_queue_only" | "can_send_now" | undefined;
+    queuedReason?: "route_not_established" | "awaiting_remote_ack" | "transport_unavailable" | undefined;
+    storedAt?: number | undefined;
+}>>;
+export type RuntimeDeliveryReceipt = z.infer<typeof RuntimeDeliveryReceiptSchema>;
+export declare const OutboundMessageSchema: z.ZodObject<{
+    rawMessage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    recipientInbox: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node">;
+        nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"client">;
+        clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+    }, z.core.$strip>], "kind">>;
+    to: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    correlationId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type OutboundMessage = z.infer<typeof OutboundMessageSchema>;
+export declare const RuntimeEventCursorSchema: z.ZodObject<{
+    afterRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type RuntimeEventCursor = z.infer<typeof RuntimeEventCursorSchema>;
+export declare const InboxCursorSchema: z.ZodObject<{
+    afterCreatedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type InboxCursor = z.infer<typeof InboxCursorSchema>;
+export declare const InboxListRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodObject<{
+        afterCreatedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    unreadOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type InboxListRequest = z.infer<typeof InboxListRequestSchema>;
+export declare const PersistedInboxEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    senderNodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    senderDisplayNameSnapshot: z.ZodOptional<z.ZodString>;
+    senderType: z.ZodOptional<z.ZodString>;
+    inboxAddress: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node">;
+        nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"client">;
+        clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+    }, z.core.$strip>], "kind">;
+    type: z.ZodString;
+    content: z.ZodString;
+    priority: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    correlationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    replyTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type PersistedInboxEvent = z.infer<typeof PersistedInboxEventSchema>;
+export declare const PeerViewEventSchema: z.ZodObject<{
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    transportPublicKey: z.core.$ZodBranded<z.ZodString, "PeerTransportId", "out">;
+    displayNameSnapshot: z.ZodOptional<z.ZodString>;
+    identityState: z.ZodEnum<{
+        invited: "invited";
+        joining: "joining";
+        paired_unverified: "paired_unverified";
+        verified: "verified";
+        revoked: "revoked";
+    }>;
+    transportState: z.ZodEnum<{
+        unknown: "unknown";
+        connected: "connected";
+        endpoint_known: "endpoint_known";
+        connecting: "connecting";
+        degraded: "degraded";
+        disconnected: "disconnected";
+    }>;
+    endpointRevision: z.ZodNumber;
+    updatedAt: z.ZodString;
+    lastSeenAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PeerViewEvent = z.infer<typeof PeerViewEventSchema>;
+export declare const NearbyPeerViewSchema: z.ZodObject<{
+    displayNameSnapshot: z.ZodString;
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    host: z.ZodString;
+    port: z.ZodNumber;
+    principalFingerprint: z.core.$ZodBranded<z.ZodString, "PrincipalFingerprint", "out">;
+    version: z.ZodString;
+    tlsCaFingerprint: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TlsCaFingerprint", "out">>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        lan: "lan";
+        wan: "wan";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        connected: "connected";
+        discovered: "discovered";
+    }>>;
+}, z.core.$strict>;
+export type NearbyPeerView = z.infer<typeof NearbyPeerViewSchema>;
+export declare const RuntimeAutonomousLoopSafetyPolicySummarySchema: z.ZodObject<{
+    allowedToolCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowedShellCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxWriteOpsPerMinute: z.ZodOptional<z.ZodNumber>;
+    maxGitPushesPerHour: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type RuntimeAutonomousLoopSafetyPolicySummary = z.infer<typeof RuntimeAutonomousLoopSafetyPolicySummarySchema>;
+export declare const RuntimeAutonomousLoopStatusSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        running: "running";
+        stopped: "stopped";
+    }>;
+    intervalMs: z.ZodNullable<z.ZodNumber>;
+    lastWakeTickAt: z.ZodNullable<z.ZodString>;
+    lastCheckpointResult: z.ZodEnum<{
+        never: "never";
+        success: "success";
+        error: "error";
+    }>;
+    safetyPolicySummary: z.ZodObject<{
+        allowedToolCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowedShellCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxWriteOpsPerMinute: z.ZodOptional<z.ZodNumber>;
+        maxGitPushesPerHour: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    ownerClientKind: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type RuntimeAutonomousLoopStatus = z.infer<typeof RuntimeAutonomousLoopStatusSchema>;
+export declare const RuntimeStatusSchema: z.ZodObject<{
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    runtimeId: z.core.$ZodBranded<z.ZodString, "RuntimeId", "out">;
+    port: z.ZodNumber;
+    attachedClients: z.ZodOptional<z.ZodNumber>;
+    autonomousLoop: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            running: "running";
+            stopped: "stopped";
+        }>;
+        intervalMs: z.ZodNullable<z.ZodNumber>;
+        lastWakeTickAt: z.ZodNullable<z.ZodString>;
+        lastCheckpointResult: z.ZodEnum<{
+            never: "never";
+            success: "success";
+            error: "error";
+        }>;
+        safetyPolicySummary: z.ZodObject<{
+            allowedToolCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowedShellCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            maxWriteOpsPerMinute: z.ZodOptional<z.ZodNumber>;
+            maxGitPushesPerHour: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        ownerClientKind: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RuntimeStatus = z.infer<typeof RuntimeStatusSchema>;
+export declare const RuntimeAutonomousLoopCommandSchema: z.ZodObject<{
+    intervalMs: z.ZodOptional<z.ZodNumber>;
+    safetyPolicy: z.ZodOptional<z.ZodObject<{
+        allowedToolCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowedShellCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxWriteOpsPerMinute: z.ZodOptional<z.ZodNumber>;
+        maxGitPushesPerHour: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RuntimeAutonomousLoopCommand = z.infer<typeof RuntimeAutonomousLoopCommandSchema>;
+export declare const PendingPairRequestViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    displayNameSnapshot: z.ZodOptional<z.ZodString>;
+    principalFingerprint: z.core.$ZodBranded<z.ZodString, "PrincipalFingerprint", "out">;
+}, z.core.$strict>;
+export type PendingPairRequestView = z.infer<typeof PendingPairRequestViewSchema>;
+export declare const PendingInviteViewSchema: z.ZodObject<{
+    inviteId: z.ZodString;
+    inviteLabel: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type PendingInviteView = z.infer<typeof PendingInviteViewSchema>;
+export declare const PairRequestDecisionSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    accepted: z.ZodBoolean;
+}, z.core.$strict>;
+export type PairRequestDecision = z.infer<typeof PairRequestDecisionSchema>;
+export declare const PairRequestResponseSchema: z.ZodObject<{
+    accepted: z.ZodOptional<z.ZodBoolean>;
+    inviteToken: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PairRequestResponse = z.infer<typeof PairRequestResponseSchema>;
+export declare const CreateInviteRequestSchema: z.ZodObject<{
+    inviteLabel: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreateInviteRequest = z.infer<typeof CreateInviteRequestSchema>;
+export declare const CreateInviteResponseSchema: z.ZodObject<{
+    inviteToken: z.ZodString;
+    pendingInvite: z.ZodObject<{
+        inviteId: z.ZodString;
+        inviteLabel: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CreateInviteResponse = z.infer<typeof CreateInviteResponseSchema>;
+export declare const InvitePeerRequestSchema: z.ZodObject<{
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    displayName: z.ZodString;
+    principalFingerprint: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "PrincipalFingerprint", "out">>;
+    controlEndpoint: z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+        tlsCaFingerprint: z.core.$ZodBranded<z.ZodString, "TlsCaFingerprint", "out">;
+        tlsServerIdentity: z.core.$ZodBranded<z.ZodString, "PrincipalFingerprint", "out">;
+        protocolVersion: z.ZodNumber;
+        endpointRevision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    transportEndpoint: z.ZodOptional<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strip>>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        lan: "lan";
+        wan: "wan";
+    }>>;
+}, z.core.$strict>;
+export type InvitePeerRequest = z.infer<typeof InvitePeerRequestSchema>;
+export declare const PairingProofStateSchema: z.ZodEnum<{
+    pending_verification: "pending_verification";
+}>;
+export type PairingProofState = z.infer<typeof PairingProofStateSchema>;
+export declare const InvitePeerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    displayNameSnapshot: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"lan_direct">;
+    pairingProofState: z.ZodLiteral<"pending_verification">;
+}, z.core.$strict>, z.ZodObject<{
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    displayNameSnapshot: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"wan_pair">;
+    pairingProofState: z.ZodLiteral<"pending_verification">;
+}, z.core.$strict>], "mode">;
+export type InvitePeerResult = z.infer<typeof InvitePeerResultSchema>;
+export declare const AcceptInviteResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    displayNameSnapshot: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AcceptInviteResponse = z.infer<typeof AcceptInviteResponseSchema>;
+export declare const AcceptInviteTokenRequestSchema: z.ZodObject<{
+    inviteToken: z.ZodString;
+}, z.core.$strict>;
+export type AcceptInviteTokenRequest = z.infer<typeof AcceptInviteTokenRequestSchema>;
+export declare const AcceptInviteTokenResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    displayNameSnapshot: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AcceptInviteTokenResponse = z.infer<typeof AcceptInviteTokenResponseSchema>;
+export declare const CancelInviteRequestSchema: z.ZodObject<{
+    inviteId: z.ZodString;
+}, z.core.$strict>;
+export type CancelInviteRequest = z.infer<typeof CancelInviteRequestSchema>;
+export declare const CancelInviteResponseSchema: z.ZodObject<{
+    cancelled: z.ZodBoolean;
+    inviteId: z.ZodString;
+}, z.core.$strict>;
+export type CancelInviteResponse = z.infer<typeof CancelInviteResponseSchema>;
+export declare const DirectPairRequestSchema: z.ZodObject<{
+    peerNodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    principalFingerprint: z.core.$ZodBranded<z.ZodString, "PrincipalFingerprint", "out">;
+    peerDisplayName: z.ZodOptional<z.ZodString>;
+    peerWgPubkey: z.core.$ZodBranded<z.ZodString, "PeerTransportId", "out">;
+    peerSigningPubkey: z.ZodString;
+    transportEndpoint: z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strip>;
+    controlEndpoint: z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+        tlsCaFingerprint: z.core.$ZodBranded<z.ZodString, "TlsCaFingerprint", "out">;
+        tlsServerIdentity: z.core.$ZodBranded<z.ZodString, "PrincipalFingerprint", "out">;
+        protocolVersion: z.ZodNumber;
+        endpointRevision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    psk: z.ZodString;
+}, z.core.$strict>;
+export type DirectPairRequest = z.infer<typeof DirectPairRequestSchema>;
+export declare const DirectPairRequestJsonSchema: Record<string, unknown>;
+export declare const DirectPairResponseSchema: z.ZodObject<{
+    received: z.ZodLiteral<true>;
+    pairingProofState: z.ZodLiteral<"pending_verification">;
+}, z.core.$strict>;
+export type DirectPairResponse = z.infer<typeof DirectPairResponseSchema>;
+export declare const RevokePeerRequestSchema: z.ZodObject<{
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    envelope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type RevokePeerRequest = z.infer<typeof RevokePeerRequestSchema>;
+export declare const RevokePeerResponseSchema: z.ZodObject<{
+    revoked: z.ZodBoolean;
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    displayNameSnapshot: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RevokePeerResponse = z.infer<typeof RevokePeerResponseSchema>;
+export declare const RepairPeerRequestSchema: z.ZodObject<{
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    endpointHost: z.ZodString;
+    endpointPort: z.ZodNumber;
+    endpointRevision: z.ZodNumber;
+}, z.core.$strict>;
+export type RepairPeerRequest = z.infer<typeof RepairPeerRequestSchema>;
+export declare const RepairPeerResponseSchema: z.ZodObject<{
+    repaired: z.ZodBoolean;
+    nodeId: z.core.$ZodBranded<z.ZodString, "NodeId", "out">;
+    endpointHost: z.ZodString;
+    endpointPort: z.ZodNumber;
+    endpointRevision: z.ZodNumber;
+}, z.core.$strict>;
+export type RepairPeerResponse = z.infer<typeof RepairPeerResponseSchema>;
+export declare const LocalControlClientKindSchema: z.ZodEnum<{
+    pipe: "pipe";
+    tui: "tui";
+    "daemon-launcher": "daemon-launcher";
+    "local-api": "local-api";
+}>;
+export type LocalControlClientKind = z.infer<typeof LocalControlClientKindSchema>;
+export declare const AttachedClientViewSchema: z.ZodObject<{
+    clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+    clientKind: z.ZodEnum<{
+        pipe: "pipe";
+        tui: "tui";
+        "daemon-launcher": "daemon-launcher";
+        "local-api": "local-api";
+    }>;
+    displayLabel: z.ZodString;
+    self: z.ZodBoolean;
+    attachedAt: z.ZodString;
+    lastSeenAt: z.ZodString;
+}, z.core.$strict>;
+export type AttachedClientView = z.infer<typeof AttachedClientViewSchema>;
+export declare const AttachedClientLeaseGrantSchema: z.ZodObject<{
+    clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+    clientAuthToken: z.ZodString;
+}, z.core.$strict>;
+export type AttachedClientLeaseGrant = z.infer<typeof AttachedClientLeaseGrantSchema>;
+export declare const AttachedClientAuthSchema: z.ZodObject<{
+    clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+    clientAuthToken: z.ZodString;
+}, z.core.$strict>;
+export type AttachedClientAuth = z.infer<typeof AttachedClientAuthSchema>;
+export declare const LocalControlSocketAttachClientRequestSchema: z.ZodObject<{
+    clientKind: z.ZodEnum<{
+        pipe: "pipe";
+        tui: "tui";
+        "daemon-launcher": "daemon-launcher";
+        "local-api": "local-api";
+    }>;
+    lease: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type LocalControlSocketAttachClientRequest = z.infer<typeof LocalControlSocketAttachClientRequestSchema>;
+export declare const LocalControlSocketAttachClientResponseSchema: z.ZodObject<{
+    clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+    clientAuthToken: z.ZodString;
+}, z.core.$strict>;
+export type LocalControlSocketAttachClientResponse = z.infer<typeof LocalControlSocketAttachClientResponseSchema>;
+export declare const LocalControlSocketDetachClientRequestSchema: z.ZodObject<{
+    clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+}, z.core.$strict>;
+export type LocalControlSocketDetachClientRequest = z.infer<typeof LocalControlSocketDetachClientRequestSchema>;
+export declare const LocalControlSocketDetachClientResponseSchema: z.ZodObject<{
+    detached: z.ZodBoolean;
+}, z.core.$strict>;
+export type LocalControlSocketDetachClientResponse = z.infer<typeof LocalControlSocketDetachClientResponseSchema>;
+export declare const LocalControlSocketMethodSchema: z.ZodEnum<{
+    submitRun: "submitRun";
+    resumeRun: "resumeRun";
+    streamRun: "streamRun";
+    subscribeRuntimeEvents: "subscribeRuntimeEvents";
+    sendBestEffort: "sendBestEffort";
+    sendDurable: "sendDurable";
+    listInbox: "listInbox";
+    listDirectClientInbox: "listDirectClientInbox";
+    listPeers: "listPeers";
+    listNearbyPeers: "listNearbyPeers";
+    listAttachedClients: "listAttachedClients";
+    subscribeDirectClientInbox: "subscribeDirectClientInbox";
+    getRuntimeStatus: "getRuntimeStatus";
+    startAutonomousLoop: "startAutonomousLoop";
+    stopAutonomousLoop: "stopAutonomousLoop";
+    getRuntimeBootstrap: "getRuntimeBootstrap";
+    listPendingPairRequests: "listPendingPairRequests";
+    respondToPairRequest: "respondToPairRequest";
+    createInvite: "createInvite";
+    listPendingInvites: "listPendingInvites";
+    acceptInviteToken: "acceptInviteToken";
+    cancelInvite: "cancelInvite";
+    invitePeer: "invitePeer";
+    acceptInvite: "acceptInvite";
+    directPair: "directPair";
+    revokePeer: "revokePeer";
+    repairPeer: "repairPeer";
+    attachClient: "attachClient";
+    detachClient: "detachClient";
+    watchInbox: "watchInbox";
+}>;
+export type LocalControlSocketMethod = z.infer<typeof LocalControlSocketMethodSchema>;
+export declare const LocalControlSocketRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        submitRun: "submitRun";
+        resumeRun: "resumeRun";
+        streamRun: "streamRun";
+        subscribeRuntimeEvents: "subscribeRuntimeEvents";
+        sendBestEffort: "sendBestEffort";
+        sendDurable: "sendDurable";
+        listInbox: "listInbox";
+        listDirectClientInbox: "listDirectClientInbox";
+        listPeers: "listPeers";
+        listNearbyPeers: "listNearbyPeers";
+        listAttachedClients: "listAttachedClients";
+        subscribeDirectClientInbox: "subscribeDirectClientInbox";
+        getRuntimeStatus: "getRuntimeStatus";
+        startAutonomousLoop: "startAutonomousLoop";
+        stopAutonomousLoop: "stopAutonomousLoop";
+        getRuntimeBootstrap: "getRuntimeBootstrap";
+        listPendingPairRequests: "listPendingPairRequests";
+        respondToPairRequest: "respondToPairRequest";
+        createInvite: "createInvite";
+        listPendingInvites: "listPendingInvites";
+        acceptInviteToken: "acceptInviteToken";
+        cancelInvite: "cancelInvite";
+        invitePeer: "invitePeer";
+        acceptInvite: "acceptInvite";
+        directPair: "directPair";
+        revokePeer: "revokePeer";
+        repairPeer: "repairPeer";
+        attachClient: "attachClient";
+        detachClient: "detachClient";
+        watchInbox: "watchInbox";
+    }>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    auth: z.ZodOptional<z.ZodObject<{
+        clientId: z.core.$ZodBranded<z.ZodString, "ClientId", "out">;
+        clientAuthToken: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LocalControlSocketRequest = z.infer<typeof LocalControlSocketRequestSchema>;
+export declare const LocalControlSocketSuccessResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type LocalControlSocketSuccessResponse = z.infer<typeof LocalControlSocketSuccessResponseSchema>;
+export declare const LocalControlSocketErrorResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    diagnostic: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+}, z.core.$strict>;
+export type LocalControlSocketErrorResponse = z.infer<typeof LocalControlSocketErrorResponseSchema>;
+export declare const LocalControlSocketResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    diagnostic: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+}, z.core.$strict>], "ok">;
+export type LocalControlSocketResponse = z.infer<typeof LocalControlSocketResponseSchema>;