arcie 0.1.5 → 0.1.7

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,2243 @@
+import type { IncomingMessage } from 'node:http';
+import type { ServerResponse } from 'node:http';
+import { z } from 'zod';
+
+export declare interface AcknowledgePromptOptions {
+    readonly message: string;
+    readonly lines?: readonly string[];
+}
+
+declare interface ActionResultError {
+    readonly code: string;
+    readonly message: string;
+}
+export { ActionResultError }
+export { ActionResultError as ActionResultError_alias_1 }
+
+declare type ActionResultStatus = "completed" | "failed" | "rejected" | "pending";
+export { ActionResultStatus }
+export { ActionResultStatus as ActionResultStatus_alias_1 }
+
+declare interface AgentConfig {
+    model: string;
+    name?: string;
+    description?: string;
+    cencori?: CencoriConfig;
+}
+export { AgentConfig }
+export { AgentConfig as AgentConfig_alias_1 }
+
+declare interface AgentManifest {
+    config: AgentConfig;
+    instructions: string;
+    tools: Record<string, ToolConfig>;
+    skills: Record<string, SkillConfig>;
+    hooks: Record<string, HookConfig>;
+    channels: Record<string, ChannelConfig>;
+    schedules: Record<string, ScheduleConfig>;
+    connections: Record<string, ConnectionConfig>;
+    /** Declared specialists under `subagents/<id>/`, keyed by directory name. */
+    subagents: Record<string, SubagentManifest>;
+    session?: SessionConfig;
+    policy?: PolicyConfig;
+}
+export { AgentManifest }
+export { AgentManifest as AgentManifest_alias_1 }
+
+export declare const ansiPattern: RegExp;
+
+export declare const ansiPrefixPattern: RegExp;
+
+export declare function applyLineEditorKey(state: LineState, key: TerminalKey, options?: LineEditorOptions): LineState | undefined;
+
+export declare function applyTextInputKey(state: TextInputState, key: TerminalKey): TextInputState | undefined;
+
+declare type ApprovalStrategy = "always" | "never" | "once";
+export { ApprovalStrategy }
+export { ApprovalStrategy as ApprovalStrategy_alias_1 }
+
+export declare const ARCIE_WORDMARK = "arcie";
+
+export declare function arcieCliBanner(): string;
+
+export declare interface AssistantResponseStats {
+    totalTokens: number | undefined;
+    outputTokens: number | undefined;
+    tokensPerSecond: number | undefined;
+}
+
+export declare type AssistantResponseStatsMode = "tokens" | "tokensPerSecond";
+
+declare type AssistantStepFinishReason = "content-filter" | "error" | "length" | "other" | "stop" | "tool-calls";
+export { AssistantStepFinishReason }
+export { AssistantStepFinishReason as AssistantStepFinishReason_alias_1 }
+
+declare function asUserTurn(speaker: Speaker, text: string): {
+    role: "user";
+    content: string;
+};
+export { asUserTurn }
+export { asUserTurn as asUserTurn_alias_1 }
+
+/**
+ * Puts stdin into raw mode, decodes bytes into `TerminalKey`s, and delivers
+ * them to `onKey`. Returns a detach function that restores the previous raw
+ * mode and stops delivering keys. Safe to call in a non-TTY (raw mode is
+ * skipped; delivered keys become whatever the terminal sends).
+ */
+export declare function attachKeyStream(onKey: (key: TerminalKey) => void): () => void;
+
+export declare function backspace(state: LineState): LineState;
+
+declare function basic(input: {
+    username: string;
+    password: TokenValue;
+}): OutboundAuthFn;
+export { basic }
+export { basic as basic_alias_1 }
+
+declare function bearer(token: TokenValue): OutboundAuthFn;
+export { bearer }
+export { bearer as bearer_alias_1 }
+
+export declare interface Block {
+    kind: BlockKind;
+    id?: string;
+    depth?: number;
+    live?: boolean;
+    title?: string;
+    subtitle?: string;
+    body?: string;
+    reasoning?: string;
+    result?: string;
+    detail?: string;
+    status?: ToolStatus;
+    preformatted?: boolean;
+    collapsed?: boolean;
+    expanded?: boolean;
+    toolInput?: unknown;
+    toolOutput?: unknown;
+}
+
+declare interface BlockCursorInput {
+    readonly before: string;
+    readonly under: string;
+    readonly after: string;
+    readonly visible: boolean;
+    readonly inverse: (text: string) => string;
+    readonly render?: (text: string) => string;
+}
+
+export declare type BlockKind = "user" | "assistant" | "reasoning" | "tool" | "error" | "notice" | "warning" | "result" | "subagent" | "subagent-step" | "subagent-tool" | "agent-header";
+
+export declare type BlockOp = {
+    type: "commit";
+    block: Block;
+} | {
+    type: "start-live";
+    block: Block;
+} | {
+    type: "update-live";
+    id: string;
+    patch: Partial<Block>;
+} | {
+    type: "end-live";
+    id: string;
+} | {
+    type: "clear-live";
+    id: string;
+};
+
+/**
+ * Applies a `BlockOp` to a mutable block store. The store keeps `live` blocks
+ * as an insertion-ordered map (for live-region redraw) and `committed` blocks
+ * as an append-only array (for scrollback). `commit` from the store is
+ * whatever rows should be flushed to `LiveRegion.commit`.
+ */
+export declare interface BlockStore {
+    readonly live: ReadonlyMap<string, Block>;
+    readonly justCommitted: readonly Block[];
+    apply(op: BlockOp): void;
+    drainCommitted(): Block[];
+}
+
+export declare function bold(text: string): string;
+
+export declare function buildCommand(options: {
+    agentDir: string;
+    outDir: string;
+}): Promise<void>;
+
+export declare interface CatalogModel {
+    id: string;
+    name: string;
+    provider: string;
+}
+
+declare interface CencoriConfig {
+    project?: string;
+    apiKey?: string;
+    billing?: {
+        budget?: string;
+        endUserMarkup?: number;
+    };
+    security?: {
+        policy?: "strict" | "standard" | "permissive";
+    };
+}
+export { CencoriConfig }
+export { CencoriConfig as CencoriConfig_alias_1 }
+
+declare interface CencoriMemoryClient {
+    store(options: {
+        namespace: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    search(options: {
+        namespace: string;
+        query: string;
+        limit?: number;
+        threshold?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<{
+        results: Array<{
+            content: string;
+            metadata: Record<string, unknown>;
+            similarity?: number;
+        }>;
+    }>;
+    delete?(options: {
+        namespace: string;
+        ids?: string[];
+        filter?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+export { CencoriMemoryClient }
+export { CencoriMemoryClient as CencoriMemoryClient_alias_1 }
+export { CencoriMemoryClient as CencoriMemoryClient_alias_2 }
+
+declare class CencoriMemoryStore implements MemoryStore {
+    private client;
+    constructor(client: CencoriMemoryClient);
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    search(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    close(): Promise<void>;
+    createThread(_thread: Thread): Promise<void>;
+    getThread(_threadId: string, _resourceId: string): Promise<Thread | null>;
+    listThreads(_resourceId: string): Promise<Thread[]>;
+    updateThread(_thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(_threadId: string, _resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+export { CencoriMemoryStore }
+export { CencoriMemoryStore as CencoriMemoryStore_alias_1 }
+export { CencoriMemoryStore as CencoriMemoryStore_alias_2 }
+
+declare interface ChannelConfig {
+    name: string;
+    type: "http" | "slack" | "discord" | "custom";
+    handler: (request: ChannelRequest) => ChannelResponse | Promise<ChannelResponse>;
+}
+export { ChannelConfig }
+export { ChannelConfig as ChannelConfig_alias_1 }
+
+declare interface ChannelRequest {
+    body: unknown;
+    headers: Record<string, string>;
+    method: string;
+}
+export { ChannelRequest }
+export { ChannelRequest as ChannelRequest_alias_1 }
+
+declare interface ChannelResponse {
+    status: number;
+    body: unknown;
+}
+export { ChannelResponse }
+export { ChannelResponse as ChannelResponse_alias_1 }
+
+export declare function checkProviderKeys(agentDir: string, modelId: string): Diagnostic[];
+
+declare interface CliLiveRow {
+    update(message: string, detail?: string): void;
+    stop(): void;
+}
+
+declare interface CliLiveRowLogger {
+    log(message: string): void;
+}
+
+declare interface CliLiveRowOptions {
+    readonly output?: CliLiveRowOutput;
+    readonly pulseSequence?: string;
+}
+
+declare interface CliLiveRowOutput {
+    readonly columns?: number;
+    readonly isTTY?: boolean;
+    write(chunk: string): unknown;
+}
+
+declare interface CliLogger {
+    error(message: string): void;
+    log(message: string): void;
+}
+
+declare type CliMessageTone = "accent" | "danger" | "default" | "info" | "muted" | "subagent" | "success" | "warning";
+
+export declare function clipVisible(input: string, width: number): string;
+
+export declare interface CliRow {
+    readonly label: string;
+    readonly tone?: CliMessageTone;
+    readonly value: string;
+}
+
+export declare interface CliTheme {
+    readonly color: boolean;
+    accent(text: string): string;
+    danger(text: string): string;
+    heading(text: string): string;
+    info(text: string): string;
+    label(text: string): string;
+    muted(text: string): string;
+    plain(text: string): string;
+    subagent(text: string): string;
+    success(text: string): string;
+    warning(text: string): string;
+}
+
+export declare function codePointWidth(codePoint: number): number;
+
+declare interface ConnectionConfig {
+    name: string;
+    description: string;
+    auth: {
+        type: "oauth2" | "apiKey" | "basic";
+        authorizeUrl?: string;
+        tokenUrl?: string;
+        clientId?: string;
+        scopes?: string[];
+    };
+}
+export { ConnectionConfig }
+export { ConnectionConfig as ConnectionConfig_alias_1 }
+
+export declare function createBlockStore(): BlockStore;
+
+export declare function createCliTheme(input?: {
+    color?: boolean;
+}): CliTheme;
+
+declare function createMessageAppended(delta: string, textSoFar: string, sequence: number, stepIndex: number, turnId: string): MessageAppendedEvent;
+export { createMessageAppended }
+export { createMessageAppended as createMessageAppended_alias_1 }
+
+declare function createMessageCompleted(text: string | null, finishReason: AssistantStepFinishReason, sequence: number, stepIndex: number, turnId: string): MessageCompletedEvent;
+export { createMessageCompleted }
+export { createMessageCompleted as createMessageCompleted_alias_1 }
+
+declare function createMessageReceived(message: string, sequence: number, turnId: string): MessageReceivedEvent;
+export { createMessageReceived }
+export { createMessageReceived as createMessageReceived_alias_1 }
+
+declare function createReasoningAppended(delta: string, soFar: string, sequence: number, stepIndex: number, turnId: string): ReasoningAppendedEvent;
+export { createReasoningAppended }
+export { createReasoningAppended as createReasoningAppended_alias_1 }
+
+declare function createReasoningCompleted(text: string, sequence: number, stepIndex: number, turnId: string): ReasoningCompletedEvent;
+export { createReasoningCompleted }
+export { createReasoningCompleted as createReasoningCompleted_alias_1 }
+
+export declare function createSelectState<T>(options: readonly SelectOption<T>[], init?: CreateSelectStateOptions<T>): SelectState<T>;
+
+export declare interface CreateSelectStateOptions<T> {
+    readonly initialValue?: T;
+    readonly query?: string;
+}
+
+declare function createSessionCompleted(): SessionCompletedEvent;
+export { createSessionCompleted }
+export { createSessionCompleted as createSessionCompleted_alias_1 }
+
+declare function createSessionFailed(code: string, message: string, sessionId: string): SessionFailedEvent;
+export { createSessionFailed }
+export { createSessionFailed as createSessionFailed_alias_1 }
+
+declare function createSessionStarted(sessionId: string, runtime?: SessionStartedEvent["data"]["runtime"]): SessionStartedEvent;
+export { createSessionStarted }
+export { createSessionStarted as createSessionStarted_alias_1 }
+
+declare function createSessionWaiting(): SessionWaitingEvent;
+export { createSessionWaiting }
+export { createSessionWaiting as createSessionWaiting_alias_1 }
+
+declare function createStepCompleted(finishReason: AssistantStepFinishReason, sequence: number, stepIndex: number, turnId: string, usage?: StepCompletedEvent["data"]["usage"]): StepCompletedEvent;
+export { createStepCompleted }
+export { createStepCompleted as createStepCompleted_alias_1 }
+
+declare function createStepFailed(code: string, message: string, sequence: number, stepIndex: number, turnId: string): StepFailedEvent;
+export { createStepFailed }
+export { createStepFailed as createStepFailed_alias_1 }
+
+declare function createStepStarted(sequence: number, stepIndex: number, turnId: string): StepStartedEvent;
+export { createStepStarted }
+export { createStepStarted as createStepStarted_alias_1 }
+
+declare function createSubagentCalled(name: string, callId: string, childSessionId: string, turnId: string): SubagentCalledEvent;
+export { createSubagentCalled }
+export { createSubagentCalled as createSubagentCalled_alias_1 }
+
+declare function createSubagentCompleted(name: string, callId: string, output: string): SubagentCompletedEvent;
+export { createSubagentCompleted }
+export { createSubagentCompleted as createSubagentCompleted_alias_1 }
+
+export declare interface CreateTextInputOptions {
+    readonly message: string;
+    readonly placeholder?: string;
+    readonly defaultValue?: string;
+    readonly mask?: boolean;
+    readonly validate?: (value: string) => string | undefined;
+}
+
+export declare function createTextInputState(options: CreateTextInputOptions): TextInputState;
+
+export declare function createTheme(options?: CreateThemeOptions): Theme;
+
+export declare interface CreateThemeOptions {
+    color?: boolean;
+    unicode?: boolean;
+}
+
+declare function createToolCallCompleted(name: string, output: unknown, callId: string, status: ActionResultStatus, error?: ActionResultError, sequence?: number, stepIndex?: number, turnId?: string): ToolCallCompletedEvent;
+export { createToolCallCompleted }
+export { createToolCallCompleted as createToolCallCompleted_alias_1 }
+
+declare function createToolCallStarted(name: string, input: unknown, callId: string, sequence: number, stepIndex: number, turnId: string): ToolCallStartedEvent;
+export { createToolCallStarted }
+export { createToolCallStarted as createToolCallStarted_alias_1 }
+
+export declare function createTuiPrompter(options?: TuiPrompterOptions): Prompter;
+
+declare function createTurnCompleted(sequence: number, turnId: string): TurnCompletedEvent;
+export { createTurnCompleted }
+export { createTurnCompleted as createTurnCompleted_alias_1 }
+
+declare function createTurnFailed(code: string, message: string, sequence: number, turnId: string): TurnFailedEvent;
+export { createTurnFailed }
+export { createTurnFailed as createTurnFailed_alias_1 }
+
+declare function createTurnStarted(sequence: number, turnId: string): TurnStartedEvent;
+export { createTurnStarted }
+export { createTurnStarted as createTurnStarted_alias_1 }
+
+declare const DEFAULT_TEMPLATE = "# User Profile\n\n- **Name**:\n- **Interests**:\n- **Goals**:\n- **Preferences**:\n";
+export { DEFAULT_TEMPLATE }
+export { DEFAULT_TEMPLATE as DEFAULT_TEMPLATE_alias_1 }
+export { DEFAULT_TEMPLATE as DEFAULT_TEMPLATE_alias_2 }
+
+declare function defineAgent(config: AgentConfig): AgentConfig;
+export { defineAgent }
+export { defineAgent as defineAgent_alias_1 }
+
+declare function defineChannel(config: ChannelConfig): ChannelConfig;
+export { defineChannel }
+export { defineChannel as defineChannel_alias_1 }
+
+declare function defineConnection(config: ConnectionConfig): ConnectionConfig;
+export { defineConnection }
+export { defineConnection as defineConnection_alias_1 }
+
+declare function defineHook(config: HookConfig): HookConfig;
+export { defineHook }
+export { defineHook as defineHook_alias_1 }
+
+declare function defineInstructions(source: string | InstructionsConfig): InstructionsConfig;
+export { defineInstructions }
+export { defineInstructions as defineInstructions_alias_1 }
+
+declare function defineSchedule(config: ScheduleConfig): ScheduleConfig;
+export { defineSchedule }
+export { defineSchedule as defineSchedule_alias_1 }
+
+declare function defineSkill(config: SkillConfig): SkillConfig;
+export { defineSkill }
+export { defineSkill as defineSkill_alias_1 }
+
+declare function defineTool<TInput = unknown, TOutput = unknown>(config: ToolConfig<TInput, TOutput>): ToolConfig<TInput, TOutput>;
+export { defineTool }
+export { defineTool as defineTool_alias_1 }
+
+export declare function deleteForward(state: LineState): LineState;
+
+declare interface DeleteMessagesOptions {
+    threadId: string;
+    resourceId: string;
+    messageIds?: string[];
+    beforeTimestamp?: number;
+    afterTimestamp?: number;
+}
+export { DeleteMessagesOptions }
+export { DeleteMessagesOptions as DeleteMessagesOptions_alias_1 }
+
+export declare function deleteWord(state: LineState): LineState;
+
+export declare function detectUnicode(env?: NodeJS.ProcessEnv): boolean;
+
+export declare function devCommand(options: DevOptions): Promise<void>;
+
+export declare interface DevOptions {
+    port: string;
+    agentDir: string;
+    input?: boolean;
+}
+
+export declare interface Diagnostic {
+    severity: "info" | "warn" | "error";
+    message: string;
+    fix?: string;
+}
+
+export declare function dim(text: string): string;
+
+export declare function dimmed(text: string): string;
+
+declare function discoverAgent(agentDir: string): DiscoverResult;
+export { discoverAgent }
+export { discoverAgent as discoverAgent_alias_1 }
+
+export declare interface DiscoverDiagnostic {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+    filePath?: string;
+}
+
+export declare interface DiscoveredAgent {
+    root: string;
+    agentConfig?: string;
+    instructions?: string;
+    tools: DiscoveredSlot[];
+    skills: DiscoveredSlot[];
+    hooks: DiscoveredSlot[];
+    channels: DiscoveredSlot[];
+    schedules: DiscoveredSlot[];
+    connections: DiscoveredSlot[];
+    subagents: DiscoveredSubagent[];
+    lib: DiscoveredSlot[];
+}
+
+export declare interface DiscoveredSlot {
+    name: string;
+    filePath: string;
+    type: "markdown" | "module";
+    kind: "flat" | "named";
+}
+
+/** A subagent is a nested agent directory, not a flat file. */
+export declare interface DiscoveredSubagent {
+    id: string;
+    root: string;
+    agentConfig?: string;
+    instructions?: string;
+    tools: DiscoveredSlot[];
+    skills: DiscoveredSlot[];
+}
+
+export declare interface DiscoverResult {
+    agent: DiscoveredAgent;
+    diagnostics: DiscoverDiagnostic[];
+}
+
+export declare function divider(): void;
+
+declare interface Embedder {
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+    readonly dimensions: number;
+}
+export { Embedder }
+export { Embedder as Embedder_alias_1 }
+
+export declare const EMPTY_LINE: LineState;
+
+declare function encodeEvent(event: StreamEvent): string;
+export { encodeEvent }
+export { encodeEvent as encodeEvent_alias_1 }
+
+declare function encodeEvents(events: StreamEvent[]): string;
+export { encodeEvents }
+export { encodeEvents as encodeEvents_alias_1 }
+
+declare function ensureContext<T>(key: string, factory: () => T): T;
+export { ensureContext }
+export { ensureContext as ensureContext_alias_1 }
+
+/**
+ * Pure(ish) fold from `StreamEvent`s to `BlockOp`s.
+ *
+ * Owns just enough state to correlate stream events with live blocks: the
+ * currently streaming assistant / reasoning blocks per level, an in-flight
+ * tool map keyed by `callId`, and a subagent depth stack. Every method takes
+ * one event and returns the ops that should be applied to the renderer's
+ * block store.
+ */
+export declare class EventTranslator {
+    #private;
+    constructor(options?: TranslatorOptions);
+    get depth(): number;
+    reset(): BlockOp[];
+    feed(event: StreamEvent): BlockOp[];
+}
+
+export declare function fetchModelCatalog(): Promise<CatalogModel[]>;
+
+declare class FileStore implements MemoryStore {
+    private baseDir;
+    constructor(baseDir?: string);
+    private filePath;
+    private threadsPath;
+    private read;
+    private write;
+    private readThreads;
+    private writeThreads;
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    close(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+export { FileStore }
+export { FileStore as FileStore_alias_1 }
+export { FileStore as FileStore_alias_2 }
+
+export declare function formatAssistantResponseStats(stats: AssistantResponseStats, mode: AssistantResponseStatsMode): string | undefined;
+
+export declare function formatCompactTokenCount(count: number): string;
+
+export declare function formatElapsed(milliseconds: number): string;
+
+export declare function formatPromptCommandHelp(commands?: readonly PromptCommandSpec[]): string;
+
+export declare function formatTokenFlow(flow: {
+    inputTokens: number;
+    outputTokens: number;
+    contextSize?: number;
+}, glyph: {
+    arrowUp: string;
+    arrowDown: string;
+}): string;
+
+export declare function formatValuePretty(value: unknown): string;
+
+declare function GET(handler: ChannelConfig["handler"]): ChannelConfig["handler"];
+export { GET }
+export { GET as GET_alias_1 }
+
+declare function getContext<T = unknown>(key: string): T | undefined;
+export { getContext }
+export { getContext as getContext_alias_1 }
+
+declare function getProviderApiKey(provider: string): string | undefined;
+export { getProviderApiKey }
+export { getProviderApiKey as getProviderApiKey_alias_1 }
+
+declare function getSession(): Session | null;
+export { getSession }
+export { getSession as getSession_alias_1 }
+
+declare function getSkill(agentDir: string, name: string): SkillConfig | null;
+export { getSkill }
+export { getSkill as getSkill_alias_1 }
+
+declare function getTurn(): TurnContext | null;
+export { getTurn }
+export { getTurn as getTurn_alias_1 }
+
+export declare const glyph: {
+    user: string;
+    assistant: string;
+    tool: string;
+    error: string;
+    check: string;
+    cross: string;
+    bullet: string;
+    divider: string;
+};
+
+export declare function graphemeBoundaryAtOrAfter(text: string, offset: number): number;
+
+export declare function graphemes(text: string): GraphemeSpan[];
+
+declare interface GraphemeSpan {
+    readonly text: string;
+    readonly start: number;
+    readonly end: number;
+}
+
+export declare function green(text: string): string;
+
+export declare function grey(text: string): string;
+
+export declare function handleSessionsRequest(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+
+declare function hasContext(key: string): boolean;
+export { hasContext }
+export { hasContext as hasContext_alias_1 }
+
+declare interface HookConfig {
+    name: string;
+    event: HookEvent;
+    handler: (payload: HookPayload) => void | Promise<void>;
+}
+export { HookConfig }
+export { HookConfig as HookConfig_alias_1 }
+
+declare type HookEvent = "beforeTurn" | "afterTurn" | "beforeToolCall" | "afterToolCall" | "onError" | "onStart" | "onEnd";
+export { HookEvent }
+export { HookEvent as HookEvent_alias_1 }
+
+declare interface HookPayload {
+    turn?: TurnContext;
+    toolCall?: ToolCallContext;
+    error?: Error;
+}
+export { HookPayload }
+export { HookPayload as HookPayload_alias_1 }
+
+export declare function initCommand(name: string | undefined, options: {
+    template: string;
+}): Promise<void>;
+
+declare class InMemoryStore implements MemoryStore {
+    private entries;
+    private threads;
+    private key;
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    search(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    close(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, _resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, _resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+export { InMemoryStore }
+export { InMemoryStore as InMemoryStore_alias_1 }
+export { InMemoryStore as InMemoryStore_alias_2 }
+
+declare interface InputProcessor {
+    name: string;
+    processInput(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+}
+export { InputProcessor }
+export { InputProcessor as InputProcessor_alias_1 }
+
+export declare function inputTextWidth(input: string): number;
+
+export declare function insert(state: LineState, value: string): LineState;
+
+declare interface InstructionsConfig {
+    content: string;
+    filePath?: string;
+}
+export { InstructionsConfig }
+export { InstructionsConfig as InstructionsConfig_alias_1 }
+
+export declare function isIncompletePaste(buffer: string): boolean;
+
+export declare function isProgressPulseVisible(elapsedMs: number): boolean;
+
+export declare function isPromptControlCommand(prompt: string): boolean;
+
+export declare function isProviderKeySet(agentDir: string, envVar: string): boolean;
+
+declare class KeyFactsStrategy implements MemoryStrategy {
+    private facts;
+    private loaded;
+    private ensureLoaded;
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, _toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { KeyFactsStrategy }
+export { KeyFactsStrategy as KeyFactsStrategy_alias_1 }
+export { KeyFactsStrategy as KeyFactsStrategy_alias_2 }
+
+export declare interface KeyToken {
+    key?: TerminalKey;
+    consumed: number;
+    incomplete?: boolean;
+}
+
+export declare function killToEnd(state: LineState): LineState;
+
+export declare function killToStart(state: LineState): LineState;
+
+declare class LastNStrategy implements MemoryStrategy {
+    private limit;
+    constructor(limit?: number);
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { LastNStrategy }
+export { LastNStrategy as LastNStrategy_alias_1 }
+export { LastNStrategy as LastNStrategy_alias_2 }
+
+export declare function layoutPromptInput(state: LineState): PromptLayout;
+
+declare interface LineEditorOptions {
+    readonly multiline?: boolean;
+}
+
+export declare function lineOf(text: string): LineState;
+
+export declare interface LineState {
+    readonly text: string;
+    readonly cursor: number;
+}
+
+/**
+ * Bottom-anchored redraw region.
+ *
+ * `paint(rows)` diffs against the previously painted frame and rewrites only
+ * what changed. `commit(rows)` scrolls new lines above the live region into
+ * scrollback and repaints. Callers own the string contents; this class owns
+ * cursor arithmetic.
+ */
+export declare class LiveRegion {
+    #private;
+    constructor(options?: LiveRegionOptions);
+    get columns(): number;
+    get rows(): number;
+    /**
+     * Redraws the live region to match `rows`. The cursor is positioned at
+     * `caret` (1-indexed row within the region, 1-indexed column). Passing an
+     * empty array clears the region without leaving trailing blank lines.
+     */
+    paint(rows: readonly string[], caret?: LiveRegionCaret): void;
+    /**
+     * Commits `rows` to scrollback above the live region, then repaints the
+     * region beneath them. Rows are terminated by newlines so the terminal
+     * scrolls each into history.
+     */
+    commit(rows: readonly string[]): void;
+    /**
+     * Clears the live region and shows the cursor at the start of what used to
+     * be the region's first row. Idempotent; safe to call from cleanup paths.
+     */
+    stop(): void;
+}
+
+export declare interface LiveRegionCaret {
+    readonly row: number;
+    readonly col: number;
+}
+
+export declare interface LiveRegionOptions {
+    readonly output?: TerminalOutput;
+    readonly onResize?: (size: {
+        columns: number;
+        rows: number;
+    }) => void;
+}
+
+export declare interface LlmMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+
+export declare interface LlmStreamEvent {
+    type: "delta" | "tool_call" | "done" | "error";
+    delta?: string;
+    toolCall?: {
+        name: string;
+        arguments: string;
+        id: string;
+    };
+    toolCalls?: Array<{
+        name: string;
+        arguments: string;
+        id: string;
+    }>;
+    finishReason?: string;
+    error?: string;
+}
+
+declare function loadAgent(agentDir: string): Promise<LoadedAgent>;
+export { loadAgent }
+export { loadAgent as loadAgent_alias_1 }
+
+export declare interface LoadedAgent {
+    manifest: AgentManifest;
+    agentDir: string;
+}
+
+declare function loadInstructions(agentDir: string): InstructionsConfig | null;
+export { loadInstructions }
+export { loadInstructions as loadInstructions_alias_1 }
+
+export declare function maskLine(state: LineState): LineState;
+
+export declare function matchingCommands(commands: readonly PromptCommandSpec[], text: string): readonly PromptCommandSpec[];
+
+declare class Memory {
+    store: MemoryStore;
+    resourceId: string;
+    threadId: string;
+    private processors;
+    private readOnly;
+    private buildSource;
+    constructor(options?: MemoryOptions);
+    constructor(config: SessionConfig["memory"], options?: MemoryOptions);
+    private buildFromConfig;
+    /**
+     * Create a new Memory instance sharing the same store and configuration
+     * but with overridden resourceId, threadId, and/or readOnly.
+     * Useful for per-request memory config.
+     */
+    with(overrides: {
+        resourceId?: string;
+        threadId?: string;
+        readOnly?: boolean;
+    }): Memory;
+    destroy(): Promise<void>;
+    getInputContext(): Promise<string>;
+    getSystemInstruction(): string;
+    getToolDefinitions(): Record<string, ToolConfig>;
+    recordTurn(input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+    recall(opts: RecallOptions): Promise<RecallResult>;
+}
+export { Memory }
+export { Memory as Memory_alias_1 }
+
+declare interface MemoryEntry {
+    role: "user" | "assistant" | "tool" | "system";
+    content: string;
+    timestamp: number;
+    turnId?: string;
+    score?: number;
+}
+export { MemoryEntry }
+export { MemoryEntry as MemoryEntry_alias_1 }
+export { MemoryEntry as MemoryEntry_alias_2 }
+
+export declare interface MemoryOptions {
+    store?: MemoryStore;
+    resourceId?: string;
+    threadId?: string;
+    processors?: (MemoryProcessor | MemoryStrategy)[];
+    embedder?: Embedder;
+    vectorStore?: VectorStore;
+    lastMessages?: number;
+    readOnly?: boolean;
+}
+
+declare interface MemoryProcessor extends InputProcessor {
+    processOutput?(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { MemoryProcessor }
+export { MemoryProcessor as MemoryProcessor_alias_1 }
+
+declare interface MemoryQuery {
+    resourceId: string;
+    threadId: string;
+    query?: string;
+    limit?: number;
+}
+export { MemoryQuery }
+export { MemoryQuery as MemoryQuery_alias_1 }
+export { MemoryQuery as MemoryQuery_alias_2 }
+
+declare interface MemoryStore {
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    search?(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    close?(): Promise<void>;
+    createThread?(thread: Thread): Promise<void>;
+    getThread?(threadId: string, resourceId: string): Promise<Thread | null>;
+    listThreads?(resourceId: string): Promise<Thread[]>;
+    updateThread?(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread?(threadId: string, resourceId: string): Promise<void>;
+    deleteMessages?(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread?(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+export { MemoryStore }
+export { MemoryStore as MemoryStore_alias_1 }
+export { MemoryStore as MemoryStore_alias_2 }
+
+declare interface MemoryStrategy {
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { MemoryStrategy }
+export { MemoryStrategy as MemoryStrategy_alias_1 }
+export { MemoryStrategy as MemoryStrategy_alias_2 }
+
+declare interface MessageAppendedEvent {
+    type: "message.appended";
+    data: {
+        delta: string;
+        textSoFar: string;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { MessageAppendedEvent }
+export { MessageAppendedEvent as MessageAppendedEvent_alias_1 }
+
+declare interface MessageCompletedEvent {
+    type: "message.completed";
+    data: {
+        text: string | null;
+        finishReason: AssistantStepFinishReason;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { MessageCompletedEvent }
+export { MessageCompletedEvent as MessageCompletedEvent_alias_1 }
+
+declare class MessageHistoryProcessor implements InputProcessor, OutputProcessor {
+    name: string;
+    private limit;
+    constructor(limit?: number);
+    processInput(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    processOutput(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { MessageHistoryProcessor }
+export { MessageHistoryProcessor as MessageHistoryProcessor_alias_1 }
+export { MessageHistoryProcessor as MessageHistoryProcessor_alias_2 }
+
+declare interface MessageReceivedEvent {
+    type: "message.received";
+    data: {
+        message: string;
+        sequence: number;
+        turnId: string;
+    };
+}
+export { MessageReceivedEvent }
+export { MessageReceivedEvent as MessageReceivedEvent_alias_1 }
+
+export declare interface ModelToolDefinition {
+    name: string;
+    description: string;
+    input_schema?: Record<string, unknown>;
+    type: "function";
+}
+
+export declare function moveDown<T>(state: SelectState<T>): SelectState<T>;
+
+export declare function moveEnd(state: LineState): LineState;
+
+export declare function moveHome(state: LineState): LineState;
+
+export declare function moveLeft(state: LineState): LineState;
+
+export declare function movePromptLine(state: LineState, direction: "up" | "down"): LineState | undefined;
+
+export declare function moveRight(state: LineState): LineState;
+
+export declare function moveUp<T>(state: SelectState<T>): SelectState<T>;
+
+export declare function nextGraphemeBoundary(text: string, offset: number): number;
+
+export declare function nextKey(buffer: string): KeyToken;
+
+export declare function offsetAtVisibleColumn(input: string, column: number): number;
+
+declare type OutboundAuthFn = () => Promise<{
+    readonly headers: Readonly<Record<string, string>>;
+}>;
+export { OutboundAuthFn }
+export { OutboundAuthFn as OutboundAuthFn_alias_1 }
+
+declare interface OutputProcessor {
+    name: string;
+    processOutput(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { OutputProcessor }
+export { OutputProcessor as OutputProcessor_alias_1 }
+
+export declare interface PanelCaret {
+    readonly row: number;
+    readonly col: number;
+}
+
+export declare interface PanelFrame {
+    readonly rows: string[];
+    readonly caret: PanelCaret;
+}
+
+export declare function parseKey(chunk: Buffer): TerminalKey;
+
+export declare function parsePromptCommand(prompt: string): PromptCommand | null;
+
+declare interface PolicyConfig {
+    inputGuards?: string[];
+    outputGuards?: string[];
+    allowedModels?: string[];
+    blockedTools?: string[];
+    budget?: {
+        maxSpendPerSession?: string;
+        maxSpendPerDay?: string;
+        maxSpendPerMonth?: string;
+    };
+}
+export { PolicyConfig }
+export { PolicyConfig as PolicyConfig_alias_1 }
+
+declare function POST(handler: ChannelConfig["handler"]): ChannelConfig["handler"];
+export { POST }
+export { POST as POST_alias_1 }
+
+export declare function previousGraphemeBoundary(text: string, offset: number): number;
+
+export declare function printDiagnostics(diagnostics: Diagnostic[]): void;
+
+export declare const PROGRESS_PULSE_ASCII_GLYPH = "*";
+
+export declare const PROGRESS_PULSE_DURATION_MS = 1000;
+
+export declare const PROGRESS_PULSE_GLYPH = "\u25AA";
+
+export declare const PROGRESS_PULSE_SEQUENCE = "1111110000111111";
+
+export declare const PROMPT_COMMANDS: readonly PromptCommandSpec[];
+
+export declare type PromptCommand = {
+    type: "new";
+} | {
+    type: "exit";
+} | {
+    type: "help";
+} | {
+    type: "clear";
+} | {
+    type: "loglevel";
+    argument: string;
+} | {
+    type: "extension";
+    name: PromptCommandExtensionName;
+    argument: string;
+};
+
+export declare type PromptCommandExtensionName = "model" | "provider" | "channels";
+
+export declare interface PromptCommandSpec {
+    readonly name: string;
+    readonly aliases: readonly string[];
+    readonly description: string;
+    readonly argumentHint?: string;
+    readonly takesArgument: boolean;
+    readonly build: (argument: string) => PromptCommand;
+}
+
+export declare interface Prompter {
+    text(options: TextPromptOptions): Promise<string | undefined>;
+    select<T>(options: SelectPromptOptions<T>): Promise<T | undefined>;
+    searchableSelect<T>(options: SearchableSelectPromptOptions<T>): Promise<T | undefined>;
+    acknowledge(options: AcknowledgePromptOptions): Promise<void>;
+    spinner(message: string): SpinnerHandle;
+    section(title: string, lines: readonly string[]): void;
+    readonly log: PrompterLog;
+    stop(): void;
+}
+
+export declare interface PrompterLog {
+    info(message: string): void;
+    success(message: string): void;
+    warning(message: string): void;
+    error(message: string): void;
+}
+
+export declare class PromptHistory {
+    #private;
+    add(entry: string): void;
+    begin(draft: string): void;
+    previous(currentDraft: string): string | undefined;
+    next(): string | undefined;
+}
+
+declare interface PromptLayout {
+    readonly rows: PromptLogicalRow[];
+    readonly caretRow: number;
+    readonly caretOffset: number;
+}
+
+declare interface PromptLogicalRow {
+    readonly text: string;
+    readonly start: number;
+}
+
+export declare function providerEnvVar(modelId: string): {
+    provider: string;
+    envVar: string;
+} | undefined;
+
+declare interface ReasoningAppendedEvent {
+    type: "reasoning.appended";
+    data: {
+        delta: string;
+        soFar: string;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { ReasoningAppendedEvent }
+export { ReasoningAppendedEvent as ReasoningAppendedEvent_alias_1 }
+
+declare interface ReasoningCompletedEvent {
+    type: "reasoning.completed";
+    data: {
+        text: string;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { ReasoningCompletedEvent }
+export { ReasoningCompletedEvent as ReasoningCompletedEvent_alias_1 }
+
+declare interface RecallOptions {
+    threadId: string;
+    resourceId: string;
+    page?: number;
+    perPage?: number;
+    dateRange?: {
+        start?: Date;
+        end?: Date;
+    };
+    include?: Array<{
+        id: string;
+        withPreviousMessages?: number;
+        withNextMessages?: number;
+    }>;
+    vectorSearchString?: string;
+}
+export { RecallOptions }
+export { RecallOptions as RecallOptions_alias_1 }
+
+declare interface RecallResult {
+    messages: MemoryEntry[];
+    total: number;
+    hasMore: boolean;
+}
+export { RecallResult }
+export { RecallResult as RecallResult_alias_1 }
+
+export declare function red(text: string): string;
+
+export declare function renderAttentionRows(body: string, width: number, theme: Theme): string[];
+
+export declare interface RenderBlockContext {
+    spinner: string;
+    previous?: {
+        kind: BlockKind;
+        title?: string;
+    };
+}
+
+export declare function renderBlockLines(block: Block, width: number, theme: Theme, context: RenderBlockContext): string[];
+
+export declare function renderCliBanner(theme: CliTheme, input: {
+    readonly subtitle?: string;
+    readonly title: string;
+}): string;
+
+export declare function renderCliSection(theme: CliTheme, input: {
+    readonly rows: readonly CliRow[];
+    readonly title: string;
+}): string;
+
+export declare function renderCliSpeakerLine(theme: CliTheme, input: {
+    readonly message: string;
+    readonly speaker: string;
+    readonly tone?: CliMessageTone;
+}): string;
+
+export declare function renderCliTaggedLine(theme: CliTheme, input: {
+    readonly message: string;
+    readonly tag: string;
+    readonly tone?: CliMessageTone;
+}): string;
+
+export declare function renderInputText(input: string): string;
+
+export declare function renderInputWithBlockCursor(input: BlockCursorInput): string;
+
+export declare function renderMarkdown(input: string): string;
+
+export declare function renderSelectPanel<T>(state: SelectState<T>, message: string, theme: Theme, width: number, options?: {
+    searchable?: boolean;
+    placeholder?: string;
+}): PanelFrame;
+
+export declare function renderTextPanel(state: TextInputState, theme: Theme, width: number): PanelFrame;
+
+declare function requireContext<T = unknown>(key: string): T;
+export { requireContext }
+export { requireContext as requireContext_alias_1 }
+
+declare function runAgent(agentDir: string, input: string, options?: RunOptions): Promise<RunResult>;
+export { runAgent }
+export { runAgent as runAgent_alias_1 }
+
+export declare function runCli(argv?: string[], logger?: CliLogger): Promise<void>;
+
+export declare interface RunOptions {
+    endpoint?: string;
+    apiKey?: string;
+    maxTurns?: number;
+    sessionId?: string;
+    resourceId?: string;
+    threadId?: string;
+    memoryStore?: MemoryStore;
+    onEvent?: (event: StreamEvent) => void;
+}
+
+export declare interface RunResult {
+    output: string;
+    turns: TurnContext[];
+    events: StreamEvent[];
+    sessionId: string;
+}
+
+export declare function sanitizeForTerminal(input: string): string;
+
+export declare function sanitizePastedText(text: string): string;
+
+/**
+ * Copies the web-chat template into `<agentDir>/channels/web`. If the target
+ * already exists, leaves it untouched and reports so callers can decide
+ * whether to prompt for overwrite.
+ */
+export declare function scaffoldWebChat(agentDir: string): ScaffoldWebChatResult;
+
+export declare interface ScaffoldWebChatResult {
+    readonly targetPath: string;
+    readonly alreadyExisted: boolean;
+}
+
+declare interface ScheduleConfig {
+    name: string;
+    cron: string;
+    handler: () => void | Promise<void>;
+    timezone?: string;
+}
+export { ScheduleConfig }
+export { ScheduleConfig as ScheduleConfig_alias_1 }
+
+export declare interface SearchableSelectPromptOptions<T = string> extends SelectPromptOptions<T> {
+    readonly placeholder?: string;
+}
+
+export declare function selected<T>(state: SelectState<T>): SelectOption<T> | undefined;
+
+export declare interface SelectOption<T = string> {
+    readonly value: T;
+    readonly label: string;
+    readonly description?: string;
+}
+
+export declare interface SelectPromptOptions<T = string> {
+    readonly message: string;
+    readonly options: readonly SelectOption<T>[];
+    readonly initialValue?: T;
+}
+
+export declare interface SelectState<T = string> {
+    readonly options: readonly SelectOption<T>[];
+    readonly matches: readonly SelectOption<T>[];
+    readonly selectedIndex: number;
+    readonly query: string;
+}
+
+declare class SemanticRecall implements MemoryStrategy {
+    private topK;
+    constructor(topK?: number);
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { SemanticRecall }
+export { SemanticRecall as SemanticRecall_alias_1 }
+export { SemanticRecall as SemanticRecall_alias_2 }
+
+declare interface SemanticRecallConfig {
+    topK?: number;
+    messageRange?: number;
+    scope?: "thread" | "resource";
+}
+export { SemanticRecallConfig }
+export { SemanticRecallConfig as SemanticRecallConfig_alias_1 }
+
+declare class SemanticRecallProcessor implements MemoryProcessor {
+    name: string;
+    private config;
+    private embedder;
+    private vectorStore;
+    constructor(embedder: Embedder, vectorStore: VectorStore, config?: SemanticRecallConfig);
+    processInput(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    processOutput(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { SemanticRecallProcessor }
+export { SemanticRecallProcessor as SemanticRecallProcessor_alias_1 }
+export { SemanticRecallProcessor as SemanticRecallProcessor_alias_2 }
+
+declare interface Session {
+    id: string;
+    created: Date;
+    turns: TurnContext[];
+    metadata: Record<string, unknown>;
+}
+export { Session }
+export { Session as Session_alias_1 }
+
+declare interface SessionCompletedEvent {
+    type: "session.completed";
+}
+export { SessionCompletedEvent }
+export { SessionCompletedEvent as SessionCompletedEvent_alias_1 }
+
+declare interface SessionConfig {
+    maxTurns?: number;
+    idleTimeoutMs?: number;
+    requireApproval?: boolean;
+    memory?: {
+        strategy: "lastN" | "summary" | "keyFacts" | "semantic";
+        limit?: number;
+        workingMemory?: boolean;
+        workingMemoryTemplate?: string;
+    };
+}
+export { SessionConfig }
+export { SessionConfig as SessionConfig_alias_1 }
+
+declare interface SessionFailedEvent {
+    type: "session.failed";
+    data: {
+        code: string;
+        message: string;
+        sessionId: string;
+    };
+}
+export { SessionFailedEvent }
+export { SessionFailedEvent as SessionFailedEvent_alias_1 }
+
+declare interface SessionStartedEvent {
+    type: "session.started";
+    data: {
+        sessionId: string;
+        runtime?: {
+            agentId: string;
+            modelId: string;
+            arcieVersion: string;
+        };
+    };
+}
+export { SessionStartedEvent }
+export { SessionStartedEvent as SessionStartedEvent_alias_1 }
+
+declare interface SessionWaitingEvent {
+    type: "session.waiting";
+    data: {
+        wait: "next-user-message";
+    };
+}
+export { SessionWaitingEvent }
+export { SessionWaitingEvent as SessionWaitingEvent_alias_1 }
+
+declare function setContext(key: string, value: unknown): void;
+export { setContext }
+export { setContext as setContext_alias_1 }
+
+export declare function setQuery<T>(state: SelectState<T>, query: string): SelectState<T>;
+
+declare function setSession(session: Session): void;
+export { setSession }
+export { setSession as setSession_alias_1 }
+
+declare function setTurn(turn: TurnContext): void;
+export { setTurn }
+export { setTurn as setTurn_alias_1 }
+
+export declare function showHeader(): void;
+
+declare interface SkillConfig {
+    name: string;
+    description: string;
+    content: string;
+}
+export { SkillConfig }
+export { SkillConfig as SkillConfig_alias_1 }
+
+export declare function sliceVisible(input: string, width: number): string;
+
+/**
+ * Helper for multi-user threads.
+ *
+ * When multiple people share a single thread, wrap each user message in a
+ * <turn> tag so the agent can distinguish speakers. All participants use
+ * the same resourceId (keyed on the conversation, not the user) and the
+ * same threadId.
+ *
+ * Example usage in agent instructions:
+ *
+ *   Every user message is wrapped in a <turn> tag:
+ *
+ *     <turn author_id="u_alice" author_name="Alice" functional_role="editor">
+ *     ...message text...
+ *     </turn>
+ *
+ *   Rules:
+ *   1. Address users by their author_name.
+ *   2. Respect functional_role.
+ *   3. When attributing past statements, read author_name from the <turn> tag.
+ *   4. Do not echo the <turn> tags back at the user.
+ */
+declare type Speaker = {
+    id: string;
+    name: string;
+    role: string;
+};
+export { Speaker }
+export { Speaker as Speaker_alias_1 }
+
+export declare interface SpinnerHandle {
+    update(message: string): void;
+    stop(outcome?: SpinnerOutcome): void;
+}
+
+export declare type SpinnerOutcome = {
+    kind: "success";
+    message?: string;
+} | {
+    kind: "warning";
+    message?: string;
+} | {
+    kind: "error";
+    message?: string;
+} | {
+    kind: "silent";
+};
+
+declare class SqliteStore implements MemoryStore {
+    private client;
+    constructor(dbPath?: string);
+    private init;
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    search(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    close(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, _resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, _resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+export { SqliteStore }
+export { SqliteStore as SqliteStore_alias_1 }
+export { SqliteStore as SqliteStore_alias_2 }
+
+/**
+ * Runs the block-based dev TUI against a local agent directory. Returns when
+ * the user submits `/exit` or presses Ctrl+C. Ownership of raw stdin is
+ * scoped to this function; the caller does not need to restore terminal
+ * state on exit paths.
+ */
+export declare function startBlockChat(options: StartBlockChatOptions): Promise<void>;
+
+export declare interface StartBlockChatOptions {
+    readonly agentDir: string;
+    readonly initialInput?: string;
+}
+
+export declare function startCliLiveRow(logger: CliLiveRowLogger, options?: CliLiveRowOptions): CliLiveRow;
+
+declare interface StepCompletedEvent {
+    type: "step.completed";
+    data: {
+        finishReason: AssistantStepFinishReason;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+        usage?: {
+            inputTokens?: number;
+            outputTokens?: number;
+        };
+    };
+}
+export { StepCompletedEvent }
+export { StepCompletedEvent as StepCompletedEvent_alias_1 }
+
+declare interface StepFailedEvent {
+    type: "step.failed";
+    data: {
+        code: string;
+        message: string;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { StepFailedEvent }
+export { StepFailedEvent as StepFailedEvent_alias_1 }
+
+declare interface StepStartedEvent {
+    type: "step.started";
+    data: {
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { StepStartedEvent }
+export { StepStartedEvent as StepStartedEvent_alias_1 }
+
+/**
+ * Wraps a legacy MemoryStrategy into the MemoryProcessor interface.
+ * Allows gradual migration: old strategies (LastN, Summary, KeyFacts) work
+ * unchanged inside the new processor pipeline.
+ */
+declare class StrategyAdapter implements MemoryProcessor {
+    name: string;
+    private strategy;
+    constructor(strategy: MemoryStrategy);
+    processInput(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    processOutput(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+    getToolDefinitions?(): Record<string, ToolConfig>;
+}
+export { StrategyAdapter }
+export { StrategyAdapter as StrategyAdapter_alias_1 }
+
+declare function streamAgent(agentDir: string, input: string, options?: RunOptions): AsyncGenerator<StreamEvent, void, unknown>;
+export { streamAgent }
+export { streamAgent as streamAgent_alias_1 }
+
+declare type StreamEvent = SessionStartedEvent | TurnStartedEvent | MessageReceivedEvent | MessageAppendedEvent | MessageCompletedEvent | ReasoningAppendedEvent | ReasoningCompletedEvent | StepStartedEvent | StepCompletedEvent | StepFailedEvent | ToolCallStartedEvent | ToolCallCompletedEvent | TurnCompletedEvent | TurnFailedEvent | SessionWaitingEvent | SessionCompletedEvent | SessionFailedEvent | SubagentCalledEvent | SubagentCompletedEvent;
+export { StreamEvent }
+export { StreamEvent as StreamEvent_alias_1 }
+
+export declare function streamLlm(modelId: string, messages: LlmMessage[], tools?: ModelToolDefinition[], toolResults?: ToolResult[]): AsyncGenerator<LlmStreamEvent>;
+
+export declare function stripAnsi(input: string): string;
+
+export declare function stripPasteStart(buffer: string): string;
+
+export declare function stripPromptControlCharacters(text: string): string;
+
+export declare function stripTerminalControls(input: string): string;
+
+declare type Style = (text: string) => string;
+
+declare interface SubagentCalledEvent {
+    type: "subagent.called";
+    data: {
+        name: string;
+        callId: string;
+        childSessionId: string;
+        turnId: string;
+    };
+}
+export { SubagentCalledEvent }
+export { SubagentCalledEvent as SubagentCalledEvent_alias_1 }
+
+declare interface SubagentCompletedEvent {
+    type: "subagent.completed";
+    data: {
+        name: string;
+        callId: string;
+        output: string;
+    };
+}
+export { SubagentCompletedEvent }
+export { SubagentCompletedEvent as SubagentCompletedEvent_alias_1 }
+
+/**
+ * A subagent is a fully self-contained child agent the orchestrator can
+ * delegate a focused subtask to. It runs in its own fresh, isolated session —
+ * it never inherits the parent's conversation history; the parent passes all
+ * needed context in via the delegation `message`.
+ */
+declare interface SubagentManifest {
+    /** The child agent's config. `description` is required (validated at load). */
+    config: AgentConfig;
+    instructions: string;
+    tools: Record<string, ToolConfig>;
+    skills: Record<string, SkillConfig>;
+}
+export { SubagentManifest }
+export { SubagentManifest as SubagentManifest_alias_1 }
+
+declare type SummarizeFn = (text: string) => Promise<string>;
+export { SummarizeFn }
+export { SummarizeFn as SummarizeFn_alias_1 }
+export { SummarizeFn as SummarizeFn_alias_2 }
+
+export declare function summarizeToolArgs(input: unknown, maxLength?: number): string;
+
+export declare function summarizeToolResult(output: unknown, maxLength?: number): string;
+
+declare class SummaryStrategy implements MemoryStrategy {
+    private limit;
+    private summary;
+    private summarize;
+    private mutex;
+    constructor(limit?: number, summarize?: SummarizeFn);
+    private exclusive;
+    private defaultSummarize;
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { SummaryStrategy }
+export { SummaryStrategy as SummaryStrategy_alias_1 }
+export { SummaryStrategy as SummaryStrategy_alias_2 }
+
+export declare type TerminalKey = {
+    type: "text";
+    value: string;
+    framing: "unframed" | "bracketed-paste";
+} | {
+    type: "newline";
+} | {
+    type: "backspace";
+} | {
+    type: "delete";
+} | {
+    type: "enter";
+} | {
+    type: "up";
+} | {
+    type: "down";
+} | {
+    type: "left";
+} | {
+    type: "right";
+} | {
+    type: "home";
+} | {
+    type: "end";
+} | {
+    type: "tab";
+} | {
+    type: "escape";
+} | {
+    type: "ctrl-a";
+} | {
+    type: "ctrl-e";
+} | {
+    type: "ctrl-d";
+} | {
+    type: "ctrl-k";
+} | {
+    type: "ctrl-n";
+} | {
+    type: "ctrl-p";
+} | {
+    type: "ctrl-u";
+} | {
+    type: "ctrl-w";
+} | {
+    type: "ctrl-l";
+} | {
+    type: "ctrl-r";
+} | {
+    type: "ctrl-c";
+} | {
+    type: "ignore";
+};
+
+export declare interface TerminalOutput {
+    readonly isTTY?: boolean;
+    readonly columns?: number;
+    readonly rows?: number;
+    write(chunk: string): boolean;
+    on(event: "resize", listener: () => void): unknown;
+    off(event: "resize", listener: () => void): unknown;
+}
+
+/**
+ * Terminal-side glue for the block renderer.
+ *
+ * Owns the LiveRegion, the block store, the line editor's `LineState`, and
+ * the slash-command typeahead. External code feeds it stream events via
+ * {@link apply} and key presses via {@link handleKey}; the renderer decides
+ * when a prompt has been submitted and resolves the pending
+ * `readPrompt` promise with its text.
+ */
+export declare class TerminalRenderer {
+    #private;
+    constructor(options?: TerminalRendererOptions);
+    apply(ops: readonly BlockOp[]): void;
+    writeNotice(text: string): void;
+    writeError(title: string, message: string): void;
+    writeAgentHeader(body: string): void;
+    readPrompt(): Promise<string | undefined>;
+    handleKey(key: TerminalKey): void;
+    stop(): void;
+    get columns(): number;
+}
+
+export declare interface TerminalRendererOptions {
+    readonly output?: TerminalOutput;
+    readonly theme?: Theme;
+    readonly commands?: readonly PromptCommandSpec[];
+    readonly spinnerIntervalMs?: number;
+}
+
+export declare interface TextInputState {
+    readonly line: LineState;
+    readonly message: string;
+    readonly placeholder?: string;
+    readonly mask: boolean;
+    readonly validate?: (value: string) => string | undefined;
+    readonly validationError?: string;
+}
+
+export declare interface TextPromptOptions {
+    readonly message: string;
+    readonly placeholder?: string;
+    readonly defaultValue?: string;
+    readonly mask?: boolean;
+    readonly validate?: (value: string) => string | undefined;
+}
+
+export declare interface Theme {
+    readonly color: boolean;
+    readonly unicode: boolean;
+    readonly colors: ThemeColors;
+    readonly glyph: ThemeGlyphs;
+    readonly spinner: readonly string[];
+}
+
+export declare interface ThemeColors {
+    reset: Style;
+    bold: Style;
+    dim: Style;
+    inverse: Style;
+    italic: Style;
+    white: Style;
+    gray: Style;
+    cyan: Style;
+    green: Style;
+    red: Style;
+    yellow: Style;
+    magenta: Style;
+    blue: Style;
+    orange: Style;
+}
+
+export declare interface ThemeGlyphs {
+    brand: string;
+    user: string;
+    reasoning: string;
+    success: string;
+    error: string;
+    warning: string;
+    subagent: string;
+    rule: string;
+    question: string;
+    connection: string;
+    arrow: string;
+    pointer: string;
+    selectedPointer: string;
+    option: string;
+    prompt: string;
+    elbow: string;
+    hrule: string;
+    caret: string;
+    dot: string;
+    ellipsis: string;
+    arrowUp: string;
+    arrowDown: string;
+}
+
+declare interface Thread {
+    id: string;
+    resourceId: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+}
+export { Thread }
+export { Thread as Thread_alias_1 }
+
+export declare interface ThreadMessage {
+    id: string;
+    role: MemoryEntry["role"];
+    content: string;
+    timestamp: number;
+}
+
+declare type TokenValue = string | (() => string | Promise<string>);
+export { TokenValue }
+export { TokenValue as TokenValue_alias_1 }
+
+declare function toModelOutput(name: string, tool: ToolConfig): ModelToolDefinition;
+export { toModelOutput }
+export { toModelOutput as toModelOutput_alias_1 }
+
+declare interface ToolCallCompletedEvent {
+    type: "tool.completed";
+    data: {
+        name: string;
+        output: unknown;
+        callId: string;
+        status: ActionResultStatus;
+        error?: ActionResultError;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { ToolCallCompletedEvent }
+export { ToolCallCompletedEvent as ToolCallCompletedEvent_alias_1 }
+
+declare interface ToolCallContext {
+    tool: string;
+    input: unknown;
+    output?: unknown;
+    durationMs?: number;
+    error?: Error;
+}
+export { ToolCallContext }
+export { ToolCallContext as ToolCallContext_alias_1 }
+
+declare interface ToolCallStartedEvent {
+    type: "tool.started";
+    data: {
+        name: string;
+        input: unknown;
+        callId: string;
+        sequence: number;
+        stepIndex: number;
+        turnId: string;
+    };
+}
+export { ToolCallStartedEvent }
+export { ToolCallStartedEvent as ToolCallStartedEvent_alias_1 }
+
+declare interface ToolConfig<TInput = unknown, TOutput = unknown> {
+    name?: string;
+    description: string;
+    inputSchema?: z.ZodType<TInput>;
+    outputSchema?: z.ZodType<TOutput>;
+    sandbox?: boolean;
+    needsApproval?: ApprovalStrategy;
+    execute: (input: TInput) => TOutput | Promise<TOutput>;
+}
+export { ToolConfig }
+export { ToolConfig as ToolConfig_alias_1 }
+
+export declare interface ToolResult {
+    action_id: string;
+    output: string;
+}
+
+export declare type ToolStatus = "running" | "done" | "error" | "denied" | "approval";
+
+export declare interface TranslatorOptions {
+    /** Auto-collapse a live reasoning block when the assistant starts speaking. Default true. */
+    readonly autoCollapseReasoning?: boolean;
+}
+
+export declare function truncate(text: string, maxLength: number): string;
+
+export declare interface TuiPrompterOptions {
+    readonly output?: TerminalOutput;
+    readonly theme?: Theme;
+    readonly spinnerIntervalMs?: number;
+}
+
+declare interface TurnCompletedEvent {
+    type: "turn.completed";
+    data: {
+        sequence: number;
+        turnId: string;
+    };
+}
+export { TurnCompletedEvent }
+export { TurnCompletedEvent as TurnCompletedEvent_alias_1 }
+
+declare interface TurnContext {
+    id: string;
+    sessionId?: string;
+    input: string;
+    output?: string;
+    toolCalls?: ToolCallContext[];
+}
+export { TurnContext }
+export { TurnContext as TurnContext_alias_1 }
+
+declare interface TurnFailedEvent {
+    type: "turn.failed";
+    data: {
+        code: string;
+        message: string;
+        sequence: number;
+        turnId: string;
+    };
+}
+export { TurnFailedEvent }
+export { TurnFailedEvent as TurnFailedEvent_alias_1 }
+
+declare interface TurnStartedEvent {
+    type: "turn.started";
+    data: {
+        sequence: number;
+        turnId: string;
+    };
+}
+export { TurnStartedEvent }
+export { TurnStartedEvent as TurnStartedEvent_alias_1 }
+
+/**
+ * Runs the caller-supplied `validate` against the current draft and returns
+ * a state carrying the error message, or `undefined` when the draft is
+ * accepted. Submit paths call this and only complete the promise when it
+ * returns `undefined`.
+ */
+export declare function validateTextInput(state: TextInputState): TextInputState | undefined;
+
+declare interface VectorStore {
+    upsert(namespace: string, vectors: Array<{
+        id: string;
+        values: number[];
+        metadata?: Record<string, unknown>;
+    }>): Promise<void>;
+    query(namespace: string, vector: number[], options?: {
+        topK?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<Array<{
+        id: string;
+        score: number;
+        metadata?: Record<string, unknown>;
+    }>>;
+    delete(namespace: string, ids: string[]): Promise<void>;
+}
+export { VectorStore }
+export { VectorStore as VectorStore_alias_1 }
+
+export declare function version(): string;
+
+export declare function visibleLength(input: string): number;
+
+declare interface VisibleLine {
+    readonly before: string;
+    readonly under: string;
+    readonly after: string;
+}
+
+export declare function visibleLine(state: LineState, budget: number, ellipsis?: string): VisibleLine;
+
+export declare function white(text: string): string;
+
+declare const WORKING_MEMORY_SYSTEM_INSTRUCTION = "You have access to a persistent working memory that stores information about the user.\nYou can read the current working memory below and update it using the `updateWorkingMemory` tool.\n\nWhen the user tells you something about themselves, update the working memory to reflect it.\nUse the `updateWorkingMemory` tool with `section` set to the markdown heading (e.g. \"Interests\") and `content` set to the new bullet list content for that section.";
+export { WORKING_MEMORY_SYSTEM_INSTRUCTION }
+export { WORKING_MEMORY_SYSTEM_INSTRUCTION as WORKING_MEMORY_SYSTEM_INSTRUCTION_alias_1 }
+export { WORKING_MEMORY_SYSTEM_INSTRUCTION as WORKING_MEMORY_SYSTEM_INSTRUCTION_alias_2 }
+
+export declare const WORKING_MEMORY_SYSTEM_INSTRUCTION_alias_3 = "You have access to a persistent working memory that stores information about the user.\nYou can read the current working memory below and update it using the `updateWorkingMemory` tool.\n\nWhen the user tells you something about themselves, update the working memory to reflect it.\nUse the `updateWorkingMemory` tool with `content` set to the full updated markdown content.";
+
+declare class WorkingMemory implements MemoryStrategy {
+    private template;
+    private content;
+    private baseDir;
+    private resourceId;
+    private initialized;
+    constructor(template?: string, baseDir?: string, resourceId?: string);
+    private ensureDir;
+    private filePath;
+    private loadFromDisk;
+    private saveToDisk;
+    getSystemInstruction(): string;
+    getCurrentContent(resourceId: string): string;
+    updateSection(resourceId: string, section: string, content: string): void;
+    getToolDefinitions(): Record<string, ToolConfig>;
+    getInputContext(_store: MemoryStore, resourceId: string, _threadId: string): Promise<string>;
+    recordTurn(_store: MemoryStore, _resourceId: string, _threadId: string, _input: string, _output: string, _toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+export { WorkingMemory }
+export { WorkingMemory as WorkingMemory_alias_1 }
+export { WorkingMemory as WorkingMemory_alias_2 }
+
+declare interface WorkingMemoryConfig {
+    enabled?: boolean;
+    template?: string;
+    schema?: z.ZodType<any>;
+    scope?: "thread" | "resource";
+}
+export { WorkingMemoryConfig }
+export { WorkingMemoryConfig as WorkingMemoryConfig_alias_1 }
+
+declare class WorkingMemoryProcessor implements MemoryProcessor {
+    name: string;
+    private store;
+    private resourceId;
+    private threadId;
+    private config;
+    private mode;
+    currentContent: string;
+    constructor(store: MemoryStore, resourceId: string, threadId: string, config?: WorkingMemoryConfig);
+    private key;
+    private defaultContent;
+    loadContent(): Promise<string>;
+    processInput(_store: MemoryStore, _resourceId: string, _threadId: string): Promise<string>;
+    processOutput(_store: MemoryStore, _resourceId: string, _threadId: string, _input: string, _output: string, _toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+    getSystemInstruction(): string;
+    getToolDefinitions(): Record<string, ToolConfig>;
+}
+export { WorkingMemoryProcessor }
+export { WorkingMemoryProcessor as WorkingMemoryProcessor_alias_1 }
+export { WorkingMemoryProcessor as WorkingMemoryProcessor_alias_2 }
+
+export declare function wrapVisibleLine(line: string, width: number): string[];
+
+export declare function yellow(text: string): string;
+
+export { }