mu-harness 0.32.0 → 0.34.0

package/dist/index.d.ts

@@ -0,0 +1,1673 @@
+import { Message, Tool, ContentPart, LoopEvent, Provider, ModelModalities, Usage } from 'mu-core';
+import { Color, Component, InputEvent, Surface } from 'mu-tui';
+export { wrapText } from 'mu-tui';
+
+type ToolDecision = 'allow' | 'ask' | 'deny';
+type GrantValue = ToolDecision | Record<string, ToolDecision>;
+type ToolGrants = string[] | Record<string, GrantValue>;
+interface Agent {
+    name: string;
+    description: string;
+    prompt: string;
+    tools?: ToolGrants;
+    model?: string;
+    color?: string;
+    extends?: string;
+}
+
+interface AgentRegistry {
+    list(): Agent[];
+    get(name: string): Agent | undefined;
+    add(agent: Agent): void;
+    replaceAll(agents: Agent[]): void;
+}
+declare const grantArg: (tool: string, input: unknown) => string | undefined;
+declare const toolDecision: (agent: Agent, tool: string, arg?: string) => ToolDecision;
+declare const toolNames: (agent: Agent) => string[] | undefined;
+declare const createAgentRegistry: (agents?: Agent[]) => AgentRegistry;
+
+declare const parseAgent: (source: string, fallbackName: string) => Agent;
+
+declare const loadAgents: (dir: string) => Promise<Agent[]>;
+
+type AgentSessionEvent = {
+    type: 'turn_start';
+    input: Message;
+} | LoopEvent | {
+    type: 'turn_end';
+} | {
+    type: 'error';
+    error: unknown;
+};
+/** The request the provider sees for a turn, assembled from the live session. */
+interface AssembledRequest {
+    /** Final system prompt: base system + prepareRequest hook injections + tool prompt blocks. */
+    system: string;
+    /** Final tool set (after prepareRequest hooks — may differ from session.tools, e.g. per-agent filtering). */
+    tools: readonly Tool[];
+    /** Final message list (system message + body + any hook-injected messages). */
+    messages: readonly Message[];
+}
+interface AgentSession {
+    readonly id: string;
+    readonly model?: string;
+    readonly messages: readonly Message[];
+    readonly tools: readonly Tool[];
+    /** Assemble the request from the CURRENT in-memory session — what the next turn would send. */
+    assembleRequest?(): Promise<AssembledRequest>;
+    /** Exact token count of `text` via the model's own tokenizer, when the provider supports it. */
+    countTokens?(text: string): Promise<number | undefined>;
+    /** The active model's context window in tokens, when reportable. */
+    contextWindow?(): Promise<number | undefined>;
+    /** Summarize older messages (keeping the system + last N) to free context. */
+    compact?(opts?: {
+        keepLastTurns?: number;
+    }): Promise<void>;
+    send(input: string | ContentPart[]): Promise<void>;
+    abort(): void;
+    subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+}
+
+interface PreparedRequest {
+    system?: string;
+    tools?: Tool[];
+    messages?: Message[];
+}
+/** Context handed to `afterTurn` — inspect usage and trigger compaction without owning the message array. */
+interface AfterTurnContext {
+    messages: readonly Message[];
+    countTokens(text: string): Promise<number | undefined>;
+    contextWindow(): Promise<number | undefined>;
+    /** Summarize older messages (keeping the system + last N), replacing them in place. */
+    compact(opts?: {
+        keepLastTurns?: number;
+    }): Promise<void>;
+}
+interface AgentSessionHooks {
+    sessionStart?(): void | Promise<void>;
+    prepareRequest?(req: {
+        system: string;
+        tools: Tool[];
+    }): PreparedRequest | void | Promise<PreparedRequest | void>;
+    beforeToolCall?(call: {
+        name: string;
+        input: unknown;
+    }): void | ContentPart[] | Promise<void | ContentPart[]>;
+    afterToolCall?(call: {
+        name: string;
+        result: ContentPart[];
+    }): void | ContentPart[] | Promise<void | ContentPart[]>;
+    /** Fires after a turn completes (not on abort) — used for auto-compaction and memory writes. */
+    afterTurn?(ctx: AfterTurnContext): void | Promise<void>;
+}
+
+declare const withHooks: (tool: Tool, hooks: AgentSessionHooks) => Tool;
+
+declare const mergeHooks: (list: (AgentSessionHooks | undefined)[]) => AgentSessionHooks;
+
+interface Skill {
+    name: string;
+    description: string;
+    prompt: string;
+    dir?: string;
+    platforms?: string[];
+    command?: string;
+}
+
+interface SkillRegistry {
+    list(): Skill[];
+    get(name: string): Skill | undefined;
+    add(skill: Skill): void;
+    replaceAll(skills: Skill[]): void;
+    select(names: string[]): SkillRegistry;
+}
+declare const createSkillRegistry: (skills?: Skill[]) => SkillRegistry;
+
+declare const parseSkill: (source: string, fallbackName: string, dir?: string) => Skill;
+
+declare const loadSkills: (dir: string, current?: string) => Promise<Skill[]>;
+
+declare const skillMatchesPlatform: (platforms: string[] | undefined, current?: string) => boolean;
+
+declare const createSkillTool: (registry: SkillRegistry) => Tool;
+
+interface SubAgentResult {
+    agent: string;
+    text: string;
+}
+interface SubAgentRun {
+    runId: string;
+    agent: string;
+    parentId?: string;
+    session: AgentSession;
+}
+interface SubAgentRegistry {
+    register(run: SubAgentRun): void;
+    get(runId: string): SubAgentRun | undefined;
+    list(): SubAgentRun[];
+    byParent(parentId: string): SubAgentRun[];
+    subscribe(listener: (run: SubAgentRun) => void): () => void;
+}
+
+declare const createSubAgentRegistry: () => SubAgentRegistry;
+
+interface RunSubAgentDeps {
+    spawn(agent: Agent): AgentSession;
+    runs?: SubAgentRegistry;
+    parentId?: string;
+    runId?: string;
+    signal?: AbortSignal;
+}
+declare const runSubAgent: (agent: Agent, task: string, deps: RunSubAgentDeps) => Promise<SubAgentResult>;
+
+declare const createSubAgentTool: (deps: {
+    registry: AgentRegistry;
+} & RunSubAgentDeps) => Tool;
+
+interface RunSkillDeps extends RunSubAgentDeps {
+    skills: SkillRegistry;
+    agents?: AgentRegistry;
+}
+declare const runSkill: (deps: RunSkillDeps, args: {
+    skill: string;
+    task: string;
+    agent: string;
+}) => Promise<string>;
+declare const createRunSkillTool: (deps: RunSkillDeps) => Tool;
+
+interface Plugin {
+    name: string;
+    tools?: Tool[];
+    hooks?: AgentSessionHooks;
+    agents?: Agent[];
+    skills?: Skill[];
+}
+
+declare const definePlugin: (plugin: Plugin) => Plugin;
+
+interface Resolved {
+    tools: Tool[];
+    hooks: AgentSessionHooks;
+}
+interface ResolveInput {
+    tools?: Tool[];
+    hooks?: AgentSessionHooks;
+    plugins?: Plugin[];
+}
+declare const resolve: (config: ResolveInput) => Resolved;
+
+interface PluginStore {
+    write(name: string, content: string): Promise<string>;
+    list(): Promise<string[]>;
+    remove(name: string): Promise<void>;
+}
+declare const createPluginStore: ({ dir }: {
+    dir: string;
+}) => PluginStore;
+
+declare const importModule: (spec: string) => Promise<Record<string, unknown>>;
+
+interface AgentSessionConfig {
+    provider: Provider;
+    model: string;
+    tools?: Tool[];
+    hooks?: AgentSessionHooks;
+    plugins?: Plugin[];
+    system?: string;
+    id?: string;
+    messages?: Message[];
+}
+declare const createAgentSession: (config: AgentSessionConfig) => AgentSession;
+
+interface StoredSession {
+    id: string;
+    messages: Message[];
+}
+interface SessionStore {
+    load(id: string): Promise<StoredSession>;
+    append(id: string, messages: Message[]): Promise<void>;
+    rewrite(id: string, messages: readonly Message[]): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+declare const createSessionStore: ({ dir }: {
+    dir: string;
+}) => SessionStore;
+
+interface SessionRecord {
+    id: string;
+    title?: string;
+    cwd?: string;
+    parentId?: string;
+    createdAt: number;
+}
+interface SessionCatalog {
+    record(id: string, info: {
+        cwd?: string;
+        parentId?: string;
+    }): void;
+    setTitle(id: string, title: string): void;
+    get(id: string): SessionRecord | undefined;
+    list(filter?: {
+        cwd?: string;
+        parentId?: string;
+    }): SessionRecord[];
+    delete(id: string): void;
+    close(): void;
+}
+declare const createSessionCatalog: ({ file }: {
+    file: string;
+}) => SessionCatalog;
+
+declare const persistTo: (store: SessionStore, session: AgentSession, persisted?: number) => AgentSession;
+
+interface ReviveInput {
+    id: string;
+    model?: string;
+    messages?: Message[];
+}
+interface SessionManagerOptions {
+    store: SessionStore;
+    catalog: SessionCatalog;
+    revive(input: ReviveInput): AgentSession;
+    newId(): string;
+    cwd?: string;
+    title?(input: {
+        id: string;
+        text: string;
+    }): void;
+}
+interface SessionManager {
+    create(options?: {
+        id?: string;
+        model?: string;
+        cwd?: string;
+    }): AgentSession;
+    open(id: string): Promise<AgentSession>;
+    fork(id: string, upToIndex: number): Promise<AgentSession>;
+    list(filter?: {
+        cwd?: string;
+        parentId?: string;
+    }): Promise<SessionRecord[]>;
+    get(id: string): Promise<SessionRecord | undefined>;
+    read(id: string): Promise<StoredSession | undefined>;
+    rename(id: string, title: string): void;
+    delete(id: string): Promise<void>;
+}
+declare const createSessionManager: ({ store, catalog, revive, newId, cwd, title }: SessionManagerOptions) => SessionManager;
+
+declare const titleFallback: (text: string, max?: number) => string;
+declare const cleanTitle: (raw: string, max?: number) => string;
+interface RunTitlerOptions {
+    id: string;
+    text: string;
+    setTitle(id: string, title: string): void | Promise<void>;
+    generate(text: string): Promise<string>;
+}
+declare const runTitler: (options: RunTitlerOptions) => Promise<void>;
+
+type ChannelEvent = AgentSessionEvent | {
+    type: 'channel_open';
+    title: string;
+} | {
+    type: 'channel_close';
+};
+type ChannelManagerEvent = {
+    channelId: string;
+} & ChannelEvent;
+interface Channel {
+    readonly id: string;
+    readonly title: string;
+    readonly started: boolean;
+    readonly messages: readonly Message[];
+    /** The live AgentSession, once started — exposes `lastRequest` for inspection commands. */
+    readonly session?: AgentSession;
+    send(input: string | ContentPart[]): Promise<void>;
+    abort(): void;
+    subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+}
+interface ChannelManager {
+    open(opts?: {
+        id?: string;
+        title?: string;
+    }): Channel;
+    get(id: string): Channel | undefined;
+    list(): Channel[];
+    close(id: string): void;
+    subscribe(listener: (event: ChannelManagerEvent) => void): () => void;
+}
+
+declare const createChannel: (config: {
+    id: string;
+    title: string;
+    createSession: (id: string) => AgentSession | Promise<AgentSession>;
+}) => Channel;
+
+declare const createChannelManager: (config: {
+    createSession: (id: string) => AgentSession | Promise<AgentSession>;
+    idGen?: () => string;
+}) => ChannelManager;
+
+declare const filterTools: (pool: Tool[], allow: string[] | undefined) => Tool[];
+declare const allowList: (names: string[] | undefined) => AgentSessionHooks;
+
+interface ApprovalCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+interface RequireApprovalOptions {
+    needsApproval(call: {
+        name: string;
+        input: unknown;
+    }): boolean;
+    prompt(call: ApprovalCall): boolean | Promise<boolean>;
+    onDeny?(call: ApprovalCall): ContentPart[];
+    newId?(): string;
+}
+declare const requireApproval: (options: RequireApprovalOptions) => AgentSessionHooks;
+
+type ApprovalAction = 'approve' | 'approve_always' | 'deny';
+type ApprovalDecision = 'allow' | 'ask' | 'deny';
+interface PendingApproval {
+    id: string;
+    name: string;
+    input: unknown;
+    agent?: string;
+}
+interface ApprovalManager {
+    hooks: AgentSessionHooks;
+    hooksFor(opts: {
+        decide(call: {
+            name: string;
+            input: unknown;
+        }): ApprovalDecision;
+        agent?(): string | undefined;
+    }): AgentSessionHooks;
+    pending(): PendingApproval[];
+    resolve(id: string, action: ApprovalAction): boolean;
+    subscribe(listener: (req: PendingApproval) => void): () => void;
+}
+interface ApprovalManagerOptions {
+    needsApproval?: (call: {
+        name: string;
+        input: unknown;
+    }) => boolean;
+    askTools?: string[];
+    newId?: () => string;
+}
+declare const createApprovalManager: (options?: ApprovalManagerOptions) => ApprovalManager;
+
+declare const matchesAnyGlob: (value: string, patterns: string[]) => boolean;
+
+interface CommandResult {
+    ok: boolean;
+    output?: unknown;
+    error?: string;
+}
+interface CommandContext {
+    sessionId?: string;
+    /** The live session for this invocation — lets a command inspect what the model actually saw. */
+    session?: AgentSession;
+}
+interface Command {
+    name: string;
+    description: string;
+    aliases?: string[];
+    run: (args: string, ctx: CommandContext) => CommandResult | Promise<CommandResult>;
+}
+interface CommandRegistry {
+    register(command: Command, options?: {
+        override?: boolean;
+    }): void;
+    unregister(name: string): void;
+    list(): Command[];
+    get(name: string): Command | undefined;
+    run(input: string, ctx?: CommandContext): Promise<CommandResult>;
+}
+
+declare const createAgentsCommand: (agents: AgentRegistry) => Command;
+declare const createSkillsCommand: (skills: SkillRegistry) => Command;
+declare const createSessionsCommand: (sessions: SessionManager, options?: {
+    cwd?: string;
+}) => Command;
+declare const createQuitCommand: (onQuit: () => void | Promise<void>) => Command;
+/**
+ * Universal `/context` — the live session's context broken down into all categories
+ * (system / context / instructions / memory / tools / you / agent / tool-output), each
+ * counted with the model's own tokenizer, plus the context-window fill % and a colour
+ * heatmap. Works on every channel.
+ */
+declare const createContextCommand: () => Command;
+/** Universal `/compact` — manually summarize older messages to free context now. */
+declare const createCompactCommand: () => Command;
+declare const createHelpCommand: (list: () => Command[]) => Command;
+
+declare const createCommandRegistry: (commands?: Command[]) => CommandRegistry;
+
+type SkillCommandDeps = RunSkillDeps & {
+    activeAgent?: () => Agent | undefined;
+};
+declare const createSkillCommand: (skill: Skill, deps: SkillCommandDeps) => Command;
+
+interface XdgDirs {
+    configHome: string;
+    dataHome: string;
+    stateHome: string;
+}
+interface HarnessConfigOptions {
+    hostName: string;
+    xdg: XdgDirs;
+}
+interface HarnessConfig {
+    hostName: string;
+    configDir: string;
+    dataDir: string;
+    stateDir: string;
+}
+
+declare const createHarnessConfig: (options: HarnessConfigOptions) => HarnessConfig;
+
+type Schedule = {
+    kind: 'cron';
+    expr: string;
+    timezone?: string;
+} | {
+    kind: 'interval';
+    ms: number;
+} | {
+    kind: 'once';
+    at?: number;
+};
+interface TaskResult {
+    ok: boolean;
+    output?: string;
+    error?: string;
+}
+interface Task {
+    id: string;
+    skill?: string;
+    prompt: string;
+    agent?: string;
+    schedule: Schedule;
+    enabled: boolean;
+    createdAt: number;
+    lastRun?: number;
+    lastResult?: TaskResult;
+}
+type SchedulerEvent = {
+    type: 'task_started';
+    task: Task;
+    at: number;
+} | {
+    type: 'task_completed';
+    task: Task;
+    at: number;
+    durationMs: number;
+    result: TaskResult;
+} | {
+    type: 'task_failed';
+    task: Task;
+    at: number;
+    durationMs: number;
+    error: string;
+};
+type TaskInput = Omit<Task, 'id' | 'enabled' | 'createdAt' | 'lastRun' | 'lastResult'> & {
+    enabled?: boolean;
+};
+type TaskRunner = (task: Task) => Promise<TaskResult>;
+interface TaskStore {
+    list(): Promise<Task[]>;
+    get(id: string): Promise<Task | undefined>;
+    create(input: TaskInput): Promise<Task>;
+    update(id: string, patch: Partial<Task>): Promise<Task | undefined>;
+    remove(id: string): Promise<void>;
+}
+
+declare const createTaskStore: (options: {
+    dir: string;
+}) => TaskStore;
+
+declare const createMemoryTaskStore: (initial?: Task[]) => TaskStore;
+
+interface Scheduler {
+    start(): Promise<void>;
+    stop(): void;
+    reload(): Promise<void>;
+    runNow(id: string): Promise<void>;
+}
+declare const createScheduler: (deps: {
+    store: TaskStore;
+    run: TaskRunner;
+    onEvent?: (event: SchedulerEvent) => void;
+    onError?: (error: unknown, task: Task) => void;
+}) => Scheduler;
+
+declare const createScheduleTaskTool: (deps: {
+    store: TaskStore;
+    skills: SkillRegistry;
+    onChange?: () => void | Promise<void>;
+}) => Tool;
+
+declare const createTasksCommand: (tasks: TaskStore) => Command;
+
+interface CompactionOptions {
+    /** Compact once estimated usage exceeds this fraction of the context window. Default 0.8. */
+    thresholdPct?: number;
+    /** Number of most-recent messages kept verbatim through a compaction. Default 6. */
+    keepLastTurns?: number;
+}
+/**
+ * An `afterTurn` hook that auto-compacts the conversation as it approaches the context
+ * window: when the estimated token usage crosses `thresholdPct`, older messages are
+ * summarized (keeping the system message + the last `keepLastTurns`). The gap between the
+ * threshold and the window is the reserved compaction buffer.
+ */
+declare function createCompactionHook(opts?: CompactionOptions): AgentSessionHooks;
+
+interface ModelRegistryOptions {
+    providers: Record<string, Provider>;
+    default: string;
+}
+interface ResolvedModel {
+    provider: Provider;
+    model: string;
+}
+interface ModelRegistry {
+    readonly selected: string;
+    readonly providers: string[];
+    select(ref: string): void;
+    resolve(ref?: string): ResolvedModel;
+    /** Probe a model's input modalities via its provider (may load the model). Undefined if unsupported. */
+    capabilities(ref?: string): Promise<ModelModalities | undefined>;
+}
+declare const createModelRegistry: (options: ModelRegistryOptions) => ModelRegistry;
+
+declare const VOICE_UNAVAILABLE = "voiceModel not configured and the current model doesn't support sound";
+interface VoiceOptions {
+    model?: string;
+}
+interface VoiceTranscriber {
+    transcribe(data: Uint8Array, mime: string): Promise<string>;
+    unavailableReason(): Promise<string | undefined>;
+}
+declare const createVoice: (models: ModelRegistry, options?: VoiceOptions) => VoiceTranscriber;
+
+type HarnessOptions = HarnessConfigOptions & Omit<AgentSessionConfig, 'provider' | 'model' | 'id' | 'messages'> & {
+    providers: Record<string, Provider>;
+    model: string;
+    agents?: Agent[];
+    defaultAgents?: Agent[];
+    skills?: Skill[];
+    agentDirs?: {
+        local?: string;
+        config?: string;
+    };
+    title?: boolean;
+    titleModel?: string;
+    cwd?: string;
+    sourceUrl?: string;
+    scheduler?: boolean;
+    /** Speech-to-text for `/voice`. `model` is sent recorded audio; falls back to the selected model when unset. */
+    voice?: {
+        model?: string;
+    };
+    /** Auto-compaction settings, or `false` to disable. Default: enabled at 80% of the window. */
+    compaction?: CompactionOptions | false;
+    approvals?: {
+        manager: ApprovalManager;
+        activeAgent: () => Agent | undefined;
+        decide?: (agent: Agent, call: {
+            name: string;
+            input: unknown;
+        }) => ToolDecision;
+    };
+};
+interface Harness {
+    readonly config: HarnessConfig;
+    readonly models: ModelRegistry;
+    readonly voice: VoiceTranscriber;
+    readonly plugins: PluginStore;
+    readonly sessions: SessionManager;
+    readonly agents: AgentRegistry;
+    readonly skills: SkillRegistry;
+    readonly subAgents: SubAgentRegistry;
+    dispatchSubAgent(agent: string, task: string, parentId: string): Promise<SubAgentResult>;
+    reloadDefinitions(): Promise<void>;
+    readonly commands: CommandRegistry;
+    readonly scheduler?: Scheduler;
+    readonly tasks?: TaskStore;
+    readonly cwd: string;
+    close(): void;
+}
+
+interface ChannelAdapterContext {
+    readonly harness: Harness;
+    readonly manager: ChannelManager;
+    readonly approvals: ApprovalManager;
+}
+interface ChannelAdapterHandle {
+    stop(): Promise<void>;
+}
+interface ChannelAdapter {
+    readonly name: string;
+    start(ctx: ChannelAdapterContext): Promise<ChannelAdapterHandle>;
+}
+interface RunChannelsOptions {
+    harness: Harness;
+    approvals: ApprovalManager;
+    adapters: ChannelAdapter[];
+    idGen?: () => string;
+}
+interface ChannelHost {
+    readonly manager: ChannelManager;
+    stop(): Promise<void>;
+}
+declare function runChannels(opts: RunChannelsOptions): Promise<ChannelHost>;
+
+type WireRole = 'user' | 'assistant' | 'system' | 'tool';
+/** A non-text content part carried over the wire as base64. */
+interface WireAttachment {
+    kind: 'image' | 'audio';
+    mime: string;
+    data: string;
+}
+declare const partsToAttachments: (parts: readonly ContentPart[]) => WireAttachment[];
+declare const attachmentsToParts: (attachments: readonly WireAttachment[]) => ContentPart[];
+interface WireToolCall {
+    id: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface WireToolResultInfo {
+    name: string;
+    content: string;
+    error?: boolean;
+}
+interface WireMessageMeta {
+    source?: string;
+    visibility?: 'ui' | 'llm' | 'both';
+    transient?: boolean;
+}
+interface WireMessage {
+    id: string;
+    ts: number;
+    role: WireRole;
+    content: string;
+    reasoning?: string;
+    channelId?: string;
+    toolCalls?: WireToolCall[];
+    toolCallId?: string;
+    toolResult?: WireToolResultInfo;
+    attachments?: WireAttachment[];
+    meta?: WireMessageMeta;
+}
+declare function messagesToWire(messages: readonly Message[], baseTs?: number): WireMessage[];
+
+interface SessionSummaryWire {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    messageCount: number;
+}
+interface PersistedSessionWire {
+    version?: 1;
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    messages: WireMessage[];
+}
+interface SessionService {
+    agents(): Agent[];
+    create(id: string, title?: string): Promise<void>;
+    list(): Promise<SessionSummaryWire[]>;
+    history(id: string): Promise<PersistedSessionWire | null>;
+    rawMessages(id: string): Promise<Message[]>;
+    fork(id: string, upToIndex: number): Promise<{
+        id: string;
+        messages: Message[];
+    }>;
+    delete(id: string): Promise<void>;
+    rename(id: string, title: string): void;
+    readonly subAgents: SubAgentRegistry;
+}
+declare function createSessionService(harness: Harness, manager: ChannelManager): SessionService;
+
+interface WireModel {
+    id: string;
+    ownedBy?: string;
+}
+type WsInbound = {
+    type: 'chat';
+    sessionId?: string;
+    text: string;
+    attachments?: WireAttachment[];
+} | {
+    type: 'command';
+    sessionId?: string;
+    text: string;
+} | {
+    type: 'commands';
+} | {
+    type: 'agents';
+} | {
+    type: 'approval_response';
+    requestId: string;
+    action: ApprovalAction;
+} | {
+    type: 'set_active_agent';
+    agentId: string;
+    sessionId?: string;
+} | {
+    type: 'abort';
+    sessionId: string;
+} | {
+    type: 'models:list';
+} | {
+    type: 'models:select';
+    ref: string;
+} | {
+    type: 'subagent:dispatch';
+    requestId: string;
+    agent: string;
+    task: string;
+    parentId: string;
+} | {
+    type: 'sessions:list';
+} | {
+    type: 'sessions:create';
+    sessionId?: string;
+    title?: string;
+} | {
+    type: 'sessions:delete';
+    sessionId: string;
+} | {
+    type: 'sessions:rename';
+    sessionId: string;
+    title: string;
+} | {
+    type: 'sessions:fork';
+    requestId: string;
+    sessionId: string;
+    upToIndex: number;
+} | {
+    type: 'sessions:get';
+    sessionId: string;
+} | {
+    type: 'voice:check';
+    requestId: string;
+} | {
+    type: 'voice:transcribe';
+    requestId: string;
+    mime: string;
+    data: string;
+};
+declare function parseInbound(raw: unknown): WsInbound | {
+    error: string;
+};
+interface WireAgent {
+    name: string;
+    description: string;
+    color?: string;
+}
+interface WireCommand {
+    command: string;
+    description: string;
+}
+type WireSessionChangeKind = 'created' | 'updated' | 'deleted' | 'renamed';
+interface WireRule {
+    tool: string;
+    argsPattern?: string;
+    decision: 'allow' | 'deny' | 'ask';
+}
+interface WireApprovalRequest {
+    type: 'approval_request';
+    requestId: string;
+    sessionId: string | null;
+    toolName: string;
+    args: string;
+    matchedRule: WireRule | undefined;
+}
+interface SubAgentToolCallDetail {
+    name?: string;
+    arguments?: string;
+}
+interface SubAgentToolResultDetail {
+    name?: string;
+    content?: string;
+    error?: boolean;
+}
+type SubAgentEventWire = {
+    runId: string;
+    parentSessionId: string;
+    agentName: string;
+    type: 'started';
+    detail?: {
+        task?: string;
+    };
+} | {
+    runId: string;
+    parentSessionId: string;
+    agentName: string;
+    type: 'content';
+    detail?: string;
+} | {
+    runId: string;
+    parentSessionId: string;
+    agentName: string;
+    type: 'tool_call';
+    detail?: SubAgentToolCallDetail;
+} | {
+    runId: string;
+    parentSessionId: string;
+    agentName: string;
+    type: 'tool_result';
+    detail?: SubAgentToolResultDetail;
+} | {
+    runId: string;
+    parentSessionId: string;
+    agentName: string;
+    type: 'completed';
+    detail?: {
+        content?: string;
+    };
+} | {
+    runId: string;
+    parentSessionId: string;
+    agentName: string;
+    type: 'error';
+    detail?: string;
+};
+interface WireSchedulerTask {
+    id: string;
+    cron: string;
+    prompt: string;
+    timezone?: string;
+    channel?: string;
+}
+type WireSchedulerEvent = {
+    type: 'task_started';
+    task: WireSchedulerTask;
+    at: number;
+} | {
+    type: 'task_completed';
+    task: WireSchedulerTask;
+    at: number;
+    durationMs: number;
+} | {
+    type: 'task_failed';
+    task: WireSchedulerTask;
+    at: number;
+    error: string;
+};
+type WsOutbound = {
+    type: 'commands';
+    commands: WireCommand[];
+} | {
+    type: 'capabilities';
+    vision: boolean;
+    audio: boolean;
+} | {
+    type: 'model_loading';
+    model: string;
+    loading: boolean;
+} | {
+    type: 'agents';
+    agents: WireAgent[];
+    activeAgentId?: string | null;
+} | {
+    type: 'active_agent';
+    agentId: string | null;
+    sessionId?: string;
+    reason?: string;
+} | {
+    type: 'stream';
+    sessionId: string;
+    text: string;
+} | {
+    type: 'reasoning';
+    sessionId: string;
+    text: string;
+} | {
+    type: 'turn_start';
+    sessionId: string;
+} | {
+    type: 'turn_end';
+    sessionId: string;
+    reason?: 'complete' | 'aborted' | 'error';
+} | {
+    type: 'usage';
+    sessionId: string;
+    usage: Usage;
+} | {
+    type: 'message';
+    sessionId: string;
+    message: WireMessage;
+} | {
+    type: 'models:listed';
+    models: WireModel[];
+    selected: string;
+} | {
+    type: 'subagent:result';
+    requestId: string;
+    agent: string;
+    text: string;
+} | {
+    type: 'subagent:error';
+    requestId: string;
+    message: string;
+} | {
+    type: 'voice:availability';
+    requestId: string;
+    reason?: string;
+} | {
+    type: 'voice:result';
+    requestId: string;
+    text: string;
+} | {
+    type: 'voice:error';
+    requestId: string;
+    message: string;
+} | {
+    type: 'sessions:listed';
+    sessions: SessionSummaryWire[];
+} | {
+    type: 'sessions:changed';
+    sessionId: string;
+    kind: WireSessionChangeKind;
+} | {
+    type: 'sessions:history';
+    sessionId: string;
+    session: PersistedSessionWire | null;
+} | {
+    type: 'sessions:raw';
+    sessionId: string;
+    messages: Message[];
+} | {
+    type: 'sessions:forked';
+    requestId: string;
+    sessionId: string;
+    messages: Message[];
+} | WireApprovalRequest | {
+    type: 'scheduler_event';
+    event: WireSchedulerEvent;
+} | {
+    type: 'sub_agent_event';
+    event: SubAgentEventWire;
+} | {
+    type: 'error';
+    sessionId?: string;
+    message: string;
+};
+declare function approvalRequestToWire(req: PendingApproval, sessionId: string | null): WireApprovalRequest;
+
+interface WebSocketAdapterOptions {
+    port: number;
+    host?: string;
+    authToken?: string;
+    activeAgentId?: string;
+    listModels?: () => Promise<WireModel[]>;
+    /** Modalities the configured model accepts. Image/audio attachments are dropped when off. */
+    capabilities?: {
+        vision?: boolean;
+        audio?: boolean;
+    };
+    maxPayloadBytes?: number;
+    log?: (msg: string) => void;
+}
+type WebSocketAdapter = ChannelAdapter & {
+    push(frame: WsOutbound): void;
+    /** Update the advertised model capabilities and broadcast a fresh `capabilities` frame. */
+    setCapabilities(caps: {
+        vision: boolean;
+        audio: boolean;
+    }): void;
+};
+declare function webSocketAdapter(opts: WebSocketAdapterOptions): WebSocketAdapter;
+
+interface TextStyle {
+    fg?: Color;
+    bg?: Color;
+    bold?: boolean;
+    dim?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+}
+interface ThemeColors {
+    background: Color;
+    surface: Color;
+    surfaceMuted: Color;
+    border: Color;
+    text: Color;
+    textMuted: Color;
+    accent: Color;
+    success: Color;
+    warning: Color;
+    danger: Color;
+    syntaxKeyword: Color;
+    syntaxString: Color;
+    syntaxFunction: Color;
+    syntaxNumber: Color;
+    syntaxComment: Color;
+}
+interface ThemeStyles {
+    body: TextStyle;
+    muted: TextStyle;
+    title: TextStyle;
+    userMessage: TextStyle;
+    assistantMessage: TextStyle;
+    reasoning: TextStyle;
+    commandPaletteItem: TextStyle;
+    commandPaletteHover: TextStyle;
+    commandPaletteSelected: TextStyle;
+    bashPrompt: TextStyle;
+    errorLine: TextStyle;
+    errorPrefix: TextStyle;
+}
+interface Theme {
+    name: string;
+    colors: ThemeColors;
+    styles: ThemeStyles;
+}
+declare const palette: {
+    readonly neutral: {
+        readonly 0: Color;
+        readonly 50: Color;
+        readonly 100: Color;
+        readonly 200: Color;
+        readonly 300: Color;
+        readonly 400: Color;
+        readonly 500: Color;
+        readonly 600: Color;
+        readonly 700: Color;
+        readonly 800: Color;
+        readonly 900: Color;
+        readonly 925: Color;
+        readonly 950: Color;
+    };
+    readonly blue: {
+        readonly 300: Color;
+        readonly 400: Color;
+        readonly 600: Color;
+    };
+    readonly red: {
+        readonly 400: Color;
+        readonly 600: Color;
+    };
+    readonly green: {
+        readonly 400: Color;
+        readonly 600: Color;
+        readonly 800: Color;
+    };
+    readonly yellow: {
+        readonly 300: Color;
+        readonly 400: Color;
+        readonly 500: Color;
+    };
+};
+declare const darkTheme: Theme;
+declare const lightTheme: Theme;
+declare const themesByName: Record<string, Theme>;
+declare function fgToAnsi(color: Color): string;
+declare function bgToAnsi(color: Color): string;
+declare function styleToAnsi(style: TextStyle): string;
+declare function asHexColor(value: string | undefined): `#${string}` | undefined;
+type ThemeSubscriber = (theme: Theme) => void;
+declare class ThemeProvider {
+    private theme;
+    private readonly subscribers;
+    constructor(initial: Theme);
+    current(): Theme;
+    setTheme(next: Theme): void;
+    subscribe(fn: ThemeSubscriber): () => void;
+}
+
+interface MarkdownLine {
+    text: string;
+    bleed: boolean;
+}
+declare function renderMarkdown(content: string, width: number, theme: Theme, bleed?: number): MarkdownLine[];
+declare function markdown(content: string, theme: Theme): Component;
+
+interface MultilineEditorOptions {
+    placeholder?: string;
+    maxRows?: number;
+    onSubmit?: (value: string) => void;
+    onChange?: (value: string) => void;
+}
+interface ChipRange {
+    start: number;
+    end: number;
+}
+declare class MultilineEditor implements Component {
+    private value;
+    private cursor;
+    private readonly placeholder;
+    private readonly maxRows;
+    hiddenPrefix: string;
+    chipColor?: () => string;
+    mentionRanges?: (value: string, cursor: number) => ChipRange[];
+    onPaste?: (text: string) => string | undefined;
+    onSubmit?: (value: string) => void;
+    onChange?: (value: string) => void;
+    constructor(opts?: MultilineEditorOptions);
+    getValue(): string;
+    setValue(value: string): void;
+    get cursorPos(): number;
+    setCursor(n: number): void;
+    rows(): number;
+    handleInput(event: InputEvent): void;
+    private handleKey;
+    private lineStart;
+    private lineEnd;
+    private insert;
+    private chips;
+    private moveLeft;
+    private moveRight;
+    private backspace;
+    private deleteForward;
+    private cursorRowCol;
+    render(s: Surface): void;
+    private renderRow;
+}
+
+interface Candidate {
+    label: string;
+    insert: string;
+    kind: 'file' | 'dir' | 'agent';
+}
+declare function collectCandidates(cwd: string, agentNames: string[]): Candidate[];
+declare function rank(query: string, candidates: Candidate[], limit?: number): Candidate[];
+interface MentionRange {
+    start: number;
+    end: number;
+}
+declare function mentionRanges(value: string, excludeStart?: number): MentionRange[];
+interface ActiveMention {
+    start: number;
+    query: string;
+}
+declare function activeMention(value: string, cursor: number): ActiveMention | undefined;
+
+declare const spinnerFrame: (tick: number) => string;
+declare const formatTokens: (n: number) => string;
+interface StatusState {
+    label: string;
+    busy: boolean;
+    spinnerTick: number;
+    context: string;
+    minimal?: boolean;
+    recording?: {
+        seconds: number;
+        tick: number;
+    };
+}
+declare function statusFromEvent(event: AgentSessionEvent): string | undefined;
+declare function statusComponent(state: StatusState, theme: Theme): Component;
+
+type Entry = {
+    kind: 'user';
+    text: string;
+} | {
+    kind: 'reasoning';
+    text: string;
+    closed: boolean;
+} | {
+    kind: 'assistant';
+    text: string;
+    agent?: string;
+    agentColor?: Color;
+} | {
+    kind: 'tool_call';
+    name: string;
+    input: unknown;
+} | {
+    kind: 'shell';
+    cmd: string;
+    output: string;
+    error: boolean;
+} | {
+    kind: 'subagent';
+    agent: string;
+    status: SubAgentStatus;
+    tools: number;
+    activity: string;
+    result: string;
+    log: string[];
+    open: boolean;
+    messages?: readonly Message[];
+} | {
+    kind: 'note';
+    text: string;
+    error: boolean;
+};
+type SubAgentEntry = Extract<Entry, {
+    kind: 'subagent';
+}>;
+type SubAgentStatus = 'running' | 'done' | 'error' | 'canceled';
+interface SubAgentHandle {
+    addTool(label: string): void;
+    finish(result: string): void;
+    fail(message: string): void;
+    cancel(): void;
+}
+declare class Transcript {
+    entries: Entry[];
+    expanded: boolean;
+    thinkingVisible: boolean;
+    speaker: {
+        name: string;
+        color?: Color;
+    } | undefined;
+    private pending;
+    private pendingReasoning;
+    reset(): void;
+    private speakerTag;
+    private closeReasoning;
+    toggleExpanded(): boolean;
+    toggleReasoning(): boolean;
+    appendUser(text: string): void;
+    note(content: string, error?: boolean): void;
+    appendSubAgent(agent: string, messages?: readonly Message[]): SubAgentHandle;
+    appendShell(cmd: string): {
+        setOutput: (output: string, error?: boolean) => void;
+    };
+    seed(messages: readonly Message[]): void;
+    applyEvent(event: AgentSessionEvent): void;
+}
+declare function formatToolArgs(name: string, input: unknown, max?: number): string;
+declare const stickyHeader: (value: string, theme: Theme) => Component;
+declare function entryComponent(entry: Entry, theme: Theme, expanded: boolean): Component;
+declare function transcriptComponent(model: Transcript, theme: Theme): Component;
+
+interface RecorderSpec {
+    cmd: string;
+    args: (out: string) => string[];
+}
+declare function detectRecorder(): Promise<RecorderSpec | undefined>;
+interface VoiceRecording {
+    stop(): Promise<Uint8Array>;
+    cancel(): Promise<void>;
+    elapsed(): number;
+}
+interface StartVoiceOptions {
+    recorder: RecorderSpec;
+    now: () => number;
+}
+declare function startRecording(opts: StartVoiceOptions): Promise<VoiceRecording>;
+/** Wrap raw little-endian 16-bit mono PCM in a minimal WAV container. */
+declare function pcmToWav(pcm: Uint8Array, sampleRate?: number): Uint8Array;
+interface StreamingRecorderSpec {
+    cmd: string;
+    args: string[];
+}
+declare function detectStreamingRecorder(): Promise<StreamingRecorderSpec | undefined>;
+interface StreamingRecording {
+    stop(): Promise<void>;
+}
+/**
+ * Spawn a recorder streaming raw s16le mono PCM to stdout; each stdout chunk is
+ * delivered to `onChunk`. Spawn failures (binary vanished after detection, EACCES…)
+ * arrive asynchronously via the child's 'error' event: without a listener Node
+ * re-throws them as an uncaught exception that tears down the whole TUI, so we
+ * always attach one and forward it to `onError` for graceful degradation.
+ */
+declare function startStreamingRecording(recorder: StreamingRecorderSpec, onChunk: (pcm: Uint8Array) => void, onError?: (err: Error) => void): StreamingRecording;
+interface RealtimeDictationOptions {
+    transcribe: (wav: Uint8Array) => Promise<string>;
+    onPartial: (text: string) => void;
+    /** New PCM bytes that trigger another transcription pass. Default ~1.5s @ 16k mono s16le. */
+    passEveryBytes?: number;
+}
+interface RealtimeDictation {
+    push(pcm: Uint8Array): void;
+    /** Stop, run a final correction pass over all audio, return the full transcript. */
+    finish(): Promise<string>;
+    cancel(): void;
+}
+/**
+ * Client-driven incremental dictation: accumulates PCM and re-transcribes the whole
+ * buffer every `passEveryBytes`, serialized so a slow model simply yields fewer passes.
+ * Each partial re-derives the tail, so the latest words self-correct as more audio arrives;
+ * `finish()` runs one last full pass.
+ */
+declare function createRealtimeDictation(opts: RealtimeDictationOptions): RealtimeDictation;
+
+interface ModelInfo {
+    id: string;
+    ownedBy?: string;
+}
+interface ChatFeatures {
+    approvals?: boolean;
+    subAgents?: boolean;
+    sessionPicker?: boolean;
+    modelPicker?: boolean;
+    /** The active model accepts image input. Default off — must be opted in. */
+    vision?: boolean;
+    /** The active model accepts audio input. Default off — must be opted in. */
+    audio?: boolean;
+}
+interface ChatHost {
+    session?: AgentSession;
+    approvals: ApprovalManager;
+    cwd: string;
+    createSession(): AgentSession;
+    forkSession(id: string, upToIndex: number): Promise<AgentSession>;
+    listSessions(): Promise<SessionRecord[]>;
+    openSession(id: string): Promise<AgentSession>;
+    selectModel(ref: string): void;
+    modelRef(): string;
+    listModels(): Promise<ModelInfo[]>;
+    agentRef(): string;
+    agentColor(): string | undefined;
+    cycleAgent(): string;
+    agentNames(): string[];
+    subAgents: SubAgentRegistry;
+    dispatchSubAgent(agent: string, task: string, parentId: string): Promise<SubAgentResult>;
+    initialTheme: string;
+    saveTheme(name: string): void;
+    initialThinking: boolean;
+    saveThinking(visible: boolean): void;
+    history?: {
+        load(): string[];
+        append(text: string): void;
+    };
+    features?: ChatFeatures;
+    voice?: {
+        transcribe(audio: Uint8Array, mime: string): Promise<string>;
+        unavailableReason?(): Promise<string | undefined>;
+    };
+    /** Subscribe to model load/unload state (cold-start). Optional — only WS-backed hosts emit it. */
+    subscribeModelLoading?(listener: (model: string, loading: boolean) => void): () => void;
+    banner?: string;
+    minimal?: boolean;
+    commands?(): {
+        name: string;
+        description: string;
+    }[];
+    runCommand?(input: string, ctx?: {
+        session?: AgentSession;
+    }): Promise<{
+        ok: boolean;
+        output?: unknown;
+        error?: string;
+    }>;
+    onExit(code: number): void;
+}
+declare class ChatApp {
+    private readonly host;
+    private readonly tui;
+    private readonly terminal;
+    private readonly editor;
+    private readonly scroll;
+    private readonly transcript;
+    private readonly subScroll;
+    private readonly subTranscript;
+    private readonly themeProvider;
+    private readonly commands;
+    private session;
+    private readonly features;
+    private readonly banner;
+    private readonly minimal;
+    private unsubscribe;
+    private unsubscribeTheme;
+    private unsubscribeSubAgents;
+    private unsubscribeModelLoading;
+    private modelLoading;
+    private readonly runUnsubs;
+    private readonly activeRuns;
+    private mentionAc;
+    private readonly status;
+    private running;
+    private readonly queue;
+    private readonly pendingShell;
+    private readonly pastes;
+    private pasteSeq;
+    private readonly attachments;
+    private attachSeq;
+    private models;
+    private paletteCursor;
+    private paletteDismissedFor;
+    private pickerMention;
+    private pickerRanked;
+    private pickerCursor;
+    private history;
+    private historyIndex;
+    private historyDraft;
+    private spinnerTimer;
+    private lastEsc;
+    private modelPickerOpen;
+    private modelHandle;
+    private sessionPickerOpen;
+    private sessionHandle;
+    private approvalQueue;
+    private approvalCursor;
+    private unsubscribeApproval;
+    private errorText;
+    private errorTimer;
+    private recording;
+    private recordTimer;
+    private recordStarting;
+    private callRec;
+    private callDict;
+    private callStarting;
+    private callTranscript;
+    private callStart;
+    private callTimer;
+    private stopped;
+    constructor(host: ChatHost);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private theme;
+    private commandHost;
+    private openSessionPicker;
+    private buildSessionPicker;
+    private bindSession;
+    private feature;
+    private ensureSession;
+    private clearRuns;
+    private abortRuns;
+    private onSubAgentRun;
+    private tryDispatch;
+    private dispatchMention;
+    private swapSession;
+    private onModelLoading;
+    private handleEvent;
+    private applyUsage;
+    private onTurnComplete;
+    private stripFileMentions;
+    private send;
+    private capturePaste;
+    private expandPastes;
+    private capable;
+    private pasteClipboardImage;
+    private toggleVoice;
+    private startVoice;
+    private stopRecordTimer;
+    private finishVoice;
+    private cancelVoice;
+    private callActive;
+    private toggleCall;
+    private startCall;
+    private stopCallTimer;
+    private finishCall;
+    private cancelCall;
+    private attachFromFile;
+    private addAttachment;
+    private stripAttachmentPlaceholders;
+    private clearAttachments;
+    private flushShellContext;
+    private submit;
+    private clearPastes;
+    private enqueueFromInput;
+    private onInputChange;
+    private intercept;
+    private cycleAgent;
+    private onEscape;
+    private cancelGeneration;
+    private harnessCommands;
+    private allCommands;
+    private paletteItems;
+    private paletteMove;
+    private paletteComplete;
+    private paletteRun;
+    private runCommand;
+    private pickerVisible;
+    private pickerMove;
+    private pickerAccept;
+    private pushHistory;
+    private navigateHistory;
+    private newSession;
+    private openModelPicker;
+    private buildModelPicker;
+    private moveApproval;
+    private resolveApproval;
+    private approvalView;
+    private switchModel;
+    private exportContext;
+    private toggleExpand;
+    private toggleThinking;
+    private toggleTheme;
+    private onCtrlC;
+    private recordShell;
+    private runShell;
+    private setStatus;
+    private showError;
+    private clearError;
+    private startSpinner;
+    private stopSpinner;
+    private loadModels;
+    private modelLabel;
+    private updateSpeaker;
+    private promptGlyph;
+    private inputPanel;
+    private callView;
+    private editorInner;
+    private errorView;
+    private waitingView;
+    private inputGroup;
+    private statusBar;
+    private dock;
+    private jumpToBottom;
+    private jumpToBottomHint;
+    private stickyHeaderView;
+    private governingUser;
+    private focusedSub;
+    private subAgentHeader;
+    private subAgentView;
+    private centered;
+    private bannerBlock;
+    private root;
+}
+
+interface ChatCommand {
+    name: string;
+    description: string;
+    run: (args: string) => void | Promise<void>;
+}
+interface CommandHost {
+    newSession(): void;
+    openModelPicker(): void;
+    toggleExpand(): void;
+    toggleThinking(): void;
+    exportContext(args: string): void | Promise<void>;
+    listSessions(): void;
+    voice(): void;
+    call(): void;
+    quit(): void;
+}
+
+declare const runChat: (host: ChatHost) => ChatApp;
+
+interface ConnectHarnessOptions {
+    url: string;
+    token?: string;
+    sessionId?: string;
+    cwd: string;
+    initialTheme?: string;
+    saveTheme?: (name: string) => void;
+    initialThinking?: boolean;
+    saveThinking?: (visible: boolean) => void;
+    history?: {
+        load(): string[];
+        append(text: string): void;
+    };
+    banner?: string;
+    minimal?: boolean;
+    features?: ChatFeatures;
+    onExit?: (code: number) => void;
+}
+interface RemoteHarness {
+    host: ChatHost;
+    close(): Promise<void>;
+}
+declare function connectHarness(opts: ConnectHarnessOptions): Promise<RemoteHarness>;
+
+interface WsClientOptions {
+    url: string;
+    token?: string;
+    sessionId?: string;
+}
+interface WsClient {
+    connect(): Promise<void>;
+    /** Returns false (frame dropped) when the socket is not OPEN, so callers can
+     * settle a just-registered request waiter instead of hanging forever. */
+    send(frame: WsInbound): boolean;
+    on(handler: (frame: WsOutbound) => void): () => void;
+    /** Fires once when the socket closes (after a normal close or an error), so the
+     * caller can reject any in-flight request waiters. */
+    onClose(handler: () => void): () => void;
+    close(): Promise<void>;
+}
+declare function createWsClient(opts: WsClientOptions): WsClient;
+
+interface Emitter<T> {
+    emit(event: T): void;
+    subscribe(listener: (event: T) => void): () => void;
+}
+declare const createEmitter: <T>() => Emitter<T>;
+declare const strList: (value: unknown) => string[];
+
+interface Frontmatter {
+    fields: Record<string, unknown>;
+    body: string;
+}
+declare const parseFrontmatter: (source: string) => Frontmatter;
+declare const str: (value: unknown) => string | undefined;
+
+declare const createHarness: (options: HarnessOptions) => Promise<Harness>;
+
+type MemoryScope = 'local' | 'global';
+interface MemoryStore {
+    /** Project-scoped memory file (cwd/.mu/MEMORY.md). */
+    readonly localPath: string;
+    /** Global memory file (dataDir/MEMORY.md), shared across all projects. */
+    readonly globalPath: string;
+    /** Concatenated memory (global then project), capped per scope, or undefined when empty. */
+    load(): Promise<string | undefined>;
+    /** Append a durable fact to the chosen scope's memory file. */
+    remember(fact: string, scope: MemoryScope): Promise<void>;
+}
+declare function createMemoryStore(opts: {
+    cwd: string;
+    dataDir: string;
+}): MemoryStore;
+/** A `remember` tool the agent calls to persist durable facts to local or global memory. */
+declare function createRememberTool(store: MemoryStore): Tool;
+
+/**
+ * Load project-instruction files (AGENTS.md / CLAUDE.md, opencode-style) across harness
+ * scopes: GLOBAL (configDir, every project) and LOCAL (cwd + ancestors, project-specific),
+ * plus on-demand NESTED scopes — any subdirectory the agent has touched (`accessed`) whose
+ * AGENTS.md should apply while working there. Concatenated shallow → deep so the most
+ * specific instructions land last. Returns undefined when nothing is found.
+ */
+declare function loadInstructions(cwd: string, configDir: string, opts?: {
+    files?: readonly string[];
+    accessed?: Iterable<string>;
+}): Promise<string | undefined>;
+
+export { type ActiveMention, type Agent, type AgentRegistry, type AgentSession, type AgentSessionConfig, type AgentSessionEvent, type AgentSessionHooks, type ApprovalAction, type ApprovalCall, type ApprovalDecision, type ApprovalManager, type ApprovalManagerOptions, type Candidate, type Channel, type ChannelAdapter, type ChannelAdapterContext, type ChannelAdapterHandle, type ChannelEvent, type ChannelHost, type ChannelManager, type ChannelManagerEvent, ChatApp, type ChatCommand, type ChatFeatures, type ChatHost, type Command, type CommandContext, type CommandHost, type CommandRegistry, type CommandResult, type CompactionOptions, type ConnectHarnessOptions, type Emitter, type Entry, type Frontmatter, type GrantValue, type Harness, type HarnessConfig, type HarnessConfigOptions, type HarnessOptions, type MarkdownLine, type MemoryScope, type MemoryStore, type MentionRange, type ModelInfo, type ModelRegistry, type ModelRegistryOptions, MultilineEditor, type MultilineEditorOptions, type PendingApproval, type PersistedSessionWire, type Plugin, type PluginStore, type PreparedRequest, type RealtimeDictation, type RealtimeDictationOptions, type RecorderSpec, type RemoteHarness, type RequireApprovalOptions, type ResolveInput, type Resolved, type ResolvedModel, type ReviveInput, type RunChannelsOptions, type RunSkillDeps, type RunSubAgentDeps, type RunTitlerOptions, type Schedule, type Scheduler, type SchedulerEvent, type SessionCatalog, type SessionManager, type SessionManagerOptions, type SessionRecord, type SessionService, type SessionStore, type SessionSummaryWire, type Skill, type SkillCommandDeps, type SkillRegistry, type StartVoiceOptions, type StatusState, type StoredSession, type StreamingRecorderSpec, type StreamingRecording, type SubAgentEntry, type SubAgentEventWire, type SubAgentHandle, type SubAgentRegistry, type SubAgentResult, type SubAgentRun, type SubAgentStatus, type SubAgentToolCallDetail, type SubAgentToolResultDetail, type Task, type TaskInput, type TaskResult, type TaskRunner, type TaskStore, type TextStyle, type Theme, type ThemeColors, ThemeProvider, type ThemeStyles, type ThemeSubscriber, type ToolDecision, type ToolGrants, Transcript, VOICE_UNAVAILABLE, type VoiceOptions, type VoiceRecording, type VoiceTranscriber, type WebSocketAdapter, type WebSocketAdapterOptions, type WireAgent, type WireApprovalRequest, type WireAttachment, type WireCommand, type WireMessage, type WireModel, type WireRule, type WireSchedulerEvent, type WireSchedulerTask, type WireSessionChangeKind, type WsClient, type WsClientOptions, type WsInbound, type WsOutbound, type XdgDirs, activeMention, allowList, approvalRequestToWire, asHexColor, attachmentsToParts, bgToAnsi, cleanTitle, collectCandidates, connectHarness, createAgentRegistry, createAgentSession, createAgentsCommand, createApprovalManager, createChannel, createChannelManager, createCommandRegistry, createCompactCommand, createCompactionHook, createContextCommand, createEmitter, createHarness, createHarnessConfig, createHelpCommand, createMemoryStore, createMemoryTaskStore, createModelRegistry, createPluginStore, createQuitCommand, createRealtimeDictation, createRememberTool, createRunSkillTool, createScheduleTaskTool, createScheduler, createSessionCatalog, createSessionManager, createSessionService, createSessionStore, createSessionsCommand, createSkillCommand, createSkillRegistry, createSkillTool, createSkillsCommand, createSubAgentRegistry, createSubAgentTool, createTaskStore, createTasksCommand, createVoice, createWsClient, darkTheme, definePlugin, detectRecorder, detectStreamingRecorder, entryComponent, fgToAnsi, filterTools, formatTokens, formatToolArgs, grantArg, importModule, lightTheme, loadAgents, loadInstructions, loadSkills, markdown, matchesAnyGlob, mentionRanges, mergeHooks, messagesToWire, palette, parseAgent, parseFrontmatter, parseInbound, parseSkill, partsToAttachments, pcmToWav, persistTo, rank, renderMarkdown, requireApproval, resolve, runChannels, runChat, runSkill, runSubAgent, runTitler, skillMatchesPlatform, spinnerFrame, startRecording, startStreamingRecording, statusComponent, statusFromEvent, stickyHeader, str, strList, styleToAnsi, themesByName, titleFallback, toolDecision, toolNames, transcriptComponent, webSocketAdapter, withHooks };