@aria-cli/tools 1.0.0

package/src/headless-control-contract.ts

@@ -0,0 +1,1149 @@
+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",
+] as const;
+
+export const HeadlessOperationNameSchema = z.enum(HEADLESS_OPERATION_NAMES);
+export type HeadlessOperationName = z.infer<typeof HeadlessOperationNameSchema>;
+
+export const HeadlessRequestIdSchema = NonEmptyStringSchema;
+export type HeadlessRequestId = z.infer<typeof HeadlessRequestIdSchema>;
+
+export const HeadlessInteractionIdSchema = NonEmptyStringSchema;
+export type HeadlessInteractionId = z.infer<typeof HeadlessInteractionIdSchema>;
+
+export const HeadlessInteractionSourceSchema = z.enum(["run", "auth", "system", "peer"]);
+export type HeadlessInteractionSource = z.infer<typeof HeadlessInteractionSourceSchema>;
+
+export const HeadlessInteractionQuestionSchema = z
+  .object({
+    question: NonEmptyStringSchema,
+    options: z.array(NonEmptyStringSchema).optional(),
+  })
+  .strict();
+export type HeadlessInteractionQuestion = z.infer<typeof HeadlessInteractionQuestionSchema>;
+
+export const HeadlessSelectionOptionSchema = z
+  .object({
+    id: NonEmptyStringSchema,
+    label: NonEmptyStringSchema,
+    description: z.string().optional(),
+  })
+  .strict();
+export type HeadlessSelectionOption = z.infer<typeof HeadlessSelectionOptionSchema>;
+
+export const HeadlessCredentialFieldSchema = z
+  .object({
+    key: NonEmptyStringSchema,
+    label: NonEmptyStringSchema,
+    placeholder: z.string().optional(),
+    secret: z.boolean().optional(),
+  })
+  .strict();
+export type HeadlessCredentialField = z.infer<typeof HeadlessCredentialFieldSchema>;
+
+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 type HeadlessInteractionPayload = z.infer<typeof HeadlessInteractionPayloadSchema>;
+
+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 type HeadlessInteractionResponsePayload = z.infer<
+  typeof HeadlessInteractionResponsePayloadSchema
+>;
+
+export const HeadlessInteractionRequestSchema = z
+  .object({
+    kind: z.literal("interaction.required"),
+    requestId: HeadlessRequestIdSchema,
+    interactionId: HeadlessInteractionIdSchema,
+    source: HeadlessInteractionSourceSchema,
+    interaction: HeadlessInteractionPayloadSchema,
+  })
+  .strict();
+export type HeadlessInteractionRequest = z.infer<typeof HeadlessInteractionRequestSchema>;
+
+export const HeadlessInteractionResponseSchema = z
+  .object({
+    kind: z.literal("interaction.respond"),
+    requestId: HeadlessRequestIdSchema,
+    interactionId: HeadlessInteractionIdSchema,
+    response: HeadlessInteractionResponsePayloadSchema,
+  })
+  .strict();
+export type HeadlessInteractionResponse = z.infer<typeof HeadlessInteractionResponseSchema>;
+
+export const HeadlessErrorSchema = z
+  .object({
+    code: NonEmptyStringSchema,
+    message: NonEmptyStringSchema,
+    retryable: z.boolean().optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
+  })
+  .strict();
+export type HeadlessError = z.infer<typeof HeadlessErrorSchema>;
+
+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 type HeadlessRunStartInput = z.infer<typeof HeadlessRunStartInputSchema>;
+
+export const HeadlessRunResumeInputSchema = ResumeRunRequestSchema.extend({
+  sessionId: NonEmptyStringSchema.optional(),
+});
+export type HeadlessRunResumeInput = z.infer<typeof HeadlessRunResumeInputSchema>;
+
+export interface HeadlessOperationSchemaDefinition {
+  input: z.ZodTypeAny;
+  result: z.ZodTypeAny;
+  event?: z.ZodTypeAny;
+}
+
+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,
+  },
+} satisfies Record<HeadlessOperationName, HeadlessOperationSchemaDefinition>;
+
+export const HEADLESS_STREAMING_OPERATION_NAMES = ["run.start"] as const;
+export const HEADLESS_CONNECTION_OWNED_OPERATION_NAMES = [
+  "run.start",
+  "run.resume",
+  "interaction.respond",
+] as const;
+const HeadlessStreamingOperationNameSchema = z.enum(HEADLESS_STREAMING_OPERATION_NAMES);
+
+function validateOperationPayload(
+  op: HeadlessOperationName,
+  kind: "input" | "result" | "event",
+  value: unknown,
+  ctx: z.RefinementCtx,
+): void {
+  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 type HeadlessRequest = z.infer<typeof HeadlessRequestSchema>;
+
+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 type HeadlessEvent = z.infer<typeof HeadlessEventSchema>;
+
+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 type HeadlessResult = z.infer<typeof HeadlessResultSchema>;
+
+export const HeadlessClientFrameSchema = z.union([
+  HeadlessRequestSchema,
+  HeadlessInteractionResponseSchema,
+]);
+export type HeadlessClientFrame = z.infer<typeof HeadlessClientFrameSchema>;
+
+export const HeadlessServerFrameSchema = z.union([
+  HeadlessEventSchema,
+  HeadlessResultSchema,
+  HeadlessInteractionRequestSchema,
+]);
+export type HeadlessServerFrame = z.infer<typeof HeadlessServerFrameSchema>;
+
+export type HeadlessOperationSuccessResult = z.infer<typeof HeadlessOperationSuccessResultSchema>;