@prismer/runtime 1.9.0-hotfix.1

package/dist/index.d.mts

@@ -0,0 +1,2063 @@
+import * as http from 'node:http';
+import { FsContext } from '@prismer/sandbox-runtime';
+import { ParaEvent } from '@prismer/wire';
+import { EventEmitter } from 'node:events';
+
+type DaemonState = 'starting' | 'running' | 'shutting_down' | 'stopped';
+interface DaemonOptions {
+    pidFile?: string;
+    dataDir?: string;
+    logFile?: string;
+    installSignalHandlers?: boolean;
+}
+interface ShutdownHandler {
+    name: string;
+    handler: () => Promise<void> | void;
+}
+declare class DaemonAlreadyRunningError extends Error {
+    readonly existingPid: number;
+    readonly pidFile: string;
+    constructor(pid: number, pidFile: string);
+}
+declare class DaemonProcess {
+    private _state;
+    private readonly _pidFile;
+    private readonly _dataDir;
+    private readonly _logFile;
+    private readonly _installSignalHandlers;
+    private readonly _shutdownHandlers;
+    private readonly _signalHistory;
+    private _shutdownInProgress;
+    private _sigTermHandler;
+    private _sigIntHandler;
+    private _sigHupHandler;
+    private _signalReceived;
+    constructor(opts?: DaemonOptions);
+    get state(): DaemonState;
+    get pid(): number;
+    get pidFile(): string;
+    get dataDir(): string;
+    get signalHistory(): ReadonlyArray<{
+        signal: string;
+        ts: number;
+    }>;
+    start(): Promise<void>;
+    onShutdown(h: ShutdownHandler): void;
+    shutdown(signal?: NodeJS.Signals | 'manual'): Promise<void>;
+    reload(): Promise<void>;
+    static isRunning(pidFile: string): boolean;
+    static cleanupStalePidFile(pidFile: string): boolean;
+    private _atomicPidWrite;
+    private _recordSignal;
+    private _readPidFromFile;
+}
+
+interface EventBusEnvelope<T = unknown> {
+    topic: string;
+    ts: number;
+    payload: T;
+    source?: string;
+    requestId?: string;
+}
+/**
+ * Unified subscription handler that accepts EventBusEnvelope.
+ * This matches the EventBus API expectation.
+ */
+type SubscriptionHandler<T = unknown> = (ev: EventBusEnvelope<T>) => void | Promise<void>;
+interface Subscription {
+    id: string;
+    pattern: string;
+    unsubscribe(): void;
+}
+interface EventBusOptions {
+    onSubscriberError?: (err: unknown, sub: Subscription, ev: EventBusEnvelope) => void;
+    queueWarnThreshold?: number;
+}
+declare class EventBus {
+    private readonly _subscribers;
+    private _monotonicTs;
+    private _totalPublished;
+    private readonly _onError;
+    private readonly _warnThreshold;
+    constructor(opts?: EventBusOptions);
+    publish<T>(topic: string, payload: T, meta?: {
+        source?: string;
+        requestId?: string;
+    }): void;
+    subscribe<T>(topic: string, handler: SubscriptionHandler<T>): Subscription;
+    unsubscribeAll(): void;
+    get subscriberCount(): number;
+    get totalPublished(): number;
+    private _drain;
+}
+
+type AgentState = 'registered' | 'spawning' | 'running' | 'degraded' | 'crashed' | 'backoff' | 'stopping' | 'stopped' | 'failed';
+interface AgentDescriptor {
+    id: string;
+    name: string;
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    healthCheck?: () => Promise<boolean> | boolean;
+    backoff?: {
+        initialMs?: number;
+        multiplier?: number;
+        maxMs?: number;
+        maxRestarts?: number;
+        resetAfterMs?: number;
+    };
+    attachPid?: number;
+}
+interface AgentStatus {
+    id: string;
+    state: AgentState;
+    pid?: number;
+    startedAt?: number;
+    restarts: number;
+    lastExitCode?: number;
+    lastSignal?: NodeJS.Signals | null;
+    lastHealthError?: string;
+    nextRestartAt?: number;
+}
+interface SupervisorOptions {
+    eventBus: EventBus;
+    healthProbeIntervalMs?: number;
+    degradedThreshold?: number;
+    stopTimeoutMs?: number;
+}
+declare class AgentSupervisor {
+    private readonly _bus;
+    private readonly _probeIntervalMs;
+    private readonly _degradedThreshold;
+    private readonly _stopTimeoutMs;
+    private readonly _agents;
+    constructor(opts: SupervisorOptions);
+    register(descriptor: AgentDescriptor): void;
+    unregister(id: string): Promise<void>;
+    spawn(id: string): Promise<void>;
+    stop(id: string, reason?: string): Promise<void>;
+    restart(id: string): Promise<void>;
+    attach(id: string, pid: number): Promise<void>;
+    get(id: string): AgentStatus | undefined;
+    list(): AgentStatus[];
+    shutdown(): Promise<void>;
+    private _doSpawn;
+    private _handleCrash;
+    private _scheduleRestart;
+    private _killOwned;
+    private _cancelBackoff;
+    private _startProbe;
+    private _stopProbe;
+    private _runProbe;
+    private _pollAttached;
+    private _require;
+    private _publish;
+}
+
+/**
+ * Prismer Runtime — Adapter Registry (Sprint A3, D4 dispatch mux).
+ *
+ * One process-wide registry maps adapter `name` → `AdapterImpl`. The
+ * registry is the data store; selection policy lives in DispatchMux
+ * (dispatch-mux.ts) so the same registry can drive multiple selectors
+ * (capability-based, name-based, weighted load, etc.) without coupling.
+ *
+ * An adapter advertises:
+ *   - `name`            : stable identifier (matches catalog name).
+ *   - `tiersSupported`  : PARA Tier numbers it can host (e.g. [1..7]).
+ *   - `capabilityTags`  : tags from the task's `requiresCapability`
+ *                         vocabulary that this adapter can satisfy.
+ *
+ * On register conflict, replace — adapter modules are expected to be
+ * the only source of truth for their own descriptor.
+ *
+ * Adapters typically run as out-of-process workers (Claude Code CLI,
+ * OpenClaw daemon plug-in, Hermes Python). The `dispatch` boundary
+ * here is the *runtime side* of that bridge — it returns a Promise
+ * whose resolution corresponds to the adapter's reported completion.
+ */
+interface AdapterDescriptor {
+    /** Stable identifier — must match the catalog entry. */
+    name: string;
+    /** PARA Tier numbers (L1–L10). */
+    tiersSupported: number[];
+    /** Capability tag vocabulary (e.g. ["code.write", "code.review"]). */
+    capabilityTags: string[];
+    /** Free-form for telemetry — version, build, etc. */
+    metadata?: Record<string, unknown>;
+}
+interface AdapterDispatchInput {
+    /** Cloud task ID (im_tasks.id). */
+    taskId: string;
+    /** Step index when the task is multi-step (route step). */
+    stepIdx?: number;
+    /** Capability the cloud asked for — drives adapter selection. */
+    capability: string;
+    /** User-facing prompt / instruction. */
+    prompt: string;
+    /** Free-form metadata passed through to the adapter. */
+    metadata?: Record<string, unknown>;
+    /** Optional deadline (ms epoch). Adapters should respect it best-effort. */
+    deadlineAt?: number;
+}
+interface AdapterDispatchResult {
+    ok: boolean;
+    /** Output text (stdout, summary, etc.). */
+    output?: string;
+    /** Files produced by the adapter (paths are relative to the agent
+     *  workspace; cloud uploads them via the artifact stream). */
+    artifacts?: Array<{
+        path: string;
+        bytes: number;
+        mime?: string;
+    }>;
+    /** Failure reason — must be set when ok=false. */
+    error?: string;
+    /** Free-form telemetry — token counts, latency, model, etc. */
+    metadata?: Record<string, unknown>;
+}
+interface AdapterImpl extends AdapterDescriptor {
+    /** Dispatch a task step to this adapter. Should not throw — errors
+     *  belong in the result. */
+    dispatch(input: AdapterDispatchInput): Promise<AdapterDispatchResult>;
+    /** Optional: per-adapter health probe. Defaults to "healthy". */
+    health?(): Promise<{
+        healthy: boolean;
+        reason?: string;
+    }>;
+    /**
+     * Reset adapter state for a specific agent (or all agents if undefined).
+     *
+     * v1.9.x remote-command `agent_restart` semantic: abort/clear whatever
+     * per-agent context the adapter holds. For stateless adapters (CLI shim),
+     * this is a no-op; for Mode B adapters, it's typically a POST /reset to
+     * the loopback so the adapter host clears its own session state.
+     *
+     * NOT a process restart — the adapter is not expected to own a PID.
+     *
+     * @param agentName  Optional agent name to scope the reset. Undefined = reset all.
+     * @returns Arbitrary result; ok:true for success, ok:false+reason otherwise.
+     */
+    reset?(agentName?: string): Promise<{
+        ok: boolean;
+        state?: string;
+        reason?: string;
+        [k: string]: unknown;
+    }>;
+}
+declare class AdapterRegistry {
+    private readonly adapters;
+    register(adapter: AdapterImpl): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    get(name: string): AdapterImpl | undefined;
+    list(): AdapterDescriptor[];
+    size(): number;
+    /**
+     * Find adapters that can satisfy the given capability tag.
+     *
+     * An adapter matches if `capabilityTags` includes the tag verbatim or
+     * if the adapter declared a wildcard prefix match (e.g. `code.*` matches
+     * `code.write`). Returns deterministic ordering — adapters are sorted by
+     * name so callers see the same result for the same registry state.
+     */
+    findByCapability(capability: string): AdapterImpl[];
+    /**
+     * Find adapters that can host a given PARA tier.
+     */
+    findByTier(tier: number): AdapterImpl[];
+}
+
+/**
+ * Prismer Runtime — Dispatch Mux (Sprint A3, D4).
+ *
+ * Picks an adapter for an incoming task and forwards the dispatch call.
+ * Selection policy (in priority order):
+ *
+ *   1. `preferAdapter` (caller-supplied) wins if registered AND the
+ *      adapter can satisfy the requested capability.
+ *   2. If exactly one adapter matches the capability, use it.
+ *   3. If multiple match, pick deterministically — adapters sorted by
+ *      `name` (so the same task always lands on the same adapter when
+ *      multiple are eligible). Future: load/latency-aware ranking.
+ *   4. None matches → return a structured "no_adapter" failure rather
+ *      than throw — the caller (cloud) decides whether to reroute.
+ *
+ * The mux never throws on adapter errors; it always returns a result
+ * with `ok=false` so the cloud-side TaskRouter can report `step_failed`
+ * instead of seeing a daemon-side stack trace.
+ */
+
+interface DispatchMuxRequest extends AdapterDispatchInput {
+    /** If set and registered, win selection. */
+    preferAdapter?: string;
+}
+interface DispatchMuxResult extends AdapterDispatchResult {
+    /** Which adapter handled this request. Useful for telemetry +
+     *  debugging when the answer "feels wrong". */
+    adapter?: string;
+}
+declare class DispatchMux {
+    private readonly registry;
+    constructor(registry: AdapterRegistry);
+    /**
+     * Resolve the adapter that would handle a given request without
+     * actually dispatching. Returned undefined means "no adapter matches".
+     * Useful for cloud-side capability probing.
+     */
+    resolve(req: {
+        capability: string;
+        preferAdapter?: string;
+    }): {
+        adapter: string;
+    } | undefined;
+    dispatch(req: DispatchMuxRequest): Promise<DispatchMuxResult>;
+}
+
+interface PairOfferRecord {
+    offer: string;
+    uri: string;
+    expiresAt: number;
+    createdAt: number;
+    paired: boolean;
+    bindingId?: string;
+    deviceName?: string;
+    transport?: 'lan' | 'relay';
+    clientPubKey?: string;
+}
+interface PairingStatus {
+    paired: boolean;
+    expired: boolean;
+    bindingId?: string;
+    deviceName?: string;
+    transport?: 'lan' | 'relay';
+}
+declare class PairingManager {
+    private readonly offers;
+    createOffer(ttlSec?: number): PairOfferRecord;
+    getStatus(offer: string): PairingStatus | null;
+    confirm(offer: string, input?: {
+        bindingId?: string;
+        deviceName?: string;
+        transport?: 'lan' | 'relay';
+        clientPubKey?: string;
+    }): PairingStatus;
+    cleanExpired(): void;
+}
+
+/**
+ * event-handler.ts — PARA event subscription and processing for Daemon
+ *
+ * Implements PARA event subscription, Tier-based event routing, and
+ * integration with daemon startup workflow.
+ *
+ * Reference: docs/version190/04-sandbox-permissions.md §5.3
+ */
+
+interface EventHandlerOptions {
+    bus: EventBus;
+    supervisor: AgentSupervisor;
+    /** Optional tier filter for event routing */
+    tierFilter?: number;
+}
+declare class EventHandler {
+    private readonly _bus;
+    private readonly _supervisor;
+    private readonly _tierFilter?;
+    private readonly _subscriptions;
+    private readonly _blockedEvents;
+    private _registered;
+    constructor(opts: EventHandlerOptions);
+    /**
+     * Start subscribing to PARA events.
+     * Must be called after daemon is fully initialized.
+     */
+    start(): void;
+    /**
+     * Stop all event subscriptions.
+     */
+    stop(): void;
+    /**
+     * Subscribe to a specific PARA event type with optional tier filter.
+     */
+    private _subscribe;
+    /**
+     * Unsubscribe from a specific event type.
+     */
+    unsubscribe(eventType: string, handler?: SubscriptionHandler<ParaEvent>): void;
+    /**
+     * Handle agent registration event
+     */
+    private _handleAgentRegister;
+    /**
+     * Handle session started event
+     */
+    private _handleSessionStarted;
+    /**
+     * Handle session ended event
+     */
+    private _handleSessionEnded;
+    /**
+     * Handle agent state change
+     */
+    private _handleAgentState;
+    /**
+     * Handle skill activation
+     */
+    private _handleSkillActivated;
+    /**
+     * Handle skill deactivation
+     */
+    private _handleSkillDeactivated;
+    /**
+     * Handle approval request
+     */
+    private _handleApprovalRequest;
+    /**
+     * Handle approval result
+     */
+    private _handleApprovalResult;
+    /**
+     * Handle task creation
+     */
+    private _handleTaskCreated;
+    /**
+     * Handle task completion
+     */
+    private _handleTaskCompleted;
+    /**
+     * Handle LLM pre-request
+     */
+    private _handleLlmPre;
+    /**
+     * Handle LLM post-request
+     */
+    private _handleLlmPost;
+}
+
+/** Authenticated identity returned by the authenticate callback. */
+interface AuthenticatedIdentity {
+    agentId: string;
+    bearerSub?: string;
+}
+interface DaemonHttpOptions {
+    host?: string;
+    port?: number;
+    eventBus: EventBus;
+    supervisor: AgentSupervisor;
+    fsContextProvider?: (req: {
+        agentId: string;
+        workspace?: string;
+    }) => FsContext | undefined;
+    pairingManager?: PairingManager;
+    eventHandler?: EventHandler;
+    /** When provided, every non-health request must carry a valid Bearer token (null = 401).
+     *  When absent, localhost trust mode: body agentId is used as-is. */
+    authenticate?: (bearerToken: string | undefined) => AuthenticatedIdentity | null;
+}
+/** Generic extension-point route handler registered via registerRoute() (Q3). */
+type RouteHandler = (req: http.IncomingMessage, res: http.ServerResponse, ctx: {
+    authed: AuthenticatedIdentity | null;
+    body: Buffer;
+}) => Promise<void> | void;
+declare class DaemonHttpServer {
+    private readonly _host;
+    private readonly _port;
+    private readonly _bus;
+    private readonly _supervisor;
+    private readonly _fsCtxProvider?;
+    private readonly _authenticate?;
+    private readonly _pairingManager;
+    private readonly _eventHandler?;
+    private _server;
+    private _url;
+    private _running;
+    private readonly _sseClients;
+    private readonly _inFlight;
+    private readonly _startedAt;
+    private readonly _customRoutes;
+    constructor(opts: DaemonHttpOptions);
+    get url(): string | undefined;
+    get isRunning(): boolean;
+    /** Register a custom route handler. Built-in routes take precedence. */
+    registerRoute(method: 'GET' | 'POST' | 'PATCH' | 'DELETE', path: string, handler: RouteHandler): void;
+    /** Remove a previously registered custom route. */
+    unregisterRoute(method: string, path: string): void;
+    private _findCustomRoute;
+    start(): Promise<{
+        host: string;
+        port: number;
+    }>;
+    stop(timeoutMs?: number): Promise<void>;
+    private _handleRequest;
+    private _handleHealth;
+    private _handlePairOffer;
+    private _handlePairStatus;
+    private _handlePairConfirm;
+    private _handleTransportStatus;
+    /** Read-only snapshot of transport state, used by /gui/status. Returns
+     *  null when the multi-path transport isn't enabled. */
+    private _snapshotTransportStatus;
+    private _handleLanProbe;
+    private _handleTransportReprobe;
+}
+
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface LLMRequest {
+    messages: LLMMessage[];
+    maxTokens?: number;
+    temperature?: number;
+    maxCostUsd?: number;
+    maxLatencyMs?: number;
+    capabilities?: string[];
+}
+interface LLMResponse {
+    content: string;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    provider: string;
+    model: string;
+    latencyMs: number;
+    costUsd?: number;
+}
+interface LLMProvider {
+    name: string;
+    model: string;
+    priority: number;
+    capabilities?: string[];
+    pricing?: {
+        inputPer1kUsd: number;
+        outputPer1kUsd: number;
+    };
+    invoke: (req: LLMRequest, signal: AbortSignal) => Promise<Omit<LLMResponse, 'provider' | 'model' | 'latencyMs'>>;
+    healthCheck?: () => Promise<boolean>;
+}
+interface RoutingPolicy {
+    strategy: 'priority' | 'cheapest' | 'fastest' | 'round-robin';
+    retryOnFailure?: boolean;
+    maxRetries?: number;
+    healthCheckIntervalMs?: number;
+    timeoutMs?: number;
+}
+interface ProviderStats {
+    invocations: number;
+    successes: number;
+    failures: number;
+    p50Ms: number;
+    p95Ms: number;
+    avgCostUsd: number;
+}
+declare class AllProvidersFailedError extends Error {
+    attempts: Array<{
+        provider: string;
+        error: string;
+    }>;
+    constructor(attempts: AllProvidersFailedError['attempts']);
+}
+declare class LLMDispatcher {
+    private readonly providers;
+    private policy;
+    private readonly state;
+    private rrCounter;
+    private healthTimer;
+    constructor(providers: LLMProvider[], policy?: RoutingPolicy);
+    complete(req: LLMRequest): Promise<LLMResponse>;
+    get stats(): Record<string, ProviderStats>;
+    setPolicy(policy: RoutingPolicy): void;
+    markProviderDown(name: string): void;
+    markProviderUp(name: string): void;
+    stopHealthChecks(): void;
+    private startHealthChecks;
+    private runHealthChecks;
+    _runHealthChecksNow(): Promise<void>;
+    private isDown;
+    private estimateCostUsd;
+    private selectProviders;
+}
+
+/**
+ * Prismer Runtime — Evolution Gateway HTTP API
+ *
+ * Exposes evolution gateway operations via HTTP for daemon process.
+ * Integrates with LLM Dispatcher for distillation triggers.
+ *
+ * Endpoints:
+ * - POST /evolution/signal — Extract signals from tool output / log
+ * - POST /evolution/record — Record gene execution outcome
+ * - POST /evolution/analyze — Analyze signals and recommend gene
+ * - POST /evolution/genes — Create new gene
+ * - GET /evolution/genes — Query available genes
+ * - GET /evolution/personality — Get agent personality
+ * - POST /evolution/distill — Trigger distillation
+ *
+ * @see docs/version190/IMPLEMENTATION-PLAN-RUNTIME-GAP.md
+ */
+
+interface EvolutionGatewayOptions {
+    eventBus: EventBus;
+    supervisor: AgentSupervisor;
+    llmDispatcher?: LLMDispatcher;
+    /** Cloud API base URL (default: https://prismer.cloud) */
+    cloudApiBase?: string;
+    /** Authenticated identity (from Bearer token or API key) */
+    authenticate?: (bearerToken: string | undefined) => AuthenticatedIdentity | null;
+    /**
+     * v1.9.0 B.7.a — API key used as the Bearer token when forwarding daemon
+     * requests to the cloud Evolution API. When undefined, outbound requests
+     * omit the Authorization header (callers get 401 from cloud until the
+     * daemon is started with `apiKey`).
+     */
+    cloudApiKey?: string;
+}
+interface SignalExtractionRequest {
+    toolOutput?: {
+        toolName?: string;
+        output?: string;
+        exitCode?: number;
+        error?: string;
+        durationMs?: number;
+    };
+    logFile?: {
+        logPath?: string;
+        logContent?: string;
+        timestamp?: string;
+    };
+    provider?: string;
+    stage?: string;
+    severity?: string;
+    tags?: string[];
+}
+interface AnalyzeRequest {
+    signals: string[];
+    taskCapability?: string;
+    provider?: string;
+    stage?: string;
+    severity?: string;
+}
+interface RecordRequest {
+    geneId: string;
+    signals: string[];
+    outcome: 'success' | 'failed';
+    score?: number;
+    summary?: string;
+    costCredits?: number;
+    transitionReason?: 'gene_applied' | 'fallback_relaxed' | 'fallback_neighbor' | 'baseline';
+}
+interface CreateGeneRequest {
+    category: 'repair' | 'optimize' | 'innovate' | 'diagnostic';
+    signalsMatch: string[];
+    strategy: string[];
+    preconditions?: string[];
+    constraints?: {
+        maxCredits?: number;
+        maxRetries?: number;
+        maxExecutionTime?: number;
+    };
+}
+interface DistillationRequest {
+    /** Skip LLM verification and trigger immediately */
+    dryRun?: boolean;
+}
+declare class EvolutionGatewayHttpHandler {
+    private readonly eventBus;
+    private readonly supervisor;
+    private readonly llmDispatcher;
+    private readonly cloudApiBase;
+    private readonly authenticate;
+    private readonly cloudApiKey;
+    private readonly routes;
+    constructor(opts: EvolutionGatewayOptions);
+    private cloudAuthHeaders;
+    private registerRoutes;
+    /** Get all registered routes */
+    getRoutes(): Map<string, RouteHandler>;
+    /** Get a specific route handler */
+    getRoute(method: string, path: string): RouteHandler | undefined;
+    /**
+     * POST /evolution/signal
+     * Extract signals from tool output or log file.
+     */
+    private handleExtractSignal;
+    /**
+     * POST /evolution/analyze
+     * Analyze signals and recommend the best gene.
+     */
+    private handleAnalyze;
+    /**
+     * POST /evolution/record
+     * Record gene execution outcome.
+     */
+    private handleRecord;
+    /**
+     * POST /evolution/genes
+     * Create a new gene.
+     */
+    private handleCreateGene;
+    /**
+     * GET /evolution/genes
+     * Query available genes.
+     */
+    private handleQueryGenes;
+    /**
+     * GET /evolution/personality
+     * Get agent personality.
+     */
+    private handleGetPersonality;
+    /**
+     * POST /evolution/distill
+     * Trigger gene distillation.
+     */
+    private handleDistill;
+    /**
+     * GET /evolution/unmatched
+     * Get unmatched signals (evolution frontier).
+     */
+    private handleGetUnmatched;
+    private parseCloudResponse;
+    private callCloudAnalyze;
+    private callCloudRecord;
+    private callCloudCreateGene;
+    private callCloudQueryGenes;
+    private callCloudGetPersonality;
+    private callCloudDistill;
+    private callCloudGetUnmatched;
+    private triggerLocalDistillation;
+    private extractSignalsLocal;
+}
+
+/**
+ * Prismer Runtime — Task Router
+ *
+ * v1.9.0 Task Router: HTTP API for routing tasks to agents,
+ * capability matching, and SSE streaming of task state changes.
+ *
+ * Integrates with:
+ * - Cloud API (/api/im/tasks) for persistent task store
+ * - AgentSupervisor for local agent status
+ * - EventBus for SSE streaming
+ *
+ * Design reference: docs/version190/IMPLEMENTATION-PLAN-RUNTIME-GAP.md §P1
+ */
+
+/**
+ * Task routing state machine per §16.4.
+ *
+ * State transitions:
+ *   created → dispatching → step_running → step_completed → (next step or completed)
+ *   step_running → step_failed → retrying (×3) → retry_exhausted → needs_human
+ *   step_running → step_timeout → rerouting → step_running (new agent)
+ */
+declare enum TaskRouteState {
+    Created = "created",
+    Dispatching = "dispatching",
+    StepRunning = "step_running",
+    StepCompleted = "step_completed",
+    StepFailed = "step_failed",
+    StepTimeout = "step_timeout",
+    Retrying = "retrying",
+    RetryExhausted = "retry_exhausted",
+    NeedsHuman = "needs_human",
+    Rerouting = "rerouting",
+    Completed = "completed",
+    Cancelled = "cancelled"
+}
+interface TaskRouterOptions {
+    eventBus: EventBus;
+    supervisor: AgentSupervisor;
+    cloudBaseUrl?: string;
+    apiToken?: string;
+}
+interface TaskInfo {
+    id: string;
+    title: string;
+    status: TaskRouteState | string;
+    requiresCapability?: string | null;
+    runtimeRoute?: unknown[] | null;
+    assigneeId?: string | null;
+    progress?: number | null;
+    statusMessage?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RouteTaskRequest {
+    taskId?: string;
+    priority?: 'high' | 'normal' | 'low';
+    preferredAgentId?: string;
+}
+interface RouteTaskResponse {
+    taskId: string;
+    agentId: string;
+    capability: string;
+    stepIdx: number;
+    totalSteps: number;
+}
+interface AssignTaskRequest {
+    agentId: string;
+    taskId?: string;
+}
+interface StepCompletedRequest {
+    taskId?: string;
+    stepId: string;
+    result?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface CancelTaskRequest {
+    taskId?: string;
+    reason: string;
+}
+interface StepFailedRequest {
+    taskId?: string;
+    stepId: string;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+interface StepTimeoutRequest {
+    taskId?: string;
+    stepId: string;
+    capability?: string;
+    metadata?: Record<string, unknown>;
+}
+declare class TaskRouter {
+    private readonly _bus;
+    private readonly _supervisor;
+    private readonly _cloudBaseUrl;
+    private readonly _apiToken;
+    private _sseClients;
+    /** Per-step retry counters: key = `${taskId}:${stepId}` */
+    private readonly _retryCounters;
+    constructor(opts: TaskRouterOptions);
+    /**
+     * Register HTTP routes with the daemon server.
+     * Call this from daemon-http.ts to expose task router endpoints.
+     */
+    registerRoutes(server: {
+        registerRoute: (method: 'GET' | 'POST' | 'PATCH' | 'DELETE', path: string, handler: RouteHandler) => void;
+    }): void;
+    private _handleRouteTask;
+    private _handleAssignTask;
+    private _handleStepCompleted;
+    private _handleCancelTask;
+    private _handleStepFailed;
+    private _handleStepTimeout;
+    private _handleGetTask;
+    private _handleListTasks;
+    /** Publish a task.state event with the given TaskRouteState and optional extra fields. */
+    private _publishState;
+    private _callCloudApi;
+}
+
+type KeychainBackend = 'macos-keychain' | 'libsecret' | 'pass' | 'encrypted-file';
+interface KeychainAdapter {
+    name: KeychainBackend;
+    available(): Promise<boolean>;
+    get(service: string, account: string): Promise<string | null>;
+    set(service: string, account: string, value: string): Promise<void>;
+    delete(service: string, account: string): Promise<void>;
+    list(service: string): Promise<string[]>;
+}
+interface KeychainOptions {
+    preferredBackend?: KeychainBackend;
+    masterPassphrase?: string;
+    encryptedFilePath?: string;
+}
+declare class NoKeychainBackendError extends Error {
+    constructor();
+}
+declare class KeychainOperationError extends Error {
+    constructor(op: string, cause: unknown);
+}
+declare class Keychain {
+    private readonly opts;
+    private resolvedBackend;
+    private detecting;
+    constructor(opts?: KeychainOptions);
+    backend(): Promise<KeychainAdapter>;
+    private buildCandidateList;
+    private makeAdapter;
+    get(service: string, account: string): Promise<string | null>;
+    set(service: string, account: string, value: string): Promise<void>;
+    delete(service: string, account: string): Promise<void>;
+    list(service: string): Promise<string[]>;
+}
+
+interface PrismerConfig {
+    apiKey?: string;
+    apiBase?: string;
+    daemon?: {
+        host?: string;
+        port?: number;
+    };
+    agents?: Record<string, {
+        enabled?: boolean;
+        apiKey?: string;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+interface LoadConfigOptions {
+    path?: string;
+    keychain?: Keychain;
+    resolvePlaceholders?: boolean;
+}
+declare class ConfigError extends Error {
+    constructor(message: string);
+}
+declare function parseKeyringPlaceholder(value: string): {
+    service: string;
+    account: string;
+} | null;
+declare function loadConfig(opts?: LoadConfigOptions): Promise<PrismerConfig>;
+declare function writeConfig(config: PrismerConfig, opts?: {
+    path?: string;
+}): Promise<void>;
+
+interface MigrateStep {
+    level: 'info' | 'ok' | 'warn' | 'error';
+    message: string;
+    detail?: string;
+}
+interface MigrateSecretsOptions {
+    configPath?: string;
+    keychain: Keychain;
+    dryRun?: boolean;
+    onStep?: (step: MigrateStep) => void;
+}
+interface MigrateSecretsResult {
+    migrated: Array<{
+        path: string;
+        service: string;
+        account: string;
+    }>;
+    skipped: Array<{
+        path: string;
+        reason: string;
+    }>;
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+declare function migrateSecrets(opts: MigrateSecretsOptions): Promise<MigrateSecretsResult>;
+
+interface DaemonRunnerOptions {
+    host?: string;
+    port?: number;
+    pidFile?: string;
+    dataDir?: string;
+    installSignalHandlers?: boolean;
+    authBearer?: string;
+    apiKey?: string;
+    daemonId?: string;
+    userId?: string;
+    enableTransport?: boolean;
+    forceProbe?: boolean;
+    workspace?: string;
+    /**
+     * v1.9.0 B.7.a — cloud base URL (https://prismer.cloud for prod,
+     * https://cloud.prismer.dev for test). Forwarded to EvolutionGateway so
+     * daemon→cloud calls hit the same env the API key was issued against.
+     */
+    cloudApiBase?: string;
+}
+interface DaemonRunnerHandle {
+    stop(): Promise<void>;
+    readonly url: string;
+    readonly pid: number;
+    readonly dataDir: string;
+}
+declare function startDaemonRunner(opts?: DaemonRunnerOptions): Promise<DaemonRunnerHandle>;
+
+declare function assertBrandVoice(text: string, label?: string): void;
+
+type OutputMode = 'pretty' | 'json' | 'quiet';
+interface UIOptions {
+    mode?: OutputMode;
+    color?: boolean;
+    stream?: NodeJS.WritableStream;
+    errStream?: NodeJS.WritableStream;
+}
+interface TableRow {
+    [column: string]: string;
+}
+interface TableOptions {
+    columns: string[];
+    maxWidth?: number;
+}
+interface LegacyTableOptions {
+    columns: string[];
+    rows: TableRow[];
+    maxWidth?: number;
+}
+
+declare class UI {
+    readonly mode: OutputMode;
+    readonly colorEnabled: boolean;
+    private readonly stream;
+    private readonly errStream;
+    constructor(opts?: UIOptions);
+    private ansi;
+    private green;
+    private red;
+    private yellow;
+    private cyan;
+    private dim;
+    private bold;
+    private gray;
+    private brandMark;
+    private colorBrandLine;
+    write(text: string): void;
+    writeErr(text: string): void;
+    header(text: string): void;
+    smallHeader(subtitle?: string): void;
+    banner(subtitle?: string, opts?: {
+        full?: boolean;
+    }): void;
+    blank(): void;
+    line(text: string): void;
+    info(text: string): void;
+    secondary(text: string, indent?: number): void;
+    tip(text: string): void;
+    next(text: string): void;
+    ok(text: string, detail?: string): void;
+    success(text: string, detail?: string): void;
+    fail(text: string, detail?: string): void;
+    online(text: string): void;
+    offline(text: string): void;
+    notInstalled(text: string): void;
+    pending(text: string): void;
+    warn(text: string, detail?: string): void;
+    error(what: string, cause?: string, fix?: string): void;
+    table(rows: TableRow[], opts: TableOptions): void;
+    table(opts: LegacyTableOptions): void;
+    spinner(text: string): {
+        update(t: string): void;
+        stop(final?: string): void;
+    };
+    progress(text: string, total: number): {
+        update(current: number, detail?: string): void;
+        stop(final?: string): void;
+    };
+    json(payload: unknown, opts?: {
+        pretty?: boolean;
+    }): void;
+    result<T>(pretty: () => void, jsonPayload: T): void;
+}
+declare function getUI(): UI;
+declare function setUI(ui: UI): void;
+declare function applyCommonFlags(argv: string[]): {
+    mode: OutputMode;
+    color: boolean;
+    restArgv: string[];
+};
+
+interface CliContext {
+    ui: UI;
+    keychain: Keychain;
+    cwd: string;
+    argv: string[];
+}
+declare function createCliContext(opts?: {
+    argv?: string[];
+    ui?: UI;
+}): Promise<CliContext>;
+
+interface AgentCatalogEntry {
+    name: string;
+    displayName: string;
+    packPackage: string;
+    packVersionRange: string;
+    hookConfigPath: string;
+    mcpConfigPath?: string;
+    upstreamBinary: string;
+    upstreamVersionRange?: string;
+    localSourcePath?: string;
+    installCommand?: string;
+    tiersSupported: number[];
+    capabilityTags: string[];
+    detect: () => Promise<{
+        found: boolean;
+        binaryPath?: string;
+        version?: string;
+    }>;
+}
+declare const AGENT_CATALOG: AgentCatalogEntry[];
+declare function getAgent(name: string): AgentCatalogEntry | undefined;
+
+type HookFormat = 'v1.8' | 'v1.9';
+interface HookEntry {
+    command?: string;
+    webhook?: string;
+    enabled?: boolean;
+    [key: string]: unknown;
+}
+interface HookConfig {
+    hooks: Record<string, HookEntry | HookEntry[]>;
+    [key: string]: unknown;
+}
+interface MergeResult {
+    merged: HookConfig;
+    added: string[];
+    preserved: string[];
+    replaced: string[];
+    backupPath?: string;
+}
+interface MergeOptions {
+    daemonUrl: string;
+    dryRun?: boolean;
+    /** Absolute path to the installed claude-code-plugin root (contains hooks/para-emit.mjs). */
+    pluginRoot?: string;
+}
+declare function mergeHooks(existing: HookConfig | null, opts: MergeOptions): MergeResult;
+declare function readHookConfig(filePath: string): Promise<HookConfig | null>;
+declare function writeHookConfig(filePath: string, cfg: HookConfig): Promise<void>;
+declare function installHooks(configPath: string, existing: HookConfig | null, opts: MergeOptions): Promise<MergeResult>;
+declare function rollbackHooks(configPath: string): Promise<{
+    restored: boolean;
+    fromBackup: string | null;
+}>;
+
+interface PairOffer {
+    offer: string;
+    uri: string;
+    expiresAt: number;
+    relayUrl?: string;
+    lanHost?: string;
+    lanPort?: number;
+}
+interface PairedDevice {
+    id: string;
+    name: string;
+    method: 'qr' | 'api-key';
+    transport: 'lan' | 'relay';
+    lastSeenAt: number;
+    pairedAt: number;
+}
+
+interface MigrateOptions {
+    dryRun?: boolean;
+    configPath?: string;
+    homeDir?: string;
+    yes?: boolean;
+    /**
+     * Dependency-injection hook for tests — override the TTY confirmation prompt.
+     * When provided, replaces the readline-based promptConfirm call entirely.
+     */
+    confirmer?: () => Promise<boolean>;
+}
+interface MigrateResult {
+    apiKeyMigrated: boolean;
+    hooksBackedUp: string[];
+    hooksRedirected: string[];
+    memoryFilesImported: number;
+    networkEndpointsRewritten: Array<{
+        file: string;
+        rewrites: number;
+        backupPath: string;
+    }>;
+    errors: Array<{
+        step: string;
+        error: string;
+    }>;
+}
+
+interface EncryptionConfig {
+    enabled: boolean;
+    key?: Buffer;
+}
+interface MemoryFile {
+    id: string;
+    ownerId: string;
+    ownerType: 'user' | 'agent';
+    scope: string;
+    path: string;
+    content: string;
+    version: number;
+    memoryType?: string;
+    description?: string;
+    contentHash: string;
+    createdAt: string;
+    updatedAt: string;
+    stale: boolean;
+}
+interface MemoryFileVersion {
+    id: string;
+    fileId: string;
+    version: number;
+    content: string;
+    createdAt: string;
+}
+interface DreamCompaction {
+    id: string;
+    ownerId: string;
+    scope: string;
+    summary: string;
+    createdAt: string;
+}
+interface WriteMemoryFileInput {
+    ownerId: string;
+    ownerType: 'user' | 'agent';
+    scope?: string;
+    path: string;
+    content: string;
+    memoryType?: string;
+    description?: string;
+}
+interface MemoryFileFilters {
+    ownerId?: string;
+    scope?: string;
+    path?: string;
+    memoryType?: string;
+    stale?: boolean;
+    limit?: number;
+    offset?: number;
+}
+interface MemorySearchResult extends MemoryFile {
+    relevance: number;
+    snippet?: string;
+}
+interface MemoryStats {
+    fileCount: number;
+    totalSize: number;
+    totalBytes: number;
+    staleFiles: number;
+    ftsIndexed: number;
+    recallP95: number;
+}
+declare class MemoryDB {
+    private readonly filePath;
+    private readonly db;
+    private readonly crypto;
+    constructor(_encryptionConfig?: EncryptionConfig, opts?: {
+        filePath?: string;
+    });
+    writeMemoryFile(input: WriteMemoryFileInput): MemoryFile;
+    getMemoryFileById(id: string): MemoryFile | null;
+    deleteMemoryFile(id: string): boolean;
+    listMemoryFiles(filters?: MemoryFileFilters): MemoryFile[];
+    searchMemoryFiles(keyword: string, filters?: MemoryFileFilters): MemorySearchResult[];
+    getStats(ownerId?: string): MemoryStats;
+    close(): void;
+}
+declare function getMemoryDB(): MemoryDB;
+declare function closeMemoryDB(): void;
+declare function generateSalt(): Buffer;
+declare function deriveKey(password: string, salt: Buffer): Buffer;
+declare function encrypt(plaintext: string, key: Buffer): string;
+declare function decrypt(encoded: string, key: Buffer): string;
+
+interface WriteMemoryRequest {
+    ownerId: string;
+    ownerType: 'user' | 'agent';
+    path: string;
+    content: string;
+    scope?: string;
+    memoryType?: string;
+    description?: string;
+    encrypt?: boolean;
+}
+interface RecallRequest {
+    keyword: string;
+    ownerId?: string;
+    scope?: string;
+    limit?: number;
+    useCloudFallback?: boolean;
+}
+interface ListMemoryRequest {
+    ownerId?: string;
+    scope?: string;
+    path?: string;
+    memoryType?: string;
+    stale?: boolean;
+    limit?: number;
+    offset?: number;
+}
+interface MemoryResponse {
+    success: boolean;
+    data?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+
+interface DreamResult {
+    ok: boolean;
+    compactedFiles: number;
+    summary?: DreamCompaction;
+}
+interface DreamSchedulerOptions {
+    ownerId?: string;
+    scope?: string;
+    intervalMs?: number;
+}
+declare class DreamScheduler {
+    private readonly opts;
+    private timer;
+    constructor(opts?: DreamSchedulerOptions);
+    start(): void;
+    stop(): void;
+}
+declare function createDreamScheduler(opts?: DreamSchedulerOptions): DreamScheduler;
+declare function runDream(opts?: DreamSchedulerOptions): Promise<DreamResult>;
+
+/**
+ * PARA L8 — Session Export Trace Writer
+ *
+ * Per PARA spec §4.2 L8 (docs/version190/03-para-spec.md):
+ *   session export 必须是 pre-compaction 的原始 trace。compaction 会把历史消息替换为 summary——
+ *   这种 adapter 必须额外持久化原始 trace 到 `.prismer/trace/<sessionId>.jsonl.zst`
+ *   （append-only + zstd 压缩），compaction 只影响 working memory，不动 trace。
+ *
+ * Implementation:
+ *   - Each `append()` JSON-stringifies the envelope, adds '\n', zstd-compresses it,
+ *     then sync-appends the compressed bytes to the trace file.
+ *   - zstd supports concatenated frames — multiple independent compressed blobs
+ *     catenated together decompress back to the concatenation of their inputs.
+ *     This is what makes append-only valid without holding a long-lived stream.
+ *   - File mode 0o600 (trace may contain sensitive payloads).
+ *   - Node 22+ gives us native `zlib.zstdCompressSync`. Older Node: append is a no-op
+ *     and a single stderr warning is emitted at construction time. We do NOT throw
+ *     or crash the daemon — daemon must still start on Node 20.
+ */
+
+interface TraceWriterOptions {
+    sessionId: string;
+    /**
+     * Override home directory; trace file will live at
+     * `<homeDir>/.prismer/trace/<sessionId>.jsonl.zst`. Defaults to `os.homedir()`.
+     */
+    homeDir?: string;
+    /**
+     * Explicit trace directory. Overrides homeDir if provided. Useful when the
+     * daemon runs with a non-default `dataDir`.
+     */
+    traceDir?: string;
+}
+declare class TraceWriter {
+    private readonly _sessionId;
+    private readonly _filePath;
+    private readonly _compress;
+    private _bytesWritten;
+    private _warnedAppendError;
+    private _closed;
+    constructor(opts: TraceWriterOptions);
+    /** Absolute path of the trace file: `<home>/.prismer/trace/<sessionId>.jsonl.zst`. */
+    get filePath(): string;
+    /** Session ID this writer is bound to. */
+    get sessionId(): string;
+    /** Total compressed bytes appended since construction. */
+    get bytesWritten(): number;
+    /** True if zstd is unavailable (Node < 22); append() is a no-op. */
+    get disabled(): boolean;
+    /**
+     * Synchronously append one event envelope to the trace as a new zstd frame.
+     * Safe to call after close() — becomes a no-op. Errors are logged once and swallowed.
+     */
+    append(event: EventBusEnvelope): void;
+    /**
+     * Close the writer. Currently a no-op because we use sync append with one
+     * self-contained zstd frame per event. The API exists so callers can switch to
+     * a streaming implementation later without changing integration code.
+     */
+    close(): void;
+}
+interface TraceWriterManagerOptions {
+    /** Override home directory (tests). Defaults to os.homedir(). */
+    homeDir?: string;
+    /** Explicit trace directory — takes precedence over homeDir when set. */
+    traceDir?: string;
+}
+/**
+ * Routes events from the EventBus (`bus.subscribe('*', ...)`) to the per-session
+ * TraceWriter.
+ *
+ *   agent.session.started → open writer for payload.sessionId
+ *   agent.session.ended   → close + remove writer
+ *   any other event       → pick the writer by payload.sessionId if present;
+ *                           events without sessionId are skipped (not guessed)
+ */
+declare class TraceWriterManager {
+    private readonly _writers;
+    private readonly _homeDir;
+    private readonly _traceDir;
+    private readonly _warnedOpenFailures;
+    constructor(opts?: TraceWriterManagerOptions);
+    /** Event-bus subscription handler. Pass via `bus.subscribe('*', mgr.handle)`. */
+    readonly handle: (ev: EventBusEnvelope) => void;
+    /** Close all writers — call on daemon shutdown. */
+    shutdown(): void;
+    /** Test / introspection helper. */
+    activeSessions(): string[];
+    private _openWriter;
+    private _closeWriter;
+}
+
+/**
+ * Prismer Runtime — E2EE Crypto Module (v1.9.0)
+ *
+ * End-to-end encryption for LAN direct connections.
+ * Uses X25519 for key exchange and XSalsa20-Poly1305 for encryption.
+ *
+ * Security model:
+ *   - Daemon and mobile each generate X25519 keypair
+ *   - Keys are exchanged via QR code or relay (out-of-band)
+ *   - Each session derives unique encryption key via HKDF
+ *   - All LAN traffic is encrypted - relay never sees plaintext
+ *
+ * This implementation uses Node.js built-in crypto module for
+ * compatibility and no external dependencies.
+ */
+interface KeyPair {
+    publicKey: Buffer;
+    privateKey: Buffer;
+}
+interface E2EEContext {
+    localKeyPair: KeyPair;
+    remotePublicKey: Buffer;
+    sharedSecret: Buffer;
+    sendKey: Buffer;
+    recvKey: Buffer;
+    sendNonce: Buffer;
+    recvNonce: Buffer;
+}
+interface EncryptedEnvelope {
+    version: number;
+    nonce: Buffer;
+    ciphertext: Buffer;
+    authTag: Buffer;
+}
+/**
+ * Generate X25519 keypair for E2EE
+ */
+declare function generateKeyPair(): KeyPair;
+/**
+ * Derive shared secret from local private key and remote public key (X25519)
+ */
+declare function deriveSharedSecret(localPrivateKey: Buffer, remotePublicKey: Buffer): Buffer;
+/**
+ * Derive send/recv keys from shared secret using HKDF-SHA256.
+ *
+ * Role is determined by lexicographic comparison of the two public keys
+ * so both peers agree without an explicit role flag. Without the keys
+ * (legacy single-context callers), defaults to the "A" role.
+ */
+declare function deriveSessionKeys(sharedSecret: Buffer, localPublicKey?: Buffer, remotePublicKey?: Buffer): {
+    sendKey: Buffer;
+    recvKey: Buffer;
+};
+/**
+ * Serialize encrypted envelope to buffer
+ */
+declare function serializeEnvelope(envelope: EncryptedEnvelope): Buffer;
+/**
+ * Deserialize encrypted envelope from buffer
+ */
+declare function deserializeEnvelope(data: Buffer): EncryptedEnvelope;
+/**
+ * Create E2EE context for a session
+ */
+declare function createE2EEContext(localKeyPair: KeyPair, remotePublicKey: Buffer): E2EEContext;
+/**
+ * Encrypt message using E2EE context
+ */
+declare function encryptMessage(context: E2EEContext, plaintext: Buffer): Buffer;
+/**
+ * Decrypt message using E2EE context
+ */
+declare function decryptMessage(context: E2EEContext, data: Buffer): Buffer;
+
+/**
+ * Prismer Runtime — E2EE Key Storage (v1.9.0)
+ *
+ * Secure storage for E2EE keys on daemon side.
+ * Uses keychain backend with encrypted JSON fallback for offline/keyless systems.
+ *
+ * Storage model:
+ *   - Primary: Keychain (macOS Keychain / libsecret / pass)
+ *   - Fallback: Encrypted JSON file (~/.prismer/e2ee-keys.json)
+ *   - Per-session keys with TTL (30 min default)
+ *   - Automatic cleanup of expired keys
+ *
+ * Security:
+ *   - Keys encrypted at rest (keychain or encrypted file)
+ *   - Master passphrase required for file fallback
+ *   - Automatic key rotation on session expiry
+ *   - Forward secrecy: ephemeral keys discarded after session
+ */
+
+interface E2EEKeyEntry {
+    /** Session ID (userId:daemonId or userId:deviceId) */
+    sessionId: string;
+    /** User ID who owns this key */
+    userId: string;
+    /** Daemon ID or Device ID */
+    endpointId: string;
+    /** Local keypair (ephemeral) */
+    keyPair: {
+        publicKey: string;
+        privateKey: string;
+    };
+    /** Remote public key */
+    remotePublicKey: string;
+    /** When this key was created */
+    createdAt: number;
+    /** When this key expires (unix timestamp) */
+    expiresAt: number;
+    /** Current sequence number */
+    seq: number;
+}
+interface E2EEStorageStats {
+    totalKeys: number;
+    activeKeys: number;
+    expiredKeys: number;
+    oldestKeyAge: number;
+    newestKeyAge: number;
+}
+declare class E2EEKeyStorage {
+    private keychain;
+    private useEncryptedFile;
+    private masterPassphrase?;
+    private cleanupInterval?;
+    constructor(options?: {
+        masterPassphrase?: string;
+    });
+    /**
+     * Initialize storage (try keychain, fallback to encrypted file)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store E2EE key for a session
+     */
+    storeKey(entry: E2EEKeyEntry): Promise<void>;
+    /**
+     * Retrieve E2EE key for a session
+     */
+    getKey(sessionId: string): Promise<E2EEKeyEntry | null>;
+    /**
+     * Remove E2EE key for a session
+     */
+    removeKey(sessionId: string): Promise<void>;
+    /**
+     * Get all keys for a user (for recovery)
+     */
+    getAllKeysForUser(userId: string): Promise<E2EEKeyEntry[]>;
+    /**
+     * Get storage statistics
+     */
+    getStats(userId?: string): Promise<E2EEStorageStats>;
+    /**
+     * Cleanup expired keys
+     */
+    cleanupExpiredKeys(): Promise<void>;
+    /**
+     * Shutdown storage (cleanup interval)
+     */
+    destroy(): void;
+    private ensureStorageFile;
+    private readEncryptedFile;
+    private writeEncryptedFile;
+    private encryptFile;
+    private decryptFile;
+    private storeInEncryptedFile;
+    private getFromEncryptedFile;
+    private removeFromEncryptedFile;
+    private getAllFromEncryptedFile;
+    private storeInKeychain;
+    private getFromKeychain;
+    private removeFromKeychain;
+    private getAllFromKeychain;
+}
+/**
+ * Generate session ID for E2EE storage
+ * Format: {userId}:{endpointId}
+ */
+declare function generateSessionId(userId: string, endpointId: string): string;
+/**
+ * Parse session ID into components
+ */
+declare function parseSessionId(sessionId: string): {
+    userId: string;
+    endpointId: string;
+};
+/**
+ * Create E2EE key entry from runtime context
+ */
+declare function createKeyEntry(userId: string, endpointId: string, keyPair: KeyPair, remotePublicKey: string, seq?: number): E2EEKeyEntry;
+
+/**
+ * secret-scan — local-side secret detection for memory team sync.
+ *
+ * Mirror of src/im/services/memory/team-sync.service.ts SECRET_PATTERNS.
+ * Kept in sync by convention — if you add a pattern there, add it here.
+ *
+ * Used by memory-team-sync.ts before POSTing bytes to the server (so secrets
+ * never leave the device). Server has its own independent scanner (defense
+ * in depth).
+ *
+ * Design: docs/version190/14e-memory-cc-compat.md §8.5
+ */
+interface SecretHit {
+    /** Pattern name (e.g. 'aws-access-key'). */
+    pattern: string;
+    /** Truncated match (never more than 80 chars — no full secret echo). */
+    match: string;
+    /** 1-based line number. */
+    line: number;
+    /**
+     * If true, this hit is informational only — not strong enough evidence
+     * to block a push on its own (e.g. JWT-shaped strings).
+     */
+    warnOnly: boolean;
+}
+/** Scan content for known secret patterns. Returns the list of hits. */
+declare function scanForSecrets(content: string): SecretHit[];
+/**
+ * Convenience: true if content has at least one blocking (non-warnOnly) hit.
+ */
+declare function hasBlockingSecret(content: string): boolean;
+
+/**
+ * memory-team-sync — client-side delta push + server-wins pull for team memory.
+ *
+ * Walks a local directory (typically `~/.claude/memory/team/<owner>/<repo>/`),
+ * diffs content hashes against a persisted `last-sync.json`, pushes only the
+ * changed files, and writes any server-side-newer rows back to disk.
+ *
+ * Design: docs/version190/14e-memory-cc-compat.md §8.5
+ *
+ * Secret scanning (local): any file whose content matches a blocking pattern
+ * is rejected before it leaves the device. The server also scans (defense in
+ * depth).
+ */
+/** Per-file content size limit (matches server). */
+declare const MEMORY_TEAM_SYNC_MAX_BYTES: number;
+/** Name of the sidecar state file. */
+declare const LAST_SYNC_FILE = ".prismer-team-sync.json";
+interface SyncTeamMemoryOptions {
+    /** Team identifier, e.g. `'acme/widgets'`. */
+    team: string;
+    /** Root directory to sync (scanned recursively). */
+    rootDir: string;
+    /** Prismer API key (Bearer). */
+    apiKey: string;
+    /**
+     * Base URL for the IM API — typically the cloud host.
+     * e.g. `'https://prismer.cloud/api/im'` or `'http://localhost:3000/api/im'`.
+     */
+    baseUrl: string;
+    /**
+     * Optional override of the since timestamp. Normally we read this from the
+     * sidecar state file and ignore this param. Exposed mainly for testing.
+     */
+    since?: string;
+    /**
+     * Custom fetch (for tests). Defaults to the global fetch.
+     */
+    fetchImpl?: typeof fetch;
+    /**
+     * If true, do not write pulled[] rows to disk and do not update sidecar.
+     * Useful for dry-run/preflight.
+     */
+    dryRun?: boolean;
+}
+interface SyncTeamMemoryResult {
+    pushed: number;
+    pulled: number;
+    rejected: Array<{
+        path: string;
+        reason: string;
+        detail?: string;
+    }>;
+    skippedLocalSecrets: Array<{
+        path: string;
+        pattern: string;
+        line: number;
+    }>;
+    serverTime: string;
+}
+/** Walk rootDir recursively for .md files (only). Returns POSIX-style rel paths. */
+declare function listMarkdownFiles(rootDir: string): string[];
+/**
+ * Sync a team-memory directory with the cloud.
+ *
+ *   1. Walk rootDir for .md files
+ *   2. Hash each; diff against last-sync.json → push[] candidates
+ *   3. Local secret scan → any hits are skipped (not pushed)
+ *   4. POST /memory/team/sync with push[] and since
+ *   5. Write pulled[] to disk (server wins)
+ *   6. Update last-sync.json
+ */
+declare function syncTeamMemory(opts: SyncTeamMemoryOptions): Promise<SyncTeamMemoryResult>;
+/**
+ * Remove the sidecar state file — forces the next sync to re-push everything.
+ * Useful from CLI tooling.
+ */
+declare function resetTeamSyncState(rootDir: string): void;
+
+/**
+ * Shamir Secret Sharing over GF(256) — byte-oriented implementation.
+ *
+ * Split a secret Buffer into N shares such that any M (threshold) shares can
+ * reconstruct the original, but fewer than M reveal zero information.
+ *
+ * Field: GF(256) with AES irreducible polynomial 0x11B.
+ *        Addition = XOR. Multiplication = carryless multiply mod 0x11B.
+ *        Share-id x ∈ {1..255} (x=0 is the secret itself).
+ *
+ * Each byte of the secret is split independently using a polynomial of degree
+ * m-1:  P(x) = s + a_1*x + a_2*x^2 + ... + a_{m-1}*x^{m-1}  (all arithmetic in GF(256))
+ * where s is the secret byte and a_1..a_{m-1} are uniformly random.
+ *
+ * Recovery uses Lagrange interpolation evaluated at x=0.
+ *
+ * Mnemonic format: Crockford base32 with 1-byte version header (0x01) and
+ * CRC-16/CCITT-FALSE checksum. Groups of 4 characters separated by hyphens.
+ *
+ * No external npm dependencies.
+ *
+ * See: Shamir, "How to Share a Secret", 1979. GF(256) byte-level variant used
+ * by industry (Trezor Shamir Backup, HashiCorp Vault, etc.).
+ */
+/**
+ * Branded `Buffer` that has been validated as a Shamir share by this module.
+ *
+ * Nominal typing prevents accidentally passing an arbitrary `Buffer` (e.g.
+ * `Buffer.from('hello')`) into {@link combineShares} or
+ * {@link encodeShareAsMnemonic}. TypeScript structural equality is defeated
+ * by the `__brand` phantom field, so the only path to a `ShamirShare` value
+ * is through this module's own functions (`splitSecret`,
+ * `decodeShareFromMnemonic`) or the explicit escape hatch
+ * {@link unsafeAsShamirShare}.
+ *
+ * This is a compile-time guard only; runtime validation (duplicate ids,
+ * inconsistent lengths, CRC) still happens inside `combineShares` /
+ * `decodeShareFromMnemonic`.
+ */
+type ShamirShare = Buffer & {
+    readonly __brand: unique symbol;
+};
+/**
+ * Escape hatch for interop paths that already hold raw share Buffers
+ * (e.g. legacy callers that read bytes off the wire themselves and cannot
+ * route through {@link decodeShareFromMnemonic}).
+ *
+ * This is a **sharp edge**: the caller is asserting the buffer is a
+ * well-formed share byte string (`[share_id, y_byte_1, y_byte_2, ...]` with
+ * `share_id ∈ 1..255`). Passing an arbitrary buffer here will compile, and
+ * will pass length / id / duplicate checks inside `combineShares`, but will
+ * reconstruct a plausibly-shaped yet **semantically wrong** secret.
+ *
+ * Prefer `decodeShareFromMnemonic` wherever possible — the CRC-16 check
+ * there catches tampered or wrong-batch shares.
+ */
+declare function unsafeAsShamirShare(buf: Buffer): ShamirShare;
+/**
+ * Split a secret into n shares; any m can recombine.
+ *
+ * Each returned share Buffer is [share_id_byte, y_byte_1, y_byte_2, ...].
+ * The share-id is 1..n (never 0).
+ *
+ * @param secret plaintext bytes
+ * @param n total shares (2..255)
+ * @param m threshold (2..n)
+ */
+declare function splitSecret(secret: Buffer, n: number, m: number): ShamirShare[];
+/**
+ * Combine shares to recover the secret. Any m of n suffice (where m is the
+ * threshold used at split time).
+ *
+ * @param shares array of share Buffers (each [x_byte, y_bytes...])
+ * @returns recovered secret
+ */
+declare function combineShares(shares: ShamirShare[]): Buffer;
+/**
+ * Encode a share as a mnemonic string.
+ *
+ * Framing (before base32 encoding):
+ *   [0x01 version] [share bytes...] [CRC-16/CCITT-FALSE of (version||share)]
+ *
+ * Output is Crockford base32, grouped in blocks of 4 characters separated by
+ * hyphens for readability. Case-insensitive on decode.
+ */
+declare function encodeShareAsMnemonic(share: ShamirShare): string;
+/**
+ * Decode a mnemonic string back into a share Buffer. Strips whitespace,
+ * hyphens, and normalizes case. Validates the version byte and CRC-16.
+ */
+declare function decodeShareFromMnemonic(encoded: string): ShamirShare;
+
+interface TimelineEntry {
+    seq: number;
+    opcode: number;
+    slot: number;
+    payload: Buffer;
+    createdAt: number;
+}
+interface OutboxEntry {
+    id: number;
+    seq: number;
+    frame: Buffer;
+    createdAt: number;
+    attempts: number;
+}
+interface DeadLetterEntry {
+    id: number;
+    originalId: number;
+    seq: number;
+    createdAt: number;
+    failedAt: number;
+    attempts: number;
+}
+interface DroppedFrame {
+    id: number;
+    seq: number;
+    attempts: number;
+}
+interface DaemonOutboxOptions {
+    bindingId: string;
+    dataDir?: string;
+    timelineCap?: number;
+    outboxCap?: number;
+    maxAttempts?: number;
+    onDrop?: (entries: DroppedFrame[]) => void;
+}
+declare class DaemonOutbox {
+    private db;
+    private bindingId;
+    private timelineCap;
+    private outboxCap;
+    private maxAttempts;
+    private onDrop?;
+    private currentSeq;
+    private droppedCount;
+    constructor(opts: DaemonOutboxOptions);
+    private initSchema;
+    appendSent(opcode: number, slot: number, payload: Buffer): number;
+    getTimelineSince(lastSeq: number, limit?: number): TimelineEntry[];
+    getCurrentSeq(): number;
+    private enforceTimelineCap;
+    queue(seq: number, frame: Buffer): number;
+    drain(limit?: number): OutboxEntry[];
+    ack(outboxId: number): void;
+    bumpAttempts(outboxId: number): {
+        attempts: number;
+        deadLettered: boolean;
+    };
+    private moveToDeadLetter;
+    getDeadLetterCount(): number;
+    getDeadLetterEntries(limit?: number, includeFrame?: boolean): (DeadLetterEntry & {
+        frame?: Buffer;
+    })[];
+    pendingCount(): number;
+    getDroppedCount(): number;
+    private enforceOutboxCap;
+    close(): void;
+}
+/** 2-byte header + payload per §5.6.4 */
+declare function frameFromParts(opcode: number, slot: number, payload: Buffer): Buffer;
+
+/**
+ * Prismer Runtime — WSS Relay Client (v1.9.0)
+ *
+ * WebSocket client for cloud relay communication. Connects to the main
+ * cloud host (derived from `cloudApiBase`) under the `/ws/daemon/*` path
+ * prefix — there is no separate relay subdomain.
+ *
+ * Responsibilities:
+ *   - Register daemon binding with API key
+ *   - Receive remote command pushes (control channel)
+ *   - Route encrypted envelopes (data channel)
+ *   - Heartbeat keepalive (30s interval)
+ *   - Auto-reconnect with exponential backoff
+ */
+
+declare const OPCODE: {
+    readonly JSON_CONTROL: 0;
+    readonly AGENT_OUTPUT: 1;
+    readonly TERMINAL_IO: 2;
+    readonly FILE_CHUNK: 3;
+    readonly AUDIT_TAP: 4;
+    readonly BACKFILL_REQUEST: 5;
+    readonly BACKFILL_CHUNK: 6;
+};
+interface RelayClientOptions {
+    apiKey: string;
+    daemonId: string;
+    userId: string;
+    /**
+     * Base WSS URL for the relay (e.g. `wss://cloud.prismer.dev`). The client
+     * appends `/ws/daemon/control` and `/ws/daemon/data` to this base. Callers
+     * typically derive it from `cloudApiBase` via `deriveWsFromHttp()`.
+     */
+    relayUrl: string;
+    heartbeatIntervalMs?: number;
+    reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+    autoReconnect?: boolean;
+    /** v1.9.0 — bindingId enables daemon-side outbox + timeline backfill (§5.6.5). */
+    bindingId?: string;
+    /** Override outbox location (for tests); defaults to ~/.prismer/daemon/{bindingId}. */
+    outboxDataDir?: string;
+}
+interface RelayState {
+    connected: boolean;
+    channel: 'control' | 'data' | null;
+    lastHeartbeat?: number;
+    reconnectAttempts: number;
+    lastError?: string;
+}
+interface RemoteCommand {
+    id: string;
+    type: string;
+    payload: Record<string, unknown>;
+    createdAt: number;
+}
+declare class RelayClient extends EventEmitter {
+    private apiKey;
+    private daemonId;
+    private userId;
+    private relayUrl;
+    private heartbeatIntervalMs;
+    private reconnectDelayMs;
+    private maxReconnectDelayMs;
+    private autoReconnect;
+    private controlWs;
+    private dataWs;
+    private heartbeatInterval?;
+    private heartbeatTimer?;
+    private reconnectTimer?;
+    private state;
+    private isShuttingDown;
+    private outbox?;
+    constructor(opts: RelayClientOptions);
+    /**
+     * Connect to relay server (both control and data channels)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from relay server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send command to mobile client via relay (data channel).
+     *
+     * v1.9.0 — if bindingId was provided, every tracked data-plane frame
+     * (AGENT_OUTPUT / TERMINAL_IO / FILE_CHUNK) is recorded in the local
+     * timeline before send. If the data channel is down, the frame is queued
+     * to the outbox and will be replayed on next successful connect.
+     */
+    /**
+     * Send JSON control message to cloud via the control channel.
+     * v1.9.x — used by daemon to ack remote commands (e.g. command.result).
+     * Returns false silently if control channel is not connected.
+     */
+    sendControl(message: unknown): boolean;
+    sendCommand(data: Buffer | string): boolean;
+    /**
+     * Get current connection state
+     */
+    getState(): RelayState;
+    /**
+     * Get connection status summary
+     */
+    getStatus(): {
+        controlConnected: boolean;
+        dataConnected: boolean;
+        lastHeartbeat?: number;
+        reconnectAttempts: number;
+    };
+    /**
+     * Connect to control channel (/ws/daemon/control)
+     */
+    private connectControlChannel;
+    /**
+     * Connect to data channel (/ws/daemon/data)
+     */
+    private connectDataChannel;
+    private relayEndpoint;
+    /**
+     * Register daemon with relay server
+     */
+    private registerDaemon;
+    /**
+     * Handle incoming control channel messages
+     */
+    private handleControlMessage;
+    /** RPC method handlers registered by the daemon process. Keyed by method
+     *  name (e.g. 'fs.read'). Result is serialized into the rpc.response
+     *  envelope. Thrown errors → `error` field. */
+    private rpcHandlers;
+    /** Register an RPC handler. Daemon code calls this at startup for each
+     *  method it wants to expose to cloud relay (mobile → cloud → daemon). */
+    registerRpcHandler(method: string, handler: (params: unknown) => Promise<unknown>): void;
+    private handleRpcRequest;
+    private sendRpcResponse;
+    /**
+     * Handle incoming data channel messages.
+     *
+     * v1.9.0 — intercept backfill-request (opcode 0x05) from the cloud
+     * (cloud forwards it on behalf of a reconnecting mobile client) and
+     * respond with backfill-chunk frames (opcode 0x06) for every timeline
+     * entry with seq > payload.lastSeq.
+     */
+    private handleDataMessage;
+    /**
+     * Drain outbox by replaying queued frames over the data channel.
+     * Called after reconnect() succeeds. Stops on the first send failure
+     * to preserve ordering.
+     */
+    private replayOutbox;
+    /** Pending count for status reporting. */
+    getOutboxPending(): number;
+    /**
+     * Handle remote command from mobile
+     */
+    private handleRemoteCommand;
+    /**
+     * Start heartbeat interval
+     */
+    private startHeartbeat;
+    /**
+     * Clear heartbeat timers
+     */
+    private clearHeartbeat;
+    /**
+     * Send heartbeat to relay
+     */
+    private sendHeartbeat;
+    /**
+     * Acknowledge heartbeat from relay
+     */
+    private sendHeartbeatAck;
+    /**
+     * Handle disconnection from one or both channels
+     */
+    private handleDisconnect;
+    /**
+     * Schedule reconnection with exponential backoff
+     */
+    private scheduleReconnect;
+    /**
+     * Clear reconnect timer
+     */
+    private clearReconnectTimer;
+    /**
+     * Close control channel
+     */
+    private closeControlChannel;
+    /**
+     * Close data channel
+     */
+    private closeDataChannel;
+}
+
+declare const RUNTIME_VERSION = "1.9.0";
+
+export { AGENT_CATALOG, type AdapterDescriptor, type AdapterDispatchInput, type AdapterDispatchResult, type AdapterImpl, AdapterRegistry, type AgentCatalogEntry, type AgentDescriptor, type AgentState, type AgentStatus, AgentSupervisor, AllProvidersFailedError, type AnalyzeRequest, type AssignTaskRequest, type AuthenticatedIdentity, type CancelTaskRequest, type CliContext, ConfigError, type CreateGeneRequest, DaemonAlreadyRunningError, type DaemonHttpOptions, DaemonHttpServer, type DaemonOptions, DaemonOutbox, type DaemonOutboxOptions, DaemonProcess, type DaemonRunnerHandle, type DaemonRunnerOptions, type DaemonState, DispatchMux, type DispatchMuxRequest, type DispatchMuxResult, type DistillationRequest, type DreamCompaction, type DreamResult, DreamScheduler, type DreamSchedulerOptions, type E2EEContext, type E2EEKeyEntry, type KeyPair as E2EEKeyPair, E2EEKeyStorage, type E2EEStorageStats, type EncryptedEnvelope, type EncryptionConfig, EventBus, type EventBusEnvelope, type EventBusOptions, EvolutionGatewayHttpHandler, type EvolutionGatewayOptions, type HookConfig, type HookEntry, type HookFormat, Keychain, type KeychainAdapter, type KeychainBackend, KeychainOperationError, type KeychainOptions, LAST_SYNC_FILE, LLMDispatcher, type LLMMessage, type LLMProvider, type LLMRequest, type LLMResponse, type ListMemoryRequest, type LoadConfigOptions, MEMORY_TEAM_SYNC_MAX_BYTES, MemoryDB, type MemoryFile, type MemoryFileVersion, type MemoryResponse, type MergeOptions, type MergeResult, type MigrateOptions, type MigrateResult, type MigrateSecretsOptions, type MigrateSecretsResult, NoKeychainBackendError, OPCODE, type OutboxEntry, type OutputMode, type PairOffer, type PairedDevice, type PrismerConfig, type ProviderStats, RUNTIME_VERSION, type RecallRequest, type RecordRequest, RelayClient, type RelayClientOptions, type RelayState, type RemoteCommand, type RouteHandler, type RouteTaskRequest, type RouteTaskResponse, type RoutingPolicy, type SecretHit, type ShamirShare, type ShutdownHandler, type SignalExtractionRequest, type StepCompletedRequest, type StepFailedRequest, type StepTimeoutRequest, type Subscription, type SubscriptionHandler, type SupervisorOptions, type SyncTeamMemoryOptions, type SyncTeamMemoryResult, type TableOptions, type TableRow, type TaskInfo, TaskRouteState, TaskRouter, type TaskRouterOptions, type TimelineEntry, TraceWriter, TraceWriterManager, type TraceWriterManagerOptions, type TraceWriterOptions, UI, type UIOptions, type WriteMemoryRequest, applyCommonFlags, assertBrandVoice, closeMemoryDB, combineShares, createCliContext, createDreamScheduler, createE2EEContext, createKeyEntry, decodeShareFromMnemonic, decrypt, decryptMessage, deriveKey, deriveSessionKeys, deriveSharedSecret, deserializeEnvelope, encodeShareAsMnemonic, encrypt, encryptMessage, frameFromParts, generateKeyPair as generateE2EEKeyPair, generateSalt, generateSessionId, getAgent, getMemoryDB, getUI, hasBlockingSecret, installHooks, listMarkdownFiles, loadConfig, mergeHooks, migrateSecrets, parseKeyringPlaceholder, parseSessionId, readHookConfig, resetTeamSyncState, rollbackHooks, runDream, scanForSecrets, serializeEnvelope, setUI, splitSecret, startDaemonRunner, syncTeamMemory, unsafeAsShamirShare, writeConfig, writeHookConfig };