@aria-cli/cli 1.0.14

package/dist/commands/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ARIA CLI Commands - Command infrastructure using Commander.js
+ */
+import { Command } from "commander";
+export declare const program: Command;
+export { createArionsCommand } from "./arions.js";
+export { createAuthCommand } from "./auth.js";
+export { createHeadlessCallCommand } from "../headless/call-command.js";
+export { runDaemonFromCli } from "./daemon.js";
+export { createPairingCommand } from "./pairing.js";
+export { createRuntimeCutoverResetCommand } from "./runtime-cutover-reset-command.js";
+export { startHeadlessStdioServer } from "../headless/stdio-server.js";
+export { runtimeCutoverResetCommand } from "./runtime-cutover-reset.js";

package/dist/commands/login-handler.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Slash command handler for /login — authenticate with providers.
+ *
+ * Supports three result modes:
+ * - PickerResult:  `/login` with no args → return provider list for interactive picker
+ * - DirectResult:  `/login bedrock`, `/login anthropic <key>` → immediate result
+ * - OAuthFlowResult: `/login anthropic` (no key) → trigger OAuth flow component
+ */
+import type { ProviderOption } from "../ui/components/ProviderPicker.js";
+export interface CommandResult {
+    success: boolean;
+    message: string;
+}
+/** No args: return provider list for the picker component */
+export interface PickerResult {
+    mode: "picker";
+    providers: ProviderOption[];
+}
+/** Direct result (Bedrock SSO, API key saved, etc.) */
+export interface DirectResult {
+    mode: "direct";
+    result: CommandResult;
+}
+/** Need to render OAuthLoginFlow component */
+export interface OAuthFlowResult {
+    mode: "oauth";
+    provider: string;
+}
+/** Need to render Copilot device-code flow component */
+export interface CopilotDeviceFlowResult {
+    mode: "copilot_device";
+    provider: "github-copilot";
+    profileLabel?: string;
+    message?: string;
+}
+export interface CopilotSourceOption {
+    id: string;
+    label: string;
+    source: "gh" | "copilot" | "device" | "env";
+    token?: string;
+    login?: string;
+    profileLabel?: string;
+    status: "connected" | "none";
+}
+export interface CopilotSourcePickerResult {
+    mode: "copilot_source_picker";
+    provider: "github-copilot";
+    options: CopilotSourceOption[];
+}
+export interface AnthropicMethodOption {
+    id: string;
+    label: string;
+    description: string;
+    method: "subscription" | "console" | "bedrock" | "claude-cli" | "setup-token" | "api-key" | "env-key";
+    status?: "connected" | "available" | "none";
+}
+export interface AnthropicMethodPickerResult {
+    mode: "anthropic_method_picker";
+    provider: "anthropic";
+    options: AnthropicMethodOption[];
+}
+export interface AnthropicKeyInputResult {
+    mode: "anthropic_key_input";
+    provider: "anthropic";
+}
+export interface AnthropicSetupTokenResult {
+    mode: "anthropic_setup_token";
+    provider: "anthropic";
+}
+export interface OpenAIMethodOption {
+    id: string;
+    label: string;
+    description: string;
+    method: "env-key" | "profile" | "codex-import" | "api-key";
+    status?: "connected" | "available" | "none";
+}
+export interface OpenAIMethodPickerResult {
+    mode: "openai_method_picker";
+    provider: "openai";
+    options: OpenAIMethodOption[];
+}
+export interface OpenAIKeyInputResult {
+    mode: "openai_key_input";
+    provider: "openai";
+}
+export interface GoogleMethodOption {
+    id: string;
+    label: string;
+    description: string;
+    method: "env-key" | "profile" | "gemini-import" | "api-key" | "oauth";
+    status?: "connected" | "available" | "none";
+}
+export interface GoogleMethodPickerResult {
+    mode: "google_method_picker";
+    provider: "google";
+    options: GoogleMethodOption[];
+}
+export interface GoogleKeyInputResult {
+    mode: "google_key_input";
+    provider: "google";
+}
+export type LoginResult = PickerResult | DirectResult | OAuthFlowResult | CopilotDeviceFlowResult | CopilotSourcePickerResult | AnthropicMethodPickerResult | AnthropicKeyInputResult | AnthropicSetupTokenResult | OpenAIMethodPickerResult | OpenAIKeyInputResult | GoogleMethodPickerResult | GoogleKeyInputResult;
+export declare function handleAnthropicMethodSelection(methodId: string): Promise<LoginResult>;
+export declare function handleOpenAIMethodSelection(methodId: string): Promise<LoginResult>;
+export declare function handleGoogleMethodSelection(methodId: string): Promise<LoginResult>;
+export declare function getProviderOptions(): ProviderOption[];
+export declare function loginProvider(provider: string, args?: string): Promise<LoginResult>;
+export declare function handleLoginCommand(args: string): Promise<LoginResult>;

package/dist/commands/logout-handler.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Slash command handler for /logout -- disconnect providers and clear credentials.
+ *
+ * Supports two result modes:
+ * - PickerResult:  `/logout` with no args -> list connected/expired providers
+ * - DirectResult:  `/logout <provider>` or `/logout all` -> immediate disconnect
+ */
+import type { ProviderOption } from "../ui/components/ProviderPicker.js";
+export interface CommandResult {
+    success: boolean;
+    message: string;
+}
+/** No args: return list of connected/expired providers for the user to choose from */
+export interface LogoutPickerResult {
+    mode: "picker";
+    providers: ProviderOption[];
+}
+/** Direct result (provider disconnected, all cleared, etc.) */
+export interface LogoutDirectResult {
+    mode: "direct";
+    result: CommandResult;
+}
+export type LogoutResult = LogoutPickerResult | LogoutDirectResult;
+export declare function handleLogoutCommand(args: string): LogoutResult;

package/dist/commands/memory-handlers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Slash command handlers for memory operations.
+ *
+ * Thin wrappers around Memoria API for testable command dispatch.
+ * Used by the REPL command pipeline and E2E tests.
+ */
+import type { IMemoria } from "@aria-cli/types";
+export interface CommandResult {
+    success: boolean;
+    message: string;
+    data?: unknown;
+}
+export declare function handleRememberCommand(args: string, memoria: IMemoria): Promise<CommandResult>;
+export declare function handleRecallCommand(args: string, memoria: IMemoria): Promise<CommandResult>;
+export declare function handleForgetCommand(args: string, memoria: IMemoria): Promise<CommandResult>;

package/dist/commands/pairing.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createPairingCommand(): Command;

package/dist/commands/peer-message-handler.d.ts

@@ -0,0 +1,7 @@
+import type { LocalControlApi, RuntimeDeliveryReceipt } from "@aria-cli/tools";
+export interface PeerMessageCommandResult {
+    success: boolean;
+    message: string;
+    receipt?: RuntimeDeliveryReceipt;
+}
+export declare function handleSendCommand(args: string, localControl: LocalControlApi, senderName: string): Promise<PeerMessageCommandResult>;

package/dist/commands/runtime-cutover-reset-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createRuntimeCutoverResetCommand(): Command;

package/dist/commands/runtime-cutover-reset.d.ts

@@ -0,0 +1,26 @@
+export interface RuntimeCutoverResetOptions {
+    ariaHome?: string;
+    fullReset?: boolean;
+    fullNodeReset?: boolean;
+    preserveLocalNodeIdentity?: boolean;
+    json?: boolean;
+}
+export interface RuntimeCutoverResetReport {
+    ariaHome: string;
+    runtimeRoot: string;
+    generatedAt: string;
+    fullReset: boolean;
+    fullNodeReset: boolean;
+    preserveLocalNodeIdentity: boolean;
+    reportPath: string;
+    removedPaths: string[];
+    deletedPaths: string[];
+    preservedPaths: string[];
+    skippedPaths: string[];
+    cleared: {
+        runtimeOwnerRecords: number;
+        runtimeEvents: number;
+    };
+}
+export declare function runRuntimeCutoverReset(options?: RuntimeCutoverResetOptions): Promise<RuntimeCutoverResetReport>;
+export declare function runtimeCutoverResetCommand(options?: RuntimeCutoverResetOptions): Promise<void>;

package/dist/commands/terminal-setup.d.ts

@@ -0,0 +1,3 @@
+export declare function isShiftEnterKeyBindingInstalled(): boolean;
+export declare function isTerminalSetupSupported(): boolean;
+export declare function runTerminalSetup(): string;

package/dist/config/aria-config.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ARIA Display & Persistence Configuration
+ *
+ * Loads user preferences from ~/.aria/config.yaml and merges them with
+ * MODE_PRESETS to produce the final display configuration. This implements
+ * the 4-layer merge strategy:
+ *
+ *   MODE_PRESETS[mode] -> config file -> CLI flags -> hotkey toggles
+ *
+ * All config options control UI presentation density, NOT feature availability.
+ * ObservabilityContext always captures everything regardless of display settings.
+ */
+import { type DisplayMode, type DisplayConfig } from "../ui/display-mode.js";
+import type { ThemeName } from "../ui/theme/index.js";
+export interface PersistenceConfig {
+    jsonlEnabled: boolean;
+    jsonlRetentionDays: number;
+    jsonlMaxSizeMb: number;
+    otelEndpoint: string | null;
+}
+export interface FullDisplayConfig extends DisplayConfig {
+    mode: DisplayMode;
+    theme?: ThemeName;
+    syntaxHighlighting: boolean;
+    maxToolOutputLines: number;
+    maxThinkingPreview: number;
+}
+export interface AriaDisplayConfig {
+    display: FullDisplayConfig;
+    persistence: PersistenceConfig;
+}
+/**
+ * Merge display config layers: preset -> file -> overrides.
+ *
+ * Each layer is a partial DisplayConfig. Values from later layers
+ * override earlier ones. Missing values fall through to the preset.
+ */
+export declare function mergeDisplayConfig(preset: DisplayConfig, fileOverrides?: Partial<DisplayConfig>, cliOverrides?: Partial<DisplayConfig>): DisplayConfig;
+/**
+ * Load the full ARIA display/persistence config.
+ *
+ * Resolution order:
+ *   1. Start with MODE_PRESETS[mode] (default: "standard")
+ *   2. Overlay values from ~/.aria/config.yaml (if exists)
+ *   3. Return merged AriaDisplayConfig
+ *
+ * If the file doesn't exist, returns defaults silently.
+ * If the file is malformed YAML, logs a warning and returns defaults.
+ */
+export declare function loadAriaDisplayConfig(configPath?: string): AriaDisplayConfig;

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { loadAriaProjectConfig, loadAriaProjectConfig as loadAriaConfig } from "./loader.js";
+export type { AriaProjectConfig, AriaProjectConfig as AriaConfig } from "./loader.js";
+export { loadAriaDisplayConfig, mergeDisplayConfig } from "./aria-config.js";
+export type { AriaDisplayConfig, FullDisplayConfig, PersistenceConfig } from "./aria-config.js";

package/dist/config/loader.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ARIA CLI Configuration Loader
+ *
+ * Loads configuration from project and global locations.
+ */
+import type { MCPServerConfig } from "@aria-cli/tools";
+export interface AriaProjectConfig {
+    mcp?: {
+        servers: MCPServerConfig[];
+    };
+}
+/**
+ * Load configuration from all sources
+ *
+ * Precedence: project > global > defaults
+ */
+export declare function loadAriaProjectConfig(projectDir?: string): Promise<AriaProjectConfig>;

package/dist/config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared configuration utilities for ARIA CLI
+ */
+import { type ModelTier } from "@aria-cli/models";
+import type { EffortLevel } from "@aria-cli/types";
+/**
+ * Get the ARIA home directory.
+ * Respects ARIA_HOME env var for testing and custom deployments.
+ */
+export declare function getAriaDir(): string;
+/**
+ * Get the config file path
+ */
+export declare function getConfigPath(): string;
+/**
+ * Config file structure
+ */
+export interface AriaConfig {
+    activeArion?: string;
+    preferredTier?: ModelTier;
+    defaultModel?: string;
+    anthropicApiKey?: string;
+    openaiApiKey?: string;
+    googleApiKey?: string;
+    /** AWS region for Bedrock provider (falls back to AWS_REGION env var) */
+    awsRegion?: string;
+    /** AWS profile for Bedrock SSO auth (falls back to AWS_PROFILE env var) */
+    awsProfile?: string;
+    /** Whether Shift+Enter terminal key binding has been installed */
+    shiftEnterKeyBindingInstalled?: boolean;
+    /** User-selected color theme (persisted from /theme command) */
+    theme?: string;
+    /** Autonomy level — persisted across sessions (default: "balanced") */
+    autonomy?: "minimal" | "balanced" | "high" | "full";
+    /** Effort level controlling thinking depth — persisted across sessions (default: "high") */
+    effortLevel?: EffortLevel;
+    /** Warcraft sound notifications — default true */
+    soundEnabled?: boolean;
+}
+/**
+ * Load configuration from ~/.aria/config.json
+ * Automatically migrates legacy defaultModel to preferredTier.
+ *
+ * This is the canonical config loader — use this instead of inline
+ * JSON.parse to ensure migration logic runs consistently.
+ */
+export declare function loadAndMigrateConfig(): AriaConfig;
+/** @deprecated Use loadAndMigrateConfig() */
+export declare const loadConfig: typeof loadAndMigrateConfig;
+/**
+ * Save configuration to ~/.aria/config.json
+ */
+export declare function saveConfig(config: AriaConfig): void;

package/dist/daemon-info.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Legacy daemon-info / presence helpers.
+ *
+ * The runtime-owner architecture no longer allows attach/discovery through
+ * daemon-info files or per-process presence files. Keep this module only to
+ * document that these APIs were removed in favor of HostSupervisor and
+ * local-control attach.
+ */
+import type { NodeId } from "@aria-cli/tools";
+export interface DaemonInfo {
+    port: number;
+    pid: number;
+    arionName: string;
+    nodeId?: NodeId;
+    startedAt: number;
+}
+export declare const LEGACY_RUNTIME_DISCOVERY_REMOVED = "[daemon-info] Legacy daemon-info/presence attach is removed. Use HostSupervisor/runtime-owner records and local-control attach instead.";

package/dist/ensure-daemon.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Universal daemon connection for all CLI subcommands.
+ *
+ * One function, one pattern:
+ *   1. Find running daemon → verify PID alive → connect to socket
+ *   2. Dead/missing daemon → clean stale records → spawn → connect
+ *
+ * Every CLI path (pairing, call, headless) uses this. No scoped runtimes,
+ * no split-brain, no WG port conflicts. The daemon owns the runtime.
+ */
+import type { LocalControlApi } from "@aria-cli/tools";
+import type { CliContext } from "./cli-context.js";
+export interface DaemonConnection {
+    control: LocalControlApi;
+    release(): Promise<void>;
+}
+/**
+ * Connect to a running daemon, or spawn one if none exists.
+ * This is the ONLY way CLI subcommands should obtain a control client.
+ */
+export declare function ensureDaemon(ctx: CliContext): Promise<DaemonConnection>;

package/dist/event-loop-watchdog.d.ts

@@ -0,0 +1,31 @@
+declare const WATCHDOG_INTERVAL_MS = 500;
+declare const DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS = 2000;
+/**
+ * Set the current phase label. The watchdog reads this on stall detection.
+ * Call `clearStallPhase()` when the operation completes.
+ */
+export declare function setStallPhase(label: string): void;
+export declare function clearStallPhase(): void;
+/** Read current phase (used by the watchdog callback). */
+export declare function getStallPhase(): {
+    label: string;
+    ageMs: number;
+} | undefined;
+export interface EventLoopWatchdogOptions {
+    thresholdMs?: number;
+    onStall: (stallMs: number) => void;
+    /** Called instead of onStall when the gap is caused by OS sleep/suspend. */
+    onSleep?: (sleepMs: number) => void;
+}
+/**
+ * Detects event loop stalls by measuring time between setInterval ticks.
+ *
+ * Uses performance.now() (monotonic clock) as the primary measurement.
+ * On macOS this clock does NOT advance during sleep (mach_absolute_time),
+ * eliminating sleep false-positives structurally. On Linux, CLOCK_MONOTONIC
+ * does include sleep time, so a secondary CPU-usage ratio check filters
+ * those out: if wall-clock jumped but CPU was idle, the process was
+ * suspended, not blocked.
+ */
+export declare function startEventLoopWatchdog(opts: EventLoopWatchdogOptions): () => void;
+export { DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS, WATCHDOG_INTERVAL_MS };

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

@@ -0,0 +1,19 @@
+import type { HeadlessInteractionResponse, HeadlessServerFrame } from "@aria-cli/tools";
+import type { SessionHistory } from "../history/SessionHistory.js";
+import type { AuthService, HeadlessDispatchContext } from "./kernel.js";
+export declare class HeadlessAuthOrchestrator {
+    private readonly auth;
+    private readonly sessionLedger;
+    private readonly getActiveArionName;
+    constructor(auth: AuthService | undefined, sessionLedger: SessionHistory, getActiveArionName: () => Promise<string>);
+    login(requestId: string, input: unknown, context?: HeadlessDispatchContext): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    logout(requestId: string, input: unknown): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    respond(response: HeadlessInteractionResponse, context?: HeadlessDispatchContext): AsyncGenerator<HeadlessServerFrame, void, undefined>;
+    private framesForInitialLoginResult;
+    private framesForContinuedLoginResult;
+    private buildLoginInteractionSpec;
+    private persistNewInteraction;
+    private persistContinuedInteraction;
+    private persistInteractionRecord;
+    private secretField;
+}

package/dist/headless/auth-service.d.ts

@@ -0,0 +1,15 @@
+import { type AnthropicMethodOption, type CopilotSourceOption, type GoogleMethodOption, type LoginResult, type OpenAIMethodOption } from "../commands/login-handler.js";
+import { type LogoutResult } from "../commands/logout-handler.js";
+import type { ProviderOption } from "../ui/components/ProviderPicker.js";
+export type HeadlessAuthLoginResult = LoginResult;
+export type HeadlessAuthLogoutResult = LogoutResult;
+export type HeadlessAuthProviderOption = ProviderOption;
+export type HeadlessCopilotSourceOption = CopilotSourceOption;
+export type HeadlessAnthropicMethodOption = AnthropicMethodOption;
+export type HeadlessOpenAIMethodOption = OpenAIMethodOption;
+export type HeadlessGoogleMethodOption = GoogleMethodOption;
+export declare function getHeadlessAuthProviders(): HeadlessAuthProviderOption[];
+export declare function runHeadlessLogin(args: string): Promise<HeadlessAuthLoginResult>;
+export declare function runHeadlessLogout(args: string): HeadlessAuthLogoutResult;
+export declare function buildStructuredLoginArgs(input: Record<string, unknown>): string;
+export declare function buildStructuredLogoutArgs(input: Record<string, unknown>): string;

package/dist/headless/bootstrap-fast-path.d.ts

@@ -0,0 +1,12 @@
+import type { HeadlessResult } from "@aria-cli/tools";
+export type BootstrapSessionOperation = "session.list" | "session.read" | "session.load";
+interface BootstrapFastPathOptions {
+    ariaHome?: string;
+    arionName?: string;
+}
+export declare function resolveAriaHome(override?: string): string;
+export declare function resolveBootstrapArionName(options?: BootstrapFastPathOptions): string;
+export declare function resolveCanonicalArionName(ariaHome: string, requestedName: string): string;
+export declare function runBootstrapSessionOperation(requestId: string, operation: BootstrapSessionOperation, input: unknown, options?: BootstrapFastPathOptions): HeadlessResult;
+export declare function runBootstrapSystemRestart(requestId: string, input: unknown): HeadlessResult;
+export {};

package/dist/headless/call-command.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+interface CallCommandOptions {
+    inputJson?: string;
+    arion?: string;
+}
+export declare function runHeadlessCall(operation: string, options: CallCommandOptions): Promise<number>;
+export declare function createHeadlessCallCommand(): Command;
+export {};

package/dist/headless/daemon-service.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeAutonomousLoopCommand, RuntimeStatus } from "@aria-cli/tools";
+import type { CliContext } from "../cli-context.js";
+import type { DaemonService } from "./kernel.js";
+export declare function createDaemonService(options: {
+    cli: CliContext;
+    cwd: string;
+    arionName?: string;
+    getArionName?: () => string;
+    localControl?: {
+        getRuntimeStatus(): Promise<RuntimeStatus>;
+        startAutonomousLoop?(input?: RuntimeAutonomousLoopCommand): Promise<unknown>;
+        stopAutonomousLoop?(): Promise<unknown>;
+    };
+}): DaemonService;

package/dist/headless/hook-actions.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared hook action implementations used by the `hook.*` headless operations.
+ *
+ * These functions provide the Memoria/router-backed extraction, reflection,
+ * consolidation, ingestion, and harvesting behavior without a dedicated legacy
+ * hook CLI mode.
+ */
+import { Memoria } from "@aria-cli/memoria";
+import type { ModelRouter } from "@aria-cli/models";
+export interface HookResult {
+    output: unknown;
+    exitCode?: number;
+}
+export interface HookActionOptions {
+    signal?: AbortSignal;
+}
+export interface HarvestActionInput {
+    preHarvest?: boolean;
+    feedback?: boolean;
+    extract?: boolean;
+    stats?: boolean;
+    cleanup?: boolean;
+    cost?: boolean;
+    all?: boolean;
+    limit?: number;
+}
+export declare function parseHarvestArgs(args: readonly string[]): Required<HarvestActionInput>;
+export declare function actionExtract(memoria: InstanceType<typeof Memoria>, stdin: string, options?: HookActionOptions): Promise<HookResult>;
+export declare function actionReflect(memoria: InstanceType<typeof Memoria>, router: ModelRouter, stdin: string, options?: {
+    signal?: AbortSignal;
+}): Promise<HookResult>;
+export declare function actionConsolidate(memoria: InstanceType<typeof Memoria>, options?: {
+    signal?: AbortSignal;
+}): Promise<HookResult>;
+export declare function actionIngest(memoria: InstanceType<typeof Memoria>, options?: {
+    signal?: AbortSignal;
+}): Promise<HookResult>;
+export declare function actionHarvest(memoria: InstanceType<typeof Memoria>, router: ModelRouter, input?: HarvestActionInput, options?: {
+    signal?: AbortSignal;
+}): Promise<HookResult>;

package/dist/headless/hook-service.d.ts

@@ -0,0 +1,8 @@
+import type { CliContext } from "../cli-context.js";
+import type { HookService } from "./kernel.js";
+export declare function createHookService(options: {
+    cli: CliContext;
+    arionName: string;
+    getArionName?: () => string;
+    resolveMemoriaPath?: () => Promise<string>;
+}): HookService;

package/dist/headless/kernel-services.d.ts

@@ -0,0 +1,8 @@
+import type { CliContext } from "../cli-context.js";
+import type { FullKernelContext, KernelContext } from "./kernel.js";
+export interface HeadlessCapabilityServiceOptions {
+    cli: CliContext;
+    activeArionName?: string;
+    overrides?: Pick<Partial<KernelContext>, "arionManager" | "auth" | "config" | "memoria" | "modelDiscovery">;
+}
+export declare function createHeadlessCapabilityServices(options: HeadlessCapabilityServiceOptions): Pick<FullKernelContext, "arionManager" | "auth" | "config" | "memoria" | "modelDiscovery">;