@aria-cli/cli 1.0.14

package/dist/headless/kernel.d.ts

@@ -0,0 +1,118 @@
+import type { IMemoria } from "@aria-cli/types";
+import type { AttachedLocalControlApi, HeadlessClientFrame, HeadlessOperationName, HeadlessServerFrame } from "@aria-cli/tools";
+import { type CliContext } from "../cli-context.js";
+import { type SessionHistory as SessionHistoryType } from "../history/index.js";
+export interface ConfigService {
+    getTheme?(): Promise<unknown>;
+    setTheme?(theme: string): Promise<unknown>;
+    getAutonomy?(): Promise<unknown>;
+    setAutonomy?(autonomy: string): Promise<unknown>;
+    getActiveArion?(): Promise<string | undefined>;
+    setActiveArion?(name: string): Promise<void>;
+}
+export interface AuthService {
+    status?(): Promise<unknown>;
+    login?(input: Record<string, unknown>): Promise<unknown>;
+    logout?(input: Record<string, unknown>): Promise<unknown>;
+}
+export interface ModelDiscoveryService {
+    listAvailable?(): Promise<unknown>;
+    refresh?(force?: boolean): Promise<unknown>;
+    getCurrentModel?(): Promise<string | undefined>;
+    setCurrentModel?(model: string): Promise<unknown>;
+    getSessionModel?(): Promise<string | undefined>;
+}
+export interface ArionService {
+    list?(): Promise<unknown[]>;
+    hatch?(input: Record<string, unknown>): Promise<unknown>;
+    get?(name: string): Promise<{
+        name: string;
+        status?: string;
+    } | null>;
+    wake?(name: string): Promise<void>;
+    rest?(name: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export interface DaemonService {
+    start?(input: Record<string, unknown>): Promise<Record<string, unknown>>;
+    status?(input: Record<string, unknown>): Promise<Record<string, unknown>>;
+    stop?(input: Record<string, unknown>): Promise<Record<string, unknown>>;
+    shouldStopOnShutdown?(): boolean;
+    releaseAll?(): Promise<void>;
+}
+export interface HookService {
+    extract?(input: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, unknown>>;
+    reflect?(input: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, unknown>>;
+    consolidate?(input: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, unknown>>;
+    ingest?(input: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, unknown>>;
+    harvest?(input: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, unknown>>;
+}
+export interface SystemService {
+    restart?(input: Record<string, unknown>): Promise<Record<string, unknown>>;
+    terminalSetup?(): Promise<Record<string, unknown>>;
+}
+export interface HeadlessRunAbortController {
+    abort(input: {
+        runId?: string;
+        sessionId?: string;
+    }): Promise<boolean> | boolean;
+}
+export interface KernelContext {
+    cli: CliContext;
+    localControl: AttachedLocalControlApi;
+    sessionLedger: SessionHistoryType;
+    arionManager?: ArionService;
+    memoria?: IMemoria;
+    config?: ConfigService;
+    auth?: AuthService;
+    modelDiscovery?: ModelDiscoveryService;
+    daemon?: DaemonService;
+    hook?: HookService;
+    system?: SystemService;
+    activeRunController?: HeadlessRunAbortController;
+    getSessionModel?(): string | undefined;
+    getSessionArion?(): string | undefined;
+}
+export interface FullKernelContext extends KernelContext {
+    arionManager: ArionService;
+    memoria: IMemoria;
+    config: ConfigService;
+    auth: AuthService;
+    modelDiscovery: ModelDiscoveryService;
+    daemon: DaemonService;
+    hook: HookService;
+    system: SystemService;
+}
+export type HeadlessKernelHandler = (requestId: string, input: unknown, context?: HeadlessDispatchContext) => AsyncGenerator<HeadlessServerFrame, void, undefined>;
+export interface HeadlessDispatchContext {
+    signal?: AbortSignal;
+    activeRunController?: HeadlessRunAbortController;
+}
+export interface HeadlessKernelRuntime {
+    kernel: HeadlessKernel;
+    ctx: FullKernelContext;
+    release(): Promise<void>;
+}
+export declare function createHeadlessKernelHandlers(ctx: KernelContext): Record<HeadlessOperationName, HeadlessKernelHandler>;
+export declare class HeadlessKernel {
+    private readonly ctx;
+    private readonly handlers;
+    constructor(ctx: KernelContext, handlers?: Record<HeadlessOperationName, HeadlessKernelHandler>);
+    dispatch(frame: HeadlessClientFrame, context?: HeadlessDispatchContext): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    getContext(): KernelContext;
+}
+export declare function createHeadlessKernelRuntime(options?: {
+    cwd?: string;
+    arionName?: string;
+}): Promise<HeadlessKernelRuntime>;

package/dist/headless/operations/arion.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+export declare function createArionOperationHandlers(ctx: FullKernelContext): Pick<Record<string, HeadlessKernelHandler>, "arion.list" | "arion.hatch" | "arion.become" | "arion.rest" | "arion.wake" | "arion.create">;
+export declare function createArionOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "arion.list" | "arion.hatch" | "arion.become" | "arion.rest" | "arion.wake" | "arion.create">;

package/dist/headless/operations/auth.d.ts

@@ -0,0 +1,4 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+import type { HeadlessAuthOrchestrator } from "../auth-orchestrator.js";
+export declare function createAuthOperationHandlers(ctx: FullKernelContext, orchestrator: HeadlessAuthOrchestrator): Pick<Record<string, HeadlessKernelHandler>, "auth.status" | "auth.login" | "auth.logout">;
+export declare function createAuthOperationHandlers(ctx: KernelContext, orchestrator: HeadlessAuthOrchestrator): Pick<Record<string, HeadlessKernelHandler>, "auth.status" | "auth.login" | "auth.logout">;

package/dist/headless/operations/client.d.ts

@@ -0,0 +1,2 @@
+import type { HeadlessKernelHandler, KernelContext } from "../kernel.js";
+export declare function createClientOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "client.list" | "client.inbox.list">;

package/dist/headless/operations/config.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+export declare function createConfigOperationHandlers(ctx: FullKernelContext): Pick<Record<string, HeadlessKernelHandler>, "config.theme.get" | "config.theme.set" | "config.autonomy.get" | "config.autonomy.set">;
+export declare function createConfigOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "config.theme.get" | "config.theme.set" | "config.autonomy.get" | "config.autonomy.set">;

package/dist/headless/operations/daemon.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+export declare function createDaemonOperationHandlers(ctx: FullKernelContext): Pick<Record<string, HeadlessKernelHandler>, "daemon.start" | "daemon.status" | "daemon.stop">;
+export declare function createDaemonOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "daemon.start" | "daemon.status" | "daemon.stop">;

package/dist/headless/operations/hook.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+export declare function createHookOperationHandlers(ctx: FullKernelContext): Pick<Record<string, HeadlessKernelHandler>, "hook.extract" | "hook.reflect" | "hook.consolidate" | "hook.ingest" | "hook.harvest">;
+export declare function createHookOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "hook.extract" | "hook.reflect" | "hook.consolidate" | "hook.ingest" | "hook.harvest">;

package/dist/headless/operations/index.d.ts

@@ -0,0 +1,10 @@
+export { createArionOperationHandlers } from "./arion.js";
+export { createAuthOperationHandlers } from "./auth.js";
+export { createClientOperationHandlers } from "./client.js";
+export { createConfigOperationHandlers } from "./config.js";
+export { createMemoryOperationHandlers } from "./memory.js";
+export { createMessageOperationHandlers } from "./message.js";
+export { createModelOperationHandlers } from "./model.js";
+export { createPeerOperationHandlers } from "./peer.js";
+export { createRunOperationHandlers } from "./run.js";
+export { createSessionOperationHandlers } from "./session.js";

package/dist/headless/operations/memory.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+export declare function createMemoryOperationHandlers(ctx: FullKernelContext): Pick<Record<string, HeadlessKernelHandler>, "memory.remember" | "memory.recall" | "memory.list" | "memory.forget" | "memory.recall_knowledge">;
+export declare function createMemoryOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "memory.remember" | "memory.recall" | "memory.list" | "memory.forget" | "memory.recall_knowledge">;

package/dist/headless/operations/message.d.ts

@@ -0,0 +1,2 @@
+import type { HeadlessKernelHandler, KernelContext } from "../kernel.js";
+export declare function createMessageOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "message.send" | "message.inbox.list">;

package/dist/headless/operations/model.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+export declare function createModelOperationHandlers(ctx: FullKernelContext): Pick<Record<string, HeadlessKernelHandler>, "model.list" | "model.set" | "model.refresh">;
+export declare function createModelOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "model.list" | "model.set" | "model.refresh">;

package/dist/headless/operations/peer.d.ts

@@ -0,0 +1,2 @@
+import type { HeadlessKernelHandler, KernelContext } from "../kernel.js";
+export declare function createPeerOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "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">;

package/dist/headless/operations/run.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler } from "../kernel.js";
+import { HeadlessRunOrchestrator } from "../run-orchestrator.js";
+export declare function createRunOperationHandlers(orchestrator: HeadlessRunOrchestrator): Pick<Record<string, HeadlessKernelHandler>, "run.start" | "run.resume" | "run.abort" | "interaction.respond">;

package/dist/headless/operations/session.d.ts

@@ -0,0 +1,74 @@
+import type { HeadlessKernelHandler, KernelContext } from "../kernel.js";
+export declare function buildSessionListResult(requestId: string, sessionLedger: KernelContext["sessionLedger"], input: unknown): {
+    kind: "result";
+    requestId: string;
+    op: "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";
+    ok: true;
+    result: unknown;
+} | {
+    kind: "result";
+    requestId: string;
+    op: "unknown" | "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";
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+};
+export declare function buildSessionReadResult(requestId: string, sessionLedger: KernelContext["sessionLedger"], input: unknown): {
+    kind: "result";
+    requestId: string;
+    op: "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";
+    ok: true;
+    result: unknown;
+} | {
+    kind: "result";
+    requestId: string;
+    op: "unknown" | "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";
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+};
+export declare function buildSessionLoadResult(requestId: string, sessionLedger: KernelContext["sessionLedger"], input: unknown): {
+    kind: "result";
+    requestId: string;
+    op: "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";
+    ok: true;
+    result: unknown;
+} | {
+    kind: "result";
+    requestId: string;
+    op: "unknown" | "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";
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+};
+export declare function buildSessionForkResult(requestId: string, sessionLedger: KernelContext["sessionLedger"], input: unknown): {
+    kind: "result";
+    requestId: string;
+    op: "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";
+    ok: true;
+    result: unknown;
+} | {
+    kind: "result";
+    requestId: string;
+    op: "unknown" | "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";
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+};
+export declare function createSessionOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "session.list" | "session.read" | "session.load" | "session.fork">;

package/dist/headless/operations/subscription.d.ts

@@ -0,0 +1,2 @@
+import type { HeadlessKernelHandler, KernelContext } from "../kernel.js";
+export declare function createSubscriptionOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "subscription.peers" | "subscription.inbox" | "subscription.runtime_status">;

package/dist/headless/operations/system.d.ts

@@ -0,0 +1,3 @@
+import type { HeadlessKernelHandler, KernelContext, FullKernelContext } from "../kernel.js";
+export declare function createSystemOperationHandlers(ctx: FullKernelContext): Pick<Record<string, HeadlessKernelHandler>, "system.restart" | "system.terminal_setup">;
+export declare function createSystemOperationHandlers(ctx: KernelContext): Pick<Record<string, HeadlessKernelHandler>, "system.restart" | "system.terminal_setup">;

package/dist/headless/operations/utils.d.ts

@@ -0,0 +1,5 @@
+import type { HeadlessOperationName, HeadlessResult } from "@aria-cli/tools";
+import type { HeadlessKernelHandler } from "../kernel.js";
+export declare function successResult(requestId: string, op: HeadlessOperationName, result: unknown): HeadlessResult;
+export declare function failureResult(requestId: string, op: HeadlessOperationName, code: string, message: string, details?: Record<string, unknown>): HeadlessResult;
+export declare function unsupportedWhenMissing(serviceName: string, op: HeadlessOperationName): HeadlessKernelHandler;

package/dist/headless/run-orchestrator.d.ts

@@ -0,0 +1,38 @@
+import type { AttachedLocalControlApi, HeadlessRunStartInput, HeadlessRunResumeInput, HeadlessInteractionResponse, HeadlessServerFrame } from "@aria-cli/tools";
+import type { SessionHistory } from "../history/SessionHistory.js";
+export interface HeadlessRunExecutionContext {
+    localControl: AttachedLocalControlApi;
+    sessionLedger: SessionHistory;
+    activeRunController?: {
+        abort(input: {
+            runId?: string;
+            sessionId?: string;
+        }): Promise<boolean> | boolean;
+    };
+    getSessionModel?: () => string | undefined;
+    getSessionArion?: () => string | undefined;
+}
+export declare class HeadlessRunOrchestrator {
+    private readonly ctx;
+    constructor(ctx: HeadlessRunExecutionContext);
+    private renewSessionLease;
+    private clearRunningSession;
+    private releaseClaimOnce;
+    private static isAbortError;
+    private static createAbortReason;
+    private static getAbortCode;
+    private static getAbortMessage;
+    start(requestId: string, request: HeadlessRunStartInput, signal?: AbortSignal): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    resume(requestId: string, request: HeadlessRunResumeInput, signal?: AbortSignal): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    abort(requestId: string, input: {
+        runId?: string;
+        sessionId?: string;
+    }, activeRunController?: {
+        abort(input: {
+            runId?: string;
+            sessionId?: string;
+        }): Promise<boolean> | boolean;
+    }): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    respond(response: HeadlessInteractionResponse, signal?: AbortSignal): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    private consumeRunEvent;
+}

package/dist/headless/stdio-server.d.ts

@@ -0,0 +1,4 @@
+export declare function startHeadlessStdioServer(options?: {
+    cwd?: string;
+    arionName?: string;
+}): Promise<void>;

package/dist/history/SessionHistory.d.ts

@@ -0,0 +1,200 @@
+import type { ConversationMessage } from "./conversation-message.js";
+export interface SessionSummary {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+    title: string | null;
+    arion: string;
+    model: string;
+    messageCount: number;
+    preview: string;
+}
+export interface SessionMessage {
+    id: number;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    arion?: string;
+    toolCallId?: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+        thoughtSignature?: string;
+    }>;
+    thinking?: unknown[];
+    createdAt: Date;
+}
+export interface SessionContext {
+    id: string;
+    arion: string;
+    model: string;
+    messages: SessionMessage[];
+}
+export interface LoadedSession {
+    id: string;
+    arion: string;
+    model: string;
+    messages: ConversationMessage[];
+}
+export type SessionRuntimeStateStatus = "idle" | "running" | "paused" | "completed";
+export type SessionInteractionStatus = "pending" | "answered" | "applied" | "expired" | "canceled";
+export interface SessionRuntimeState {
+    sessionId: string;
+    stateStatus: SessionRuntimeStateStatus;
+    activeRunId: string | null;
+    pausedState: unknown | null;
+    policySnapshot: Record<string, unknown> | null;
+    lastEventSeq: number;
+    revision: number;
+    leaseOwner: string | null;
+    leaseExpiresAt: string | null;
+    updatedAt: string;
+}
+export interface SessionInteractionRecord {
+    interactionId: string;
+    sessionId: string;
+    requestId: string;
+    source: "run" | "auth" | "system" | "peer";
+    kind: string;
+    status: SessionInteractionStatus;
+    prompt: Record<string, unknown>;
+    response: Record<string, unknown> | null;
+    createdAt: string;
+    answeredAt: string | null;
+    appliedAt: string | null;
+}
+export interface LoadedSessionState {
+    session: LoadedSession;
+    runtimeState: SessionRuntimeState | null;
+    pendingInteraction: SessionInteractionRecord | null;
+}
+export interface RunMetricsRow {
+    id: string;
+    sessionId: string;
+    turnCount?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    estimatedCost?: number;
+    wallTimeMs?: number;
+    toolCount?: number;
+    guardrailFires?: number;
+    handoffCount?: number;
+    createdAt?: string;
+}
+export declare class SessionHistory {
+    private db;
+    private sessionFtsEnabled;
+    /** Sessions that received incremental addConversationMessage writes this process. */
+    private readonly incrementalSessions;
+    /**
+     * Resolve the per-Arion history.db path.
+     * Each Arion gets its own history.db at ~/.aria/arions/{arionName}/history.db.
+     */
+    static resolvePerArionPath(ariaDir: string, arionName: string): string;
+    /**
+     * Migrate JSONL logs from global ~/.aria/logs/ to per-Arion ~/.aria/arions/{arionName}/logs/.
+     * Copies all .jsonl files on first access. Keeps originals intact.
+     */
+    static migrateJsonlLogs(ariaDir: string, arionName: string): string;
+    constructor(dbPath: string);
+    private initialize;
+    private initializeSessionFts;
+    private toFtsPrefixQuery;
+    private withImmediateTransaction;
+    private ensureSessionRuntimeRow;
+    private readSessionRuntimeStateRow;
+    private parseJsonColumn;
+    private toSessionRuntimeState;
+    private toSessionInteractionRecord;
+    private assertSessionMutationGuard;
+    createSession(arion: string, model: string, id?: string): string;
+    /**
+     * Fork (clone) a session into a new independent session.
+     * Copies all messages (or up to `messageLimit`) from the source session.
+     * The new session gets a fresh runtime state and no interactions.
+     *
+     * @returns The new session ID, source session ID, number of messages copied, and title.
+     */
+    forkSession(sourceSessionId: string, options?: {
+        messageLimit?: number;
+        title?: string;
+    }): {
+        newSessionId: string;
+        sourceSessionId: string;
+        messagesCopied: number;
+        title: string | null;
+    };
+    addMessage(sessionId: string, role: "user" | "assistant" | "system" | "tool", content: string, options?: {
+        arion?: string;
+        toolCallId?: string;
+        toolCalls?: Array<{
+            id: string;
+            name: string;
+            arguments: Record<string, unknown>;
+            thoughtSignature?: string;
+        }>;
+        thinking?: unknown[];
+    }): void;
+    addConversationMessage(sessionId: string, msg: ConversationMessage): void;
+    /**
+     * Atomically persist multiple conversation messages in a single transaction.
+     * Either all messages are committed or none — no partial turns in history.
+     * Also reduces write contention: one lock acquisition instead of N.
+     */
+    addConversationMessages(sessionId: string, msgs: ConversationMessage[]): void;
+    replaceConversationMessages(sessionId: string, msgs: ConversationMessage[]): void;
+    loadSessionMessages(sessionId: string): LoadedSession | null;
+    loadSession(sessionId: string): LoadedSessionState | null;
+    getSessionRuntimeState(sessionId: string): SessionRuntimeState | null;
+    getInteraction(interactionId: string): SessionInteractionRecord | null;
+    claimSessionForMutation(sessionId: string, ownerId: string, staleAfterMs: number): SessionRuntimeState;
+    recordPausedRun(sessionId: string, runId: string, pausedState: unknown, policySnapshot: Record<string, unknown>, interactionRecord?: Pick<SessionInteractionRecord, "interactionId" | "requestId" | "source" | "kind" | "prompt"> | null, options?: {
+        ownerId?: string;
+        expectedRevision?: number;
+        lastEventSeq?: number;
+    }): SessionRuntimeState;
+    recordInteractionResponse(sessionId: string, interactionId: string, response: Record<string, unknown>, options?: {
+        ownerId?: string;
+        expectedRevision?: number;
+    }): SessionInteractionRecord;
+    cancelInteraction(sessionId: string, interactionId: string, options?: {
+        ownerId?: string;
+        expectedRevision?: number;
+    }): SessionInteractionRecord;
+    completeRun(sessionId: string, _runResult: Record<string, unknown>, options?: {
+        ownerId?: string;
+        expectedRevision?: number;
+    }): SessionRuntimeState;
+    releaseSessionClaim(sessionId: string, ownerId: string): void;
+    listSessions(limit?: number, offset?: number): SessionSummary[];
+    searchSessions(query: string, limit?: number, offset?: number): SessionSummary[];
+    searchSessionsFts(query: string, limit?: number, offset?: number): SessionSummary[];
+    /**
+     * Fast session search for interactive UI filtering.
+     *
+     * Unlike `searchSessions`, this does NOT join the messages table.
+     * It searches session metadata only (title/arion/model/id) so it stays
+     * responsive while the user types in the resume overlay.
+     */
+    searchSessionSummaries(query: string, limit?: number, offset?: number): SessionSummary[];
+    getSession(sessionId: string): SessionContext | null;
+    deleteSession(sessionId: string): void;
+    setSessionTitle(sessionId: string, title: string): void;
+    markCompleted(sessionId: string): void;
+    markStaleSessionsCompleted(maxAgeDays: number): number;
+    getIncompleteSessions(limit?: number): SessionSummary[];
+    /**
+     * Resolve a session ID from a full UUID or prefix (8+ chars).
+     * Returns the full ID if exactly one match, null otherwise.
+     */
+    findSessionByPrefix(prefix: string): string | null;
+    getSessionCount(): number;
+    private truncatePreview;
+    addInputHistory(content: string): void;
+    getInputHistory(limit?: number): string[];
+    saveRunMetrics(sessionId: string, metrics: RunMetricsRow): void;
+    getRunMetrics(sessionId: string): RunMetricsRow[];
+    close(): void;
+}