@aria-cli/tools 1.0.19 → 1.0.33

package/dist-cjs/headless-control-contract.js

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