@aria-cli/tools 1.0.12 → 1.0.14

package/dist/headless-control-contract.js

@@ -1,967 +0,0 @@
-import { z } from "zod";
-import { AcceptInviteTokenRequestSchema, AcceptInviteTokenResponseSchema, AttachedClientViewSchema, CreateInviteRequestSchema, CreateInviteResponseSchema, DirectPairRequestSchema, DirectPairResponseSchema, InboxListRequestSchema, InvitePeerRequestSchema, InvitePeerResultSchema, NearbyPeerViewSchema, OutboundMessageSchema, PairRequestDecisionSchema, PairRequestResponseSchema, PendingPairRequestViewSchema, PersistedInboxEventSchema, PeerViewEventSchema, RepairPeerRequestSchema, RepairPeerResponseSchema, RevokePeerRequestSchema, RevokePeerResponseSchema, ResumeRunRequestSchema, RuntimeDeliveryReceiptSchema, RuntimeQueuedReceiptSchema, RuntimeRunEventSchema, RuntimeStatusSchema, RunRequestSchema, RunResultSchema, } from "./network-runtime/local-control-contract.js";
-const NonEmptyStringSchema = z.string().trim().min(1);
-const PositiveIntSchema = z.number().int().positive();
-const NonNegativeIntSchema = z.number().int().nonnegative();
-const LooseObjectSchema = z.object({}).catchall(z.unknown());
-const EmptyObjectSchema = z.object({}).strict();
-const IsoDatetimeSchema = z.string().datetime({ offset: true }).or(z.string().min(1));
-const AutonomySchema = z.enum(["minimal", "balanced", "high", "full"]);
-export const HEADLESS_OPERATION_NAMES = [
-    "run.start",
-    "run.resume",
-    "run.abort",
-    "interaction.respond",
-    "session.list",
-    "session.read",
-    "session.load",
-    "session.fork",
-    "memory.remember",
-    "memory.recall",
-    "memory.list",
-    "memory.forget",
-    "memory.recall_knowledge",
-    "arion.list",
-    "arion.hatch",
-    "arion.become",
-    "arion.rest",
-    "arion.wake",
-    "arion.create",
-    "model.list",
-    "model.set",
-    "model.refresh",
-    "auth.status",
-    "auth.login",
-    "auth.logout",
-    "peer.list",
-    "peer.list_nearby",
-    "peer.pending.list",
-    "peer.pending.respond",
-    "peer.invite",
-    "peer.connect",
-    "peer.accept_invite",
-    "peer.direct_pair",
-    "peer.repair",
-    "peer.revoke",
-    "client.list",
-    "client.inbox.list",
-    "message.send",
-    "message.inbox.list",
-    "config.theme.get",
-    "config.theme.set",
-    "config.autonomy.get",
-    "config.autonomy.set",
-    "system.restart",
-    "system.terminal_setup",
-    "daemon.start",
-    "daemon.status",
-    "daemon.stop",
-    "hook.extract",
-    "hook.reflect",
-    "hook.consolidate",
-    "hook.ingest",
-    "hook.harvest",
-];
-export const HeadlessOperationNameSchema = z.enum(HEADLESS_OPERATION_NAMES);
-export const HeadlessRequestIdSchema = NonEmptyStringSchema;
-export const HeadlessInteractionIdSchema = NonEmptyStringSchema;
-export const HeadlessInteractionSourceSchema = z.enum(["run", "auth", "system", "peer"]);
-export const HeadlessInteractionQuestionSchema = z
-    .object({
-    question: NonEmptyStringSchema,
-    options: z.array(NonEmptyStringSchema).optional(),
-})
-    .strict();
-export const HeadlessSelectionOptionSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    label: NonEmptyStringSchema,
-    description: z.string().optional(),
-})
-    .strict();
-export const HeadlessCredentialFieldSchema = z
-    .object({
-    key: NonEmptyStringSchema,
-    label: NonEmptyStringSchema,
-    placeholder: z.string().optional(),
-    secret: z.boolean().optional(),
-})
-    .strict();
-export const HeadlessToolApprovalPayloadSchema = z
-    .object({
-    kind: z.literal("tool_approval"),
-    prompt: z.string().optional(),
-    toolName: NonEmptyStringSchema,
-    toolInput: z.unknown().optional(),
-    riskLevel: z.string().optional(),
-    issues: z.array(z.string()).optional(),
-})
-    .strict();
-export const HeadlessQuestionnairePayloadSchema = z
-    .object({
-    kind: z.literal("questionnaire"),
-    prompt: z.string().optional(),
-    questions: z.array(HeadlessInteractionQuestionSchema).min(1),
-})
-    .strict();
-export const HeadlessSelectionPayloadSchema = z
-    .object({
-    kind: z.literal("selection"),
-    prompt: NonEmptyStringSchema,
-    options: z.array(HeadlessSelectionOptionSchema).min(1),
-})
-    .strict();
-export const HeadlessCredentialInputPayloadSchema = z
-    .object({
-    kind: z.literal("credential_input"),
-    prompt: NonEmptyStringSchema,
-    provider: NonEmptyStringSchema.optional(),
-    mode: z.enum(["generic", "oauth_authorization_code"]).optional(),
-    authorizeUrl: NonEmptyStringSchema.optional(),
-    callbackMode: z.enum(["manual_code", "local_callback"]).optional(),
-    expectedState: NonEmptyStringSchema.optional(),
-    fields: z.array(HeadlessCredentialFieldSchema).min(1),
-})
-    .strict();
-export const HeadlessOauthDevicePayloadSchema = z
-    .object({
-    kind: z.literal("oauth_device"),
-    prompt: NonEmptyStringSchema,
-    provider: NonEmptyStringSchema.optional(),
-    profileLabel: NonEmptyStringSchema.optional(),
-    verificationUri: NonEmptyStringSchema,
-    userCode: NonEmptyStringSchema,
-    expiresAt: IsoDatetimeSchema.optional(),
-    intervalSeconds: PositiveIntSchema.optional(),
-})
-    .strict();
-export const HeadlessConfirmPayloadSchema = z
-    .object({
-    kind: z.literal("confirm"),
-    prompt: NonEmptyStringSchema,
-    detail: z.string().optional(),
-    confirmLabel: z.string().optional(),
-    denyLabel: z.string().optional(),
-    defaultApproved: z.boolean().optional(),
-})
-    .strict();
-export const HeadlessInteractionPayloadSchema = z.discriminatedUnion("kind", [
-    HeadlessToolApprovalPayloadSchema,
-    HeadlessQuestionnairePayloadSchema,
-    HeadlessSelectionPayloadSchema,
-    HeadlessCredentialInputPayloadSchema,
-    HeadlessOauthDevicePayloadSchema,
-    HeadlessConfirmPayloadSchema,
-]);
-export const HeadlessConfirmResponsePayloadSchema = z
-    .object({
-    kind: z.literal("confirm"),
-    approved: z.boolean(),
-})
-    .strict();
-export const HeadlessQuestionnaireResponsePayloadSchema = z
-    .object({
-    kind: z.literal("questionnaire"),
-    answers: z.array(z.string()),
-})
-    .strict();
-export const HeadlessSelectionResponsePayloadSchema = z
-    .object({
-    kind: z.literal("selection"),
-    selected: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessCredentialInputResponsePayloadSchema = z
-    .object({
-    kind: z.literal("credential_input"),
-    values: z.record(z.string(), z.string()),
-})
-    .strict();
-export const HeadlessOauthDeviceResponsePayloadSchema = z
-    .object({
-    kind: z.literal("oauth_device"),
-    acknowledged: z.boolean().optional(),
-    verificationCode: z.string().optional(),
-})
-    .strict();
-export const HeadlessCancelResponsePayloadSchema = z
-    .object({
-    kind: z.literal("cancel"),
-})
-    .strict();
-export const HeadlessInteractionResponsePayloadSchema = z.discriminatedUnion("kind", [
-    HeadlessConfirmResponsePayloadSchema,
-    HeadlessQuestionnaireResponsePayloadSchema,
-    HeadlessSelectionResponsePayloadSchema,
-    HeadlessCredentialInputResponsePayloadSchema,
-    HeadlessOauthDeviceResponsePayloadSchema,
-    HeadlessCancelResponsePayloadSchema,
-]);
-export const HeadlessInteractionRequestSchema = z
-    .object({
-    kind: z.literal("interaction.required"),
-    requestId: HeadlessRequestIdSchema,
-    interactionId: HeadlessInteractionIdSchema,
-    source: HeadlessInteractionSourceSchema,
-    interaction: HeadlessInteractionPayloadSchema,
-})
-    .strict();
-export const HeadlessInteractionResponseSchema = z
-    .object({
-    kind: z.literal("interaction.respond"),
-    requestId: HeadlessRequestIdSchema,
-    interactionId: HeadlessInteractionIdSchema,
-    response: HeadlessInteractionResponsePayloadSchema,
-})
-    .strict();
-export const HeadlessErrorSchema = z
-    .object({
-    code: NonEmptyStringSchema,
-    message: NonEmptyStringSchema,
-    retryable: z.boolean().optional(),
-    details: z.record(z.string(), z.unknown()).optional(),
-})
-    .strict();
-export const HeadlessSessionSummarySchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    createdAt: IsoDatetimeSchema,
-    updatedAt: IsoDatetimeSchema,
-    completedAt: IsoDatetimeSchema.optional(),
-    title: z.string().nullable(),
-    arion: NonEmptyStringSchema,
-    model: NonEmptyStringSchema,
-    messageCount: NonNegativeIntSchema,
-    preview: z.string(),
-})
-    .strict();
-export const HeadlessLoadedSessionSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    arion: NonEmptyStringSchema,
-    model: NonEmptyStringSchema,
-    messages: z.array(z.unknown()),
-})
-    .strict();
-export const HeadlessSessionListInputSchema = z
-    .object({
-    query: z.string().optional(),
-    limit: PositiveIntSchema.max(200).optional(),
-    offset: NonNegativeIntSchema.optional(),
-})
-    .strict();
-export const HeadlessSessionReferenceInputSchema = z
-    .object({
-    sessionId: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessSessionListResultSchema = z
-    .object({
-    sessions: z.array(HeadlessSessionSummarySchema),
-})
-    .strict();
-export const HeadlessSessionReadResultSchema = z
-    .object({
-    session: HeadlessLoadedSessionSchema,
-})
-    .strict();
-export const HeadlessSessionLoadResultSchema = z
-    .object({
-    session: HeadlessLoadedSessionSchema,
-    loaded: z.literal(true),
-    runtimeState: z
-        .object({
-        sessionId: NonEmptyStringSchema,
-        stateStatus: z.enum(["idle", "running", "paused", "completed"]),
-        activeRunId: z.string().nullable(),
-        pausedState: z.unknown().nullable(),
-        policySnapshot: z.record(z.string(), z.unknown()).nullable(),
-        lastEventSeq: NonNegativeIntSchema,
-        revision: NonNegativeIntSchema,
-        leaseOwner: z.string().nullable(),
-        leaseExpiresAt: IsoDatetimeSchema.nullable(),
-        updatedAt: IsoDatetimeSchema,
-    })
-        .strict()
-        .nullable()
-        .optional(),
-    pendingInteraction: z
-        .object({
-        interactionId: NonEmptyStringSchema,
-        sessionId: NonEmptyStringSchema,
-        requestId: NonEmptyStringSchema,
-        source: HeadlessInteractionSourceSchema,
-        kind: NonEmptyStringSchema,
-        status: z.enum(["pending", "answered", "applied", "expired", "canceled"]),
-        prompt: z.record(z.string(), z.unknown()),
-        response: z.record(z.string(), z.unknown()).nullable(),
-        createdAt: IsoDatetimeSchema,
-        answeredAt: IsoDatetimeSchema.nullable(),
-        appliedAt: IsoDatetimeSchema.nullable(),
-    })
-        .strict()
-        .nullable()
-        .optional(),
-})
-    .strict();
-export const HeadlessSessionForkInputSchema = z
-    .object({
-    sessionId: NonEmptyStringSchema,
-    messageLimit: z.number().int().nonnegative().optional(),
-})
-    .strict();
-export const HeadlessSessionForkResultSchema = z
-    .object({
-    newSessionId: NonEmptyStringSchema,
-    sourceSessionId: NonEmptyStringSchema,
-    messagesCopied: NonNegativeIntSchema,
-    title: z.string().nullable(),
-})
-    .strict();
-export const HeadlessPendingPairRespondResultSchema = z
-    .object({
-    response: PairRequestResponseSchema,
-})
-    .strict();
-export const HeadlessPeerInviteResultSchema = z
-    .object({
-    invite: CreateInviteResponseSchema,
-})
-    .strict();
-export const HeadlessPeerConnectResultSchema = z
-    .object({
-    invite: InvitePeerResultSchema,
-})
-    .strict();
-export const HeadlessAcceptInviteTokenResultSchema = z
-    .object({
-    accepted: AcceptInviteTokenResponseSchema,
-})
-    .strict();
-export const HeadlessDirectPairResultSchema = z
-    .object({
-    pair: DirectPairResponseSchema,
-})
-    .strict();
-export const HeadlessRepairPeerResultSchema = z
-    .object({
-    repair: RepairPeerResponseSchema,
-})
-    .strict();
-export const HeadlessRevokePeerResultSchema = z
-    .object({
-    revoke: RevokePeerResponseSchema,
-})
-    .strict();
-export const HeadlessMemoryRememberInputSchema = z
-    .object({
-    text: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessMemoryRecallInputSchema = z
-    .object({
-    query: NonEmptyStringSchema,
-    limit: PositiveIntSchema.max(200).optional(),
-})
-    .strict();
-export const HeadlessMemoryListInputSchema = z
-    .object({
-    query: z.string().optional(),
-    limit: PositiveIntSchema.max(200).optional(),
-    offset: NonNegativeIntSchema.optional(),
-})
-    .strict();
-export const HeadlessMemoryForgetInputSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessMemoryRecallKnowledgeInputSchema = z
-    .object({
-    topic: NonEmptyStringSchema,
-    kind: z.enum(["skills", "procedures", "tools", "all"]).optional(),
-    limit: PositiveIntSchema.max(200).optional(),
-})
-    .strict();
-export const HeadlessArionNameInputSchema = z
-    .object({
-    name: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessArionHatchInputSchema = z
-    .object({
-    name: NonEmptyStringSchema,
-    description: z.string().optional(),
-})
-    .strict();
-export const HeadlessArionCreateInputSchema = z
-    .object({
-    name: NonEmptyStringSchema,
-    description: z.string().optional(),
-    emoji: z.string().optional(),
-    profile: z.string().optional(),
-})
-    .strict();
-export const HeadlessModelSetInputSchema = z
-    .object({
-    model: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessAuthLoginInputSchema = z
-    .object({
-    args: z.string().optional(),
-    provider: NonEmptyStringSchema.optional(),
-    credential: z.string().optional(),
-    method: NonEmptyStringSchema.optional(),
-    profileLabel: NonEmptyStringSchema.optional(),
-    source: NonEmptyStringSchema.optional(),
-})
-    .strict();
-export const HeadlessAuthLogoutInputSchema = z
-    .object({
-    args: z.string().optional(),
-    provider: NonEmptyStringSchema.optional(),
-})
-    .strict();
-export const HeadlessClientInboxListInputSchema = InboxListRequestSchema;
-export const HeadlessMessageInboxListInputSchema = InboxListRequestSchema;
-export const HeadlessStructuredMessageSendInputSchema = z
-    .object({
-    args: z.string().optional(),
-    recipient: NonEmptyStringSchema.optional(),
-    content: z.string().trim().min(1).optional(),
-    senderName: NonEmptyStringSchema.optional(),
-})
-    .strict()
-    .refine((value) => Boolean(value.args || (value.recipient && value.content)), {
-    message: "message.send requires args or recipient/content",
-});
-export const HeadlessMessageSendInputSchema = z.union([
-    OutboundMessageSchema,
-    HeadlessStructuredMessageSendInputSchema,
-]);
-export const HeadlessConfigThemeSetInputSchema = z
-    .object({
-    theme: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessConfigAutonomySetInputSchema = z
-    .object({
-    autonomy: AutonomySchema,
-})
-    .strict();
-export const HeadlessSystemRestartInputSchema = z
-    .object({
-    reason: z.string().optional(),
-})
-    .strict();
-export const HeadlessRunAbortInputSchema = z
-    .object({
-    runId: NonEmptyStringSchema.optional(),
-    sessionId: NonEmptyStringSchema.optional(),
-})
-    .strict()
-    .refine((value) => Boolean(value.runId || value.sessionId), {
-    message: "run.abort requires runId or sessionId",
-});
-export const HeadlessDaemonCommandInputSchema = z
-    .object({
-    arion: NonEmptyStringSchema.optional(),
-    port: PositiveIntSchema.optional(),
-    intervalMs: PositiveIntSchema.optional(),
-    allowedToolCategories: z.array(NonEmptyStringSchema).optional(),
-    allowedShellCommands: z.array(NonEmptyStringSchema).optional(),
-    maxWriteOpsPerMinute: PositiveIntSchema.optional(),
-    maxGitPushesPerHour: PositiveIntSchema.optional(),
-})
-    .strict();
-export const HeadlessHookExtractPairSchema = z
-    .object({
-    user: z.string(),
-    assistant: z.string(),
-})
-    .strict();
-export const HeadlessHookExtractInputSchema = z
-    .object({
-    pairs: z.array(HeadlessHookExtractPairSchema),
-})
-    .strict();
-export const HeadlessHookReflectMessageSchema = z
-    .object({
-    role: NonEmptyStringSchema,
-    content: z.unknown(),
-})
-    .strict();
-export const HeadlessHookReflectInputSchema = z
-    .object({
-    messages: z.array(HeadlessHookReflectMessageSchema).optional(),
-    conversation: z.string().optional(),
-})
-    .strict()
-    .refine((value) => Boolean(value.messages || value.conversation), {
-    message: "hook.reflect requires messages or conversation",
-});
-export const HeadlessHookIngestInputSchema = z
-    .object({
-    source: z.enum(["claude", "codex", "all"]).optional(),
-    limit: PositiveIntSchema.optional(),
-})
-    .strict();
-export const HeadlessHookHarvestInputSchema = z
-    .object({
-    preHarvest: z.boolean().optional(),
-    feedback: z.boolean().optional(),
-    extract: z.boolean().optional(),
-    stats: z.boolean().optional(),
-    cleanup: z.boolean().optional(),
-    cost: z.boolean().optional(),
-    all: z.boolean().optional(),
-    limit: PositiveIntSchema.optional(),
-})
-    .strict();
-export const HeadlessMessageSendResultSchema = z
-    .object({
-    receipt: z.union([RuntimeQueuedReceiptSchema, RuntimeDeliveryReceiptSchema]),
-    message: z.string().optional(),
-})
-    .strict();
-export const HeadlessInboxListResultSchema = z
-    .object({
-    events: z.array(PersistedInboxEventSchema),
-})
-    .strict();
-export const HeadlessPeerListResultSchema = z
-    .object({
-    peers: z.array(PeerViewEventSchema),
-})
-    .strict();
-export const HeadlessNearbyPeerListResultSchema = z
-    .object({
-    peers: z.array(NearbyPeerViewSchema),
-})
-    .strict();
-export const HeadlessPendingPairListResultSchema = z
-    .object({
-    requests: z.array(PendingPairRequestViewSchema),
-})
-    .strict();
-export const HeadlessClientListResultSchema = z
-    .object({
-    clients: z.array(AttachedClientViewSchema),
-})
-    .strict();
-export const HeadlessHookExtractResultSchema = z
-    .object({
-    extracted: z.array(z
-        .object({
-        user: z.string(),
-        extracted: NonNegativeIntSchema,
-        error: z.string().optional(),
-    })
-        .strict()),
-})
-    .strict();
-// ---------------------------------------------------------------------------
-// Typed result schemas for operations that previously used LooseObjectSchema
-// ---------------------------------------------------------------------------
-export const HeadlessRunAbortResultSchema = z
-    .object({
-    aborted: z.literal(true),
-    runId: NonEmptyStringSchema.optional(),
-    sessionId: NonEmptyStringSchema.optional(),
-})
-    .strict();
-export const HeadlessInteractionRespondResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessMemoryRememberResultSchema = z
-    .object({
-    success: z.literal(true),
-    message: z.string(),
-    data: z.object({ id: z.string(), count: z.number() }),
-})
-    .strict();
-export const HeadlessMemoryRecallResultSchema = z
-    .object({
-    success: z.literal(true),
-    message: z.string(),
-    count: NonNegativeIntSchema,
-    memories: z.array(z.unknown()),
-})
-    .strict();
-export const HeadlessMemoryListResultSchema = z
-    .object({
-    memories: z.array(z.unknown()),
-    count: NonNegativeIntSchema,
-})
-    .strict();
-export const HeadlessMemoryForgetResultSchema = z
-    .object({
-    success: z.literal(true),
-    message: z.string(),
-    deleted: z.boolean(),
-})
-    .strict();
-export const HeadlessMemoryRecallKnowledgeResultSchema = z
-    .object({
-    tools: z.array(z.unknown()),
-    count: NonNegativeIntSchema,
-})
-    .strict();
-export const HeadlessArionListResultSchema = z
-    .object({
-    arions: z.array(z.unknown()),
-})
-    .strict();
-export const HeadlessArionHatchResultSchema = z
-    .object({
-    mode: z.string(),
-    prompt: z.string(),
-    name: NonEmptyStringSchema,
-    description: z.string().optional(),
-})
-    .strict();
-export const HeadlessArionBecomeResultSchema = z
-    .object({
-    arion: z.unknown(),
-    activeArion: z.string(),
-})
-    .strict();
-export const HeadlessArionMutateResultSchema = z
-    .object({
-    success: z.literal(true),
-    name: NonEmptyStringSchema,
-})
-    .strict();
-export const HeadlessArionCreateResultSchema = z
-    .object({
-    arion: z.unknown(),
-})
-    .strict();
-export const HeadlessModelListResultSchema = z
-    .object({
-    models: z.array(z.unknown()),
-    currentModel: z.unknown().optional(),
-})
-    .strict();
-export const HeadlessModelSetResultSchema = z
-    .object({
-    currentModel: NonEmptyStringSchema,
-})
-    .catchall(z.unknown());
-export const HeadlessModelRefreshResultSchema = z
-    .object({
-    models: z.array(z.unknown()),
-})
-    .strict();
-export const HeadlessAuthStatusResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessAuthLoginResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessAuthLogoutResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessConfigThemeGetResultSchema = z
-    .object({
-    theme: z.unknown(),
-})
-    .strict();
-export const HeadlessConfigThemeSetResultSchema = z
-    .object({
-    theme: z.string(),
-})
-    .catchall(z.unknown());
-export const HeadlessConfigAutonomyGetResultSchema = z
-    .object({
-    autonomy: z.unknown(),
-})
-    .strict();
-export const HeadlessConfigAutonomySetResultSchema = z
-    .object({
-    autonomy: z.string(),
-})
-    .catchall(z.unknown());
-export const HeadlessSystemRestartResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessSystemTerminalSetupResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessHookReflectResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessHookConsolidateResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessHookIngestResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessHookHarvestResultSchema = z.object({}).catchall(z.unknown());
-export const HeadlessOperationSuccessResultSchema = z.union([
-    RunResultSchema,
-    HeadlessSessionListResultSchema,
-    HeadlessSessionReadResultSchema,
-    HeadlessSessionLoadResultSchema,
-    HeadlessSessionForkResultSchema,
-    HeadlessPeerListResultSchema,
-    HeadlessNearbyPeerListResultSchema,
-    HeadlessPendingPairListResultSchema,
-    HeadlessClientListResultSchema,
-    HeadlessInboxListResultSchema,
-    HeadlessMessageSendResultSchema,
-    RuntimeStatusSchema,
-    HeadlessPeerInviteResultSchema,
-    HeadlessAcceptInviteTokenResultSchema,
-    HeadlessPendingPairRespondResultSchema,
-    HeadlessPeerConnectResultSchema,
-    HeadlessDirectPairResultSchema,
-    HeadlessRepairPeerResultSchema,
-    HeadlessRevokePeerResultSchema,
-    HeadlessHookExtractResultSchema,
-    HeadlessRunAbortResultSchema,
-    HeadlessInteractionRespondResultSchema,
-    HeadlessMemoryRememberResultSchema,
-    HeadlessMemoryRecallResultSchema,
-    HeadlessMemoryListResultSchema,
-    HeadlessMemoryForgetResultSchema,
-    HeadlessMemoryRecallKnowledgeResultSchema,
-    HeadlessArionListResultSchema,
-    HeadlessArionHatchResultSchema,
-    HeadlessArionBecomeResultSchema,
-    HeadlessArionMutateResultSchema,
-    HeadlessArionCreateResultSchema,
-    HeadlessModelListResultSchema,
-    HeadlessModelSetResultSchema,
-    HeadlessModelRefreshResultSchema,
-    HeadlessAuthStatusResultSchema,
-    HeadlessAuthLoginResultSchema,
-    HeadlessAuthLogoutResultSchema,
-    HeadlessConfigThemeGetResultSchema,
-    HeadlessConfigThemeSetResultSchema,
-    HeadlessConfigAutonomyGetResultSchema,
-    HeadlessConfigAutonomySetResultSchema,
-    HeadlessSystemRestartResultSchema,
-    HeadlessSystemTerminalSetupResultSchema,
-    HeadlessHookReflectResultSchema,
-    HeadlessHookConsolidateResultSchema,
-    HeadlessHookIngestResultSchema,
-    HeadlessHookHarvestResultSchema,
-]);
-export const HeadlessRunStartInputSchema = RunRequestSchema.extend({
-    sessionId: NonEmptyStringSchema.optional(),
-});
-export const HeadlessRunResumeInputSchema = ResumeRunRequestSchema.extend({
-    sessionId: NonEmptyStringSchema.optional(),
-});
-export const HEADLESS_OPERATION_SCHEMAS = {
-    "run.start": {
-        input: HeadlessRunStartInputSchema,
-        result: RunResultSchema,
-        event: RuntimeRunEventSchema,
-    },
-    "run.resume": {
-        input: HeadlessRunResumeInputSchema,
-        result: RunResultSchema,
-    },
-    "run.abort": { input: HeadlessRunAbortInputSchema, result: HeadlessRunAbortResultSchema },
-    "interaction.respond": {
-        input: z
-            .object({
-            interactionId: HeadlessInteractionIdSchema,
-            response: HeadlessInteractionResponsePayloadSchema,
-        })
-            .strict(),
-        result: HeadlessInteractionRespondResultSchema,
-    },
-    "session.list": {
-        input: HeadlessSessionListInputSchema,
-        result: HeadlessSessionListResultSchema,
-    },
-    "session.read": {
-        input: HeadlessSessionReferenceInputSchema,
-        result: HeadlessSessionReadResultSchema,
-    },
-    "session.load": {
-        input: HeadlessSessionReferenceInputSchema,
-        result: HeadlessSessionLoadResultSchema,
-    },
-    "session.fork": {
-        input: HeadlessSessionForkInputSchema,
-        result: HeadlessSessionForkResultSchema,
-    },
-    "memory.remember": {
-        input: HeadlessMemoryRememberInputSchema,
-        result: HeadlessMemoryRememberResultSchema,
-    },
-    "memory.recall": {
-        input: HeadlessMemoryRecallInputSchema,
-        result: HeadlessMemoryRecallResultSchema,
-    },
-    "memory.list": { input: HeadlessMemoryListInputSchema, result: HeadlessMemoryListResultSchema },
-    "memory.forget": {
-        input: HeadlessMemoryForgetInputSchema,
-        result: HeadlessMemoryForgetResultSchema,
-    },
-    "memory.recall_knowledge": {
-        input: HeadlessMemoryRecallKnowledgeInputSchema,
-        result: HeadlessMemoryRecallKnowledgeResultSchema,
-    },
-    "arion.list": { input: EmptyObjectSchema, result: HeadlessArionListResultSchema },
-    "arion.hatch": { input: HeadlessArionHatchInputSchema, result: HeadlessArionHatchResultSchema },
-    "arion.become": { input: HeadlessArionNameInputSchema, result: HeadlessArionBecomeResultSchema },
-    "arion.rest": { input: HeadlessArionNameInputSchema, result: HeadlessArionMutateResultSchema },
-    "arion.wake": { input: HeadlessArionNameInputSchema, result: HeadlessArionMutateResultSchema },
-    "arion.create": {
-        input: HeadlessArionCreateInputSchema,
-        result: HeadlessArionCreateResultSchema,
-    },
-    "model.list": { input: EmptyObjectSchema, result: HeadlessModelListResultSchema },
-    "model.set": { input: HeadlessModelSetInputSchema, result: HeadlessModelSetResultSchema },
-    "model.refresh": { input: EmptyObjectSchema, result: HeadlessModelRefreshResultSchema },
-    "auth.status": { input: EmptyObjectSchema, result: HeadlessAuthStatusResultSchema },
-    "auth.login": { input: HeadlessAuthLoginInputSchema, result: HeadlessAuthLoginResultSchema },
-    "auth.logout": { input: HeadlessAuthLogoutInputSchema, result: HeadlessAuthLogoutResultSchema },
-    "peer.list": { input: EmptyObjectSchema, result: HeadlessPeerListResultSchema },
-    "peer.list_nearby": { input: EmptyObjectSchema, result: HeadlessNearbyPeerListResultSchema },
-    "peer.pending.list": {
-        input: EmptyObjectSchema,
-        result: HeadlessPendingPairListResultSchema,
-    },
-    "peer.pending.respond": {
-        input: PairRequestDecisionSchema,
-        result: HeadlessPendingPairRespondResultSchema,
-    },
-    "peer.invite": { input: CreateInviteRequestSchema, result: HeadlessPeerInviteResultSchema },
-    "peer.connect": { input: InvitePeerRequestSchema, result: HeadlessPeerConnectResultSchema },
-    "peer.accept_invite": {
-        input: AcceptInviteTokenRequestSchema,
-        result: HeadlessAcceptInviteTokenResultSchema,
-    },
-    "peer.direct_pair": { input: DirectPairRequestSchema, result: HeadlessDirectPairResultSchema },
-    "peer.repair": { input: RepairPeerRequestSchema, result: HeadlessRepairPeerResultSchema },
-    "peer.revoke": { input: RevokePeerRequestSchema, result: HeadlessRevokePeerResultSchema },
-    "client.list": { input: EmptyObjectSchema, result: HeadlessClientListResultSchema },
-    "client.inbox.list": {
-        input: HeadlessClientInboxListInputSchema,
-        result: HeadlessInboxListResultSchema,
-    },
-    "message.send": {
-        input: HeadlessMessageSendInputSchema,
-        result: HeadlessMessageSendResultSchema,
-    },
-    "message.inbox.list": {
-        input: HeadlessMessageInboxListInputSchema,
-        result: HeadlessInboxListResultSchema,
-    },
-    "config.theme.get": { input: EmptyObjectSchema, result: HeadlessConfigThemeGetResultSchema },
-    "config.theme.set": {
-        input: HeadlessConfigThemeSetInputSchema,
-        result: HeadlessConfigThemeSetResultSchema,
-    },
-    "config.autonomy.get": {
-        input: EmptyObjectSchema,
-        result: HeadlessConfigAutonomyGetResultSchema,
-    },
-    "config.autonomy.set": {
-        input: HeadlessConfigAutonomySetInputSchema,
-        result: HeadlessConfigAutonomySetResultSchema,
-    },
-    "system.restart": {
-        input: HeadlessSystemRestartInputSchema,
-        result: HeadlessSystemRestartResultSchema,
-    },
-    "system.terminal_setup": {
-        input: EmptyObjectSchema,
-        result: HeadlessSystemTerminalSetupResultSchema,
-    },
-    "daemon.start": { input: HeadlessDaemonCommandInputSchema, result: RuntimeStatusSchema },
-    "daemon.status": { input: HeadlessDaemonCommandInputSchema, result: RuntimeStatusSchema },
-    "daemon.stop": { input: HeadlessDaemonCommandInputSchema, result: RuntimeStatusSchema },
-    "hook.extract": {
-        input: HeadlessHookExtractInputSchema,
-        result: HeadlessHookExtractResultSchema,
-    },
-    "hook.reflect": {
-        input: HeadlessHookReflectInputSchema,
-        result: HeadlessHookReflectResultSchema,
-    },
-    "hook.consolidate": { input: EmptyObjectSchema, result: HeadlessHookConsolidateResultSchema },
-    "hook.ingest": { input: HeadlessHookIngestInputSchema, result: HeadlessHookIngestResultSchema },
-    "hook.harvest": {
-        input: HeadlessHookHarvestInputSchema,
-        result: HeadlessHookHarvestResultSchema,
-    },
-};
-export const HEADLESS_STREAMING_OPERATION_NAMES = ["run.start"];
-export const HEADLESS_CONNECTION_OWNED_OPERATION_NAMES = [
-    "run.start",
-    "run.resume",
-    "interaction.respond",
-];
-const HeadlessStreamingOperationNameSchema = z.enum(HEADLESS_STREAMING_OPERATION_NAMES);
-function validateOperationPayload(op, kind, value, ctx) {
-    const definition = HEADLESS_OPERATION_SCHEMAS[op];
-    const schema = kind === "input"
-        ? definition.input
-        : kind === "result"
-            ? definition.result
-            : "event" in definition
-                ? definition.event
-                : undefined;
-    if (!schema) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Operation ${op} does not define a ${kind} payload`,
-            path: [kind],
-        });
-        return;
-    }
-    if (!schema.safeParse(value).success) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Invalid ${kind} payload for operation ${op}`,
-            path: [kind],
-        });
-    }
-}
-export const HeadlessRequestSchema = z
-    .object({
-    kind: z.literal("request"),
-    requestId: HeadlessRequestIdSchema,
-    op: HeadlessOperationNameSchema,
-    input: z.unknown(),
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    validateOperationPayload(value.op, "input", value.input, ctx);
-});
-export const HeadlessEventSchema = z
-    .object({
-    kind: z.literal("event"),
-    requestId: HeadlessRequestIdSchema,
-    seq: NonNegativeIntSchema,
-    op: HeadlessStreamingOperationNameSchema,
-    event: z.unknown(),
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    validateOperationPayload(value.op, "event", value.event, ctx);
-});
-export const HeadlessSuccessResultSchema = z
-    .object({
-    kind: z.literal("result"),
-    requestId: HeadlessRequestIdSchema,
-    op: HeadlessOperationNameSchema,
-    ok: z.literal(true),
-    result: z.unknown(),
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    validateOperationPayload(value.op, "result", value.result, ctx);
-});
-export const HeadlessFailureResultSchema = z
-    .object({
-    kind: z.literal("result"),
-    requestId: HeadlessRequestIdSchema,
-    op: z.union([HeadlessOperationNameSchema, z.literal("unknown")]),
-    ok: z.literal(false),
-    error: HeadlessErrorSchema,
-})
-    .strict();
-export const HeadlessResultSchema = z.union([
-    HeadlessSuccessResultSchema,
-    HeadlessFailureResultSchema,
-]);
-export const HeadlessClientFrameSchema = z.union([
-    HeadlessRequestSchema,
-    HeadlessInteractionResponseSchema,
-]);
-export const HeadlessServerFrameSchema = z.union([
-    HeadlessEventSchema,
-    HeadlessResultSchema,
-    HeadlessInteractionRequestSchema,
-]);