@aria-cli/tools 1.0.0

package/dist/headless-control-contract.js

@@ -0,0 +1,968 @@
+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,
+]);
+//# sourceMappingURL=headless-control-contract.js.map