@aria-cli/tools 1.0.9 → 1.0.11

package/src/headless-control-contract.ts

@@ -1,1149 +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",
-] 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>;