@mirasoth/soothe-client 0.1.0 → 0.2.1

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 
 /**
- * Custom error types for the Soothe client.
+ * Custom error types for the Soothe client (RFC-450 protocol-1).
  */
 /** Represents a WebSocket connection failure. */
 declare class ConnectionError extends Error {
@@ -10,12 +10,20 @@ declare class ConnectionError extends Error {
     readonly cause: Error;
     constructor(url: string, attempt: number, cause: Error);
 }
-/** Represents an error reported by the Soothe daemon. */
+/**
+ * Represents an error reported by the Soothe daemon (RFC-450 §7).
+ *
+ * The daemon's structured error object carries a numeric `code` from the
+ * reserved ranges, a human-readable `message`, and optional `data`.
+ */
 declare class DaemonError extends Error {
-    readonly code: string;
+    /** Numeric error code from the RFC-450 §7.3 registry. */
+    readonly code: number;
     /** The daemon's error message text. */
     readonly daemonMessage: string;
-    constructor(code: string, message: string);
+    /** Optional machine-parseable error details. */
+    readonly data: unknown;
+    constructor(code: number, message: string, data?: unknown);
 }
 /** Represents a timeout waiting for a daemon response. */
 declare class TimeoutError extends Error {
@@ -23,12 +31,45 @@ declare class TimeoutError extends Error {
     readonly duration: string;
     constructor(operation: string, duration: string);
 }
+/**
+ * Distinguishes clean vs unclean connection loss (RFC-450 §4, §8.3).
+ *
+ * A clean drop follows a `disconnect` notification (loops keep running
+ * server-side); an unclean drop is a read/write error or a missed pong
+ * (in-flight queries are cancelled). Pair with the Client's `'disconnected'`
+ * event: the cause is emitted exactly once when the connection drops.
+ */
+declare enum DisconnectCause {
+    /** Abrupt loss: read/write error or missed pong (RFC-450 §8.3). */
+    Unclean = 0,
+    /** Graceful peer-initiated `disconnect` notification (RFC-450 §9.2). */
+    Clean = 1
+}
+/** Human-readable cause name for logging. */
+declare function disconnectCauseName(cause: DisconnectCause): string;
+/** Indicates a failed reconnection attempt sequence. */
+declare class ReconnectError extends Error {
+    readonly url: string;
+    readonly attempts: number;
+    readonly cause: Error;
+    constructor(url: string, attempts: number, cause: Error);
+}
+/**
+ * Returned by `reattachAndProbe` when a loop accepts the reattach handshake
+ * but fails the `loop_get` liveness probe. Callers should fall back to a
+ * fresh `loop_new` bootstrap.
+ */
+declare class StaleLoopError extends Error {
+    readonly loopID: string;
+    readonly cause?: Error;
+    constructor(loopID: string, cause?: Error);
+}
 
 /**
  * Verbosity levels and tiers for event filtering.
  */
 /** User-configurable verbosity setting. */
-type VerbosityLevel = 'quiet' | 'normal' | 'debug';
+type VerbosityLevel = "quiet" | "normal" | "debug";
 /** Minimum verbosity level at which content is visible. */
 declare enum VerbosityTier {
     /** Always visible (errors, assistant text, final reports) */
@@ -62,12 +103,20 @@ interface Config {
     reconnectDelay: number;
     /** Application-level heartbeat interval in ms */
     heartbeatInterval: number;
-    /** Handshake: wait for daemon_ready in ms */
+    /** Handshake: wait for connection_ack (readiness "ready") in ms */
     daemonReadyTimeout: number;
     /** Bootstrap: wait for status with loop_id in ms */
     loopStatusTimeout: number;
-    /** After loop_subscribe: wait for confirmation in ms */
+    /** After subscribe(method:"loop_events"): wait for confirmation in ms */
     subscriptionTimeout: number;
+    /** Max reconnection attempts on a mid-session drop (0 = infinite). */
+    reconnectMaxAttempts: number;
+    /** Initial backoff delay (ms) between reconnect attempts. */
+    reconnectInitialDelay: number;
+    /** Cap (ms) on exponential backoff delay between reconnect attempts. */
+    reconnectMaxDelay: number;
+    /** `loop_get` liveness probe timeout (ms) in reattachAndProbe. */
+    reattachProbeTimeout: number;
 }
 /** Returns default configuration. */
 declare function defaultConfig(): Config;
@@ -75,250 +124,260 @@ declare function defaultConfig(): Config;
 declare function loadConfigFromEnv(): Config;
 
 /**
- * Message types, encode/decode, NDJSON splitting, and factory functions
- * for the Soothe daemon wire protocol.
+ * Daemon ``loop_input`` intent_hint values (direct model turns, no agent graph).
  */
-interface BaseMessage {
-    type: string;
-    request_id?: string;
-}
-/** Loop-scoped user input. */
-interface LoopInputMessage extends BaseMessage {
-    type: 'loop_input';
-    loop_id: string;
-    content: string;
-    autonomous?: boolean;
-    max_iterations?: number;
-    preferred_subagent?: string;
-    interactive?: boolean;
-    model?: string;
-    model_params?: Record<string, unknown>;
-    attachments?: Record<string, unknown>[];
-}
-interface CommandMessage extends BaseMessage {
-    type: 'command';
-    cmd: string;
-}
-interface DaemonStatusMessage extends BaseMessage {
-    type: 'daemon_status';
-}
-interface DaemonShutdownMessage extends BaseMessage {
-    type: 'daemon_shutdown';
-}
-interface ConfigGetMessage extends BaseMessage {
-    type: 'config_get';
-    section: string;
-}
-interface LoopNewMessage extends BaseMessage {
-    type: 'loop_new';
-    /** Project directory; runner uses this path directly when set. */
-    client_workspace?: string;
-    /** Stable scope for persisted sandbox when client_workspace is unset. */
-    client_workspace_id?: string;
-    /** User segment under $SOOTHE_HOME/workspaces/ (empty → anonymous). */
-    user_id?: string;
-    /** When true, loop execution data is GC'd after idle period (workspace retained). */
-    is_ephemeral?: boolean;
-    /**
-     * @deprecated Use `client_workspace`. Still accepted by the daemon as an alias.
-     */
-    workspace?: string;
+/** Text-only chat completion via the configured ``default`` role. */
+declare const INTENT_HINT_TEXT_COMPLETION: "text_completion";
+/** Vision / image understanding via the configured ``image`` role (attachments required). */
+declare const INTENT_HINT_IMAGE_TO_TEXT: "image_to_text";
+/** OCR via the configured ``ocr`` role (attachments required). */
+declare const INTENT_HINT_OCR: "ocr";
+/** Embedding via the configured ``embedding`` role (text-only; JSON vector response). */
+declare const INTENT_HINT_EMBED: "embed";
+/** Supported daemon direct-model intent hints. */
+type IntentHint = typeof INTENT_HINT_TEXT_COMPLETION | typeof INTENT_HINT_IMAGE_TO_TEXT | typeof INTENT_HINT_OCR | typeof INTENT_HINT_EMBED;
+/** Legacy intent_hint values removed from the daemon wire contract. */
+declare const REMOVED_INTENT_HINTS: readonly ["direct_llm", "quiz"];
+type RemovedIntentHint = (typeof REMOVED_INTENT_HINTS)[number];
+/**
+ * Wire ``loop_input.intent_hint``: direct model hints or agent-path pass-through
+ * (e.g. ``resume_clarification``, ``skill:foo``). Legacy ``direct_llm`` and
+ * ``quiz`` are rejected before send.
+ */
+type LoopInputIntentHint = IntentHint | (string & {});
+/** Returns an error message when ``hint`` is a removed legacy value; otherwise null. */
+declare function validateLoopInputIntentHint(hint: string): string | null;
+/** Phases emitted on ``mode=messages`` for user-visible loop assistant output. */
+declare const LOOP_ASSISTANT_OUTPUT_PHASES: readonly ["goal_completion", "quiz", "autonomous_goal", "direct_model", "text_completion", "image_to_text", "ocr", "embed", "plan_direct"];
+type LoopAssistantOutputPhase = (typeof LOOP_ASSISTANT_OUTPUT_PHASES)[number];
+/** Default deliverable phases for triarch-style apps (direct hints + agent outputs). */
+declare const DEFAULT_DELIVERABLE_PHASES: ReadonlySet<string>;
+
+/**
+ * Protocol-1 wire envelope: message types, encode/decode, NDJSON splitting,
+ * and factory functions for the Soothe daemon (RFC-450).
+ *
+ * The unified `{proto, type, method, params, id}` envelope combines
+ * JSON-RPC 2.0's `method`/`params`/`id` structure with graphql-ws's `type`
+ * semantics for message class distinction.
+ */
+
+/** Protocol version string (RFC-450 §8.1). */
+declare const PROTO_VERSION = "1";
+/** Default client capabilities declared in the connection_init handshake. */
+declare const DEFAULT_CLIENT_CAPABILITIES: string[];
+/** Client version reported in the connection_init handshake. */
+declare const CLIENT_VERSION = "0.1.0";
+type MessageType = "connection_init" | "connection_ack" | "request" | "response" | "notification" | "subscribe" | "next" | "error" | "complete" | "unsubscribe" | "ping" | "pong" | "receipt_response" | "disconnect" | "status";
+/** Method names carried in the envelope `method` field (RFC-450 §9.2). */
+type MethodName = "loop_list" | "loop_get" | "loop_tree" | "loop_prune" | "loop_delete" | "loop_new" | "loop_reattach" | "loop_detach" | "loop_input" | "loop_messages" | "loop_state_get" | "loop_state_update" | "loop_cards_fetch" | "loop_history_fetch" | "loop_events" | "autopilot_events" | "job_create" | "job_status" | "job_pause" | "job_resume" | "job_cancel" | "job_dag" | "job_guidance" | "daemon_status" | "daemon_shutdown" | "config_get" | "config_reload" | "skills_list" | "invoke_skill" | "models_list" | "mcp_status" | "auth" | "auth_refresh" | "slash_command" | "rpc_command" | "delivery_ack" | "cron_add" | "cron_list" | "cron_show" | "cron_cancel" | "disconnect";
+/** Base fields shared by every protocol-1 message. */
+interface BaseEnvelope {
+    proto: string;
+    type: MessageType;
 }
-/** Options for `loop_new` workspace fields. */
-interface LoopNewOptions {
-    client_workspace?: string;
-    client_workspace_id?: string;
-    user_id?: string;
-    is_ephemeral?: boolean;
-    /** @deprecated Use `client_workspace`. */
-    workspace?: string;
+/** A client→server RPC request (expects a `response` correlated by `id`). */
+interface RequestEnvelope extends BaseEnvelope {
+    type: "request";
+    method: MethodName;
+    params?: Record<string, unknown>;
+    id: string;
 }
-interface LoopSubscribeMessage extends BaseMessage {
-    type: 'loop_subscribe';
-    loop_id: string;
-    verbosity: string;
-    stream_delivery?: 'batch' | 'streaming';
+/** A server→client RPC success response. */
+interface ResponseEnvelope extends BaseEnvelope {
+    type: "response";
+    result?: Record<string, unknown>;
+    id?: string;
 }
-interface LoopDetachMessage extends BaseMessage {
-    type: 'loop_detach';
-    loop_id: string;
+/** A fire-and-forget client→server notification (no `id`, no response). */
+interface NotificationEnvelope extends BaseEnvelope {
+    type: "notification";
+    method: MethodName;
+    params?: Record<string, unknown>;
+    /** Optional receipt id for delivery confirmation (RFC-450 §5.7). */
+    receipt?: string;
 }
-interface LoopListMessage extends BaseMessage {
-    type: 'loop_list';
-    filter?: Record<string, unknown>;
-    limit?: number;
+/** Start a subscription stream (events arrive as `next`). */
+interface SubscribeEnvelope extends BaseEnvelope {
+    type: "subscribe";
+    method: "loop_events" | "autopilot_events";
+    params?: {
+        loop_id?: string;
+        verbosity?: string;
+        /** Stream delivery mode: batch (coalesce until turn end), adaptive (small payloads passthrough), streaming (real-time chunks). */
+        stream_delivery?: "batch" | "adaptive" | "streaming";
+        /** Wire serialization tier: full (all fields), compact (essential fields only). */
+        wire_tier?: "full" | "compact";
+    } & Record<string, unknown>;
+    id: string;
 }
-interface LoopGetMessage extends BaseMessage {
-    type: 'loop_get';
-    loop_id: string;
-    verbose?: boolean;
+/** A stream event for an active subscription. */
+interface NextEnvelope extends BaseEnvelope {
+    type: "next";
+    payload?: Record<string, unknown>;
+    id?: string;
 }
-interface LoopTreeMessage extends BaseMessage {
-    type: 'loop_tree';
-    loop_id: string;
-    format?: string;
+/** Structured error response (terminates the operation). */
+interface ErrorEnvelope extends BaseEnvelope {
+    type: "error";
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    id?: string;
 }
-interface LoopPruneMessage extends BaseMessage {
-    type: 'loop_prune';
-    loop_id: string;
-    retention_days?: number;
-    dry_run?: boolean;
+/** Explicit stream-completion signal. */
+interface CompleteEnvelope extends BaseEnvelope {
+    type: "complete";
+    id?: string;
 }
-interface LoopDeleteMessage extends BaseMessage {
-    type: 'loop_delete';
-    loop_id: string;
+/** Cancel a subscription by `id`. */
+interface UnsubscribeEnvelope extends BaseEnvelope {
+    type: "unsubscribe";
+    id: string;
 }
-interface LoopReattachMessage extends BaseMessage {
-    type: 'loop_reattach';
-    loop_id: string;
+/** Connection handshake (client→server, first message). */
+interface ConnectionInitEnvelope extends BaseEnvelope {
+    type: "connection_init";
+    params?: {
+        client_version: string;
+        client_name?: string;
+        accept_proto?: string[];
+        capabilities?: string[];
+    };
 }
-interface SkillsListMessage extends BaseMessage {
-    type: 'skills_list';
+/** Connection handshake response (server→client). */
+interface ConnectionAckEnvelope extends BaseEnvelope {
+    type: "connection_ack";
+    result?: {
+        server_version?: string;
+        protocol_version?: string;
+        capabilities?: string[];
+        readiness_state?: string;
+        heartbeat_interval_ms?: number;
+    };
 }
-interface ModelsListMessage extends BaseMessage {
-    type: 'models_list';
+/** Heartbeat ping (either direction). */
+interface PingEnvelope extends BaseEnvelope {
+    type: "ping";
 }
-interface InvokeSkillMessage extends BaseMessage {
-    type: 'invoke_skill';
-    skill: string;
-    args?: string;
+/** Heartbeat pong response. */
+interface PongEnvelope extends BaseEnvelope {
+    type: "pong";
 }
-interface DetachMessage extends BaseMessage {
-    type: 'detach';
+/** Delivery confirmation for a notification that carried a `receipt`. */
+interface ReceiptResponseEnvelope extends BaseEnvelope {
+    type: "receipt_response";
+    receipt: string;
 }
-interface EventMessage extends BaseMessage {
-    type: 'event';
-    loop_id?: string;
-    namespace: string;
-    data: Record<string, unknown>;
-    timestamp?: string;
+/** Clean connection close (daemon keeps loops running). */
+interface DisconnectEnvelope extends BaseEnvelope {
+    type: "disconnect";
 }
-interface StatusResponse extends BaseMessage {
-    type: 'status';
-    state: string;
+/**
+ * A daemon status frame. `status` is a defined protocol-1 top-level type
+ * (RFC-450 §9.1): it passes through the daemon's legacy→`next` translator
+ * unchanged, so it is NOT wrapped in a `next` envelope.
+ */
+interface StatusFrame extends BaseEnvelope {
+    type: "status";
+    state?: string;
     loop_id?: string;
-    workspace: string;
+    workspace?: string;
     input_history?: string[];
     conversation_history?: unknown[];
+    [key: string]: unknown;
 }
-interface SubscriptionConfirmedResponse extends BaseMessage {
-    type: 'subscription_confirmed';
-    loop_id?: string;
-    client_id: string;
-    verbosity: string;
-}
-interface ErrorResponse extends BaseMessage {
-    type: 'error';
-    code: string;
-    message: string;
-}
-interface DaemonReadyResponse extends BaseMessage {
-    type: 'daemon_ready';
-    state: string;
-    message?: string;
-}
-interface DaemonStatusResponse extends BaseMessage {
-    type: 'daemon_status_response';
-    running: boolean;
-    port_live: boolean;
-    active_loops: number;
-}
-interface ShutdownAckResponse extends BaseMessage {
-    type: 'shutdown_ack';
-    status: string;
-}
-interface LoopNewResponse extends BaseMessage {
-    type: 'loop_new_response';
+/** Discriminated union of all decoded protocol-1 messages. */
+type DecodedMessage = RequestEnvelope | ResponseEnvelope | NotificationEnvelope | SubscribeEnvelope | NextEnvelope | ErrorEnvelope | CompleteEnvelope | UnsubscribeEnvelope | ConnectionInitEnvelope | ConnectionAckEnvelope | PingEnvelope | PongEnvelope | ReceiptResponseEnvelope | DisconnectEnvelope | StatusFrame | Record<string, unknown>;
+interface LoopInputParams {
     loop_id: string;
-    success?: boolean;
-    is_ephemeral?: boolean;
-}
-interface LoopSubscribeResponse extends BaseMessage {
-    type: 'loop_subscribe_response';
-    loop_id?: string;
-    success: boolean;
-    message?: string;
-}
-interface LoopDetachResponse extends BaseMessage {
-    type: 'loop_detach_response';
-    loop_id?: string;
-    success: boolean;
-}
-interface LoopListResponse extends BaseMessage {
-    type: 'loop_list_response';
-    loops?: Record<string, unknown>[];
-    total?: number;
-}
-interface LoopGetResponse extends BaseMessage {
-    type: 'loop_get_response';
-    loop?: Record<string, unknown>;
-}
-interface LoopTreeResponse extends BaseMessage {
-    type: 'loop_tree_response';
-    tree?: Record<string, unknown>;
-}
-interface LoopPruneResponse extends BaseMessage {
-    type: 'loop_prune_response';
-    result?: Record<string, unknown>;
-}
-interface LoopDeleteResponse extends BaseMessage {
-    type: 'loop_delete_response';
-    success: boolean;
-    message?: string;
-}
-interface LoopReattachResponse extends BaseMessage {
-    type: 'loop_reattach_response';
-    loop_id?: string;
-    success?: boolean;
-}
-interface HistoryReplayMessage extends BaseMessage {
-    type: 'history_replay';
-    loop_id?: string;
-    events?: Record<string, unknown>[];
-    total_events?: number;
-}
-interface HistoryReplayCompleteMessage extends BaseMessage {
-    type: 'history_replay_complete';
-    loop_id?: string;
-}
-interface ReplayCompleteMessage extends BaseMessage {
-    type: 'replay_complete';
-    loop_id?: string;
-    event_count?: number;
-}
-interface LoopReattachedWireMessage extends BaseMessage {
-    type: 'loop_reattached';
-    loop_id?: string;
-    timestamp?: string;
+    content: string;
+    autonomous?: boolean;
+    max_iterations?: number;
+    preferred_subagent?: string;
+    /** @deprecated Ignored by daemon; loop_input always uses non-interactive autonomous mode. */
+    interactive?: boolean;
+    model?: string;
+    model_params?: Record<string, unknown>;
+    attachments?: Record<string, unknown>[];
+    intent_hint?: LoopInputIntentHint;
+    response_schema?: Record<string, unknown>;
+    response_schema_name?: string;
+    response_schema_strict?: boolean;
+    clarification_mode?: string;
+    clarification_answer?: boolean;
+    clarification_answers?: string[];
 }
-interface SkillsListResponse extends BaseMessage {
-    type: 'skills_list_response';
-    skills?: Record<string, unknown>[];
+/** Options for `loop_new` workspace fields. */
+interface LoopNewOptions {
+    client_workspace?: string;
+    client_workspace_id?: string;
+    user_id?: string;
+    is_ephemeral?: boolean;
+    /** @deprecated Use `client_workspace`. */
+    workspace?: string;
 }
-interface ModelsListResponse extends BaseMessage {
-    type: 'models_list_response';
-    models?: Record<string, unknown>[];
+/**
+ * Shape of a `next` payload when the daemon wraps a legacy free-form frame.
+ * The original frame type becomes `mode`; `data` carries the frame body with
+ * `loop_id` preserved.
+ */
+interface StreamEventPayload {
+    namespace?: unknown;
+    mode?: string;
+    data?: Record<string, unknown>;
 }
-type DecodedMessage = LoopInputMessage | CommandMessage | DaemonStatusMessage | DaemonShutdownMessage | ConfigGetMessage | LoopNewMessage | LoopSubscribeMessage | LoopDetachMessage | LoopListMessage | LoopGetMessage | LoopTreeMessage | LoopPruneMessage | LoopDeleteMessage | LoopReattachMessage | SkillsListMessage | ModelsListMessage | InvokeSkillMessage | DetachMessage | EventMessage | StatusResponse | SubscriptionConfirmedResponse | ErrorResponse | DaemonReadyResponse | DaemonStatusResponse | ShutdownAckResponse | LoopNewResponse | LoopSubscribeResponse | LoopDetachResponse | LoopListResponse | LoopGetResponse | LoopTreeResponse | LoopPruneResponse | LoopDeleteResponse | LoopReattachResponse | HistoryReplayMessage | HistoryReplayCompleteMessage | ReplayCompleteMessage | LoopReattachedWireMessage | SkillsListResponse | ModelsListResponse | Record<string, unknown>;
-/** Encodes a message as JSON with newline delimiter. */
+/** Encodes a message as JSON with a newline delimiter (NDJSON frame). */
 declare function encodeMessage(msg: unknown): string;
-/** Decodes a JSON message and returns a typed object. Unknown types return a raw map. */
+/**
+ * Decodes a JSON message and returns a typed object. Unknown types return a
+ * raw map. The decoder is permissive: it accepts protocol-1 envelopes and
+ * surfaces `response.result` / `next.payload` for consumers that read them,
+ * but always returns the full envelope so callers can inspect `type`/`id`.
+ */
 declare function decodeMessage(data: string): DecodedMessage | null;
+/** Builds a `request` envelope. */
+declare function requestEnvelope(method: MethodName, params?: Record<string, unknown>, id?: string): RequestEnvelope;
+/** Builds a `notification` envelope (no `id`). */
+declare function notificationEnvelope(method: MethodName, params?: Record<string, unknown>): NotificationEnvelope;
+/** Builds a `subscribe` envelope. */
+declare function subscribeEnvelope(method: "loop_events" | "autopilot_events", params?: Record<string, unknown>, id?: string): SubscribeEnvelope;
+/** Builds an `unsubscribe` envelope. */
+declare function unsubscribeEnvelope(id: string): UnsubscribeEnvelope;
+/** Builds a `connection_init` handshake envelope. */
+declare function connectionInitEnvelope(opts?: {
+    client_version?: string;
+    client_name?: string;
+    accept_proto?: string[];
+    capabilities?: string[];
+}): ConnectionInitEnvelope;
+/** Builds a `ping` heartbeat envelope. */
+declare function pingEnvelope(): PingEnvelope;
+/** Builds a `pong` heartbeat envelope. */
+declare function pongEnvelope(): PongEnvelope;
+/** Builds a `disconnect` notification envelope. */
+declare function disconnectEnvelope(): DisconnectEnvelope;
 /** Splits a single WebSocket text payload into individual JSON lines. */
 declare function splitWirePayload(data: string): string[];
 /**
- * Returns the AgentLoop id when present in a message.
- * Prefers loop_id field.
+ * Returns the StrangeLoop id when present in a message.
+ *
+ * Under protocol-1, loop-scoped stream events arrive as `next` envelopes
+ * whose `payload.data` carries the original frame (with `loop_id`). Raw
+ * `status` frames carry `loop_id` at the top level. This helper inspects
+ * both shapes.
  */
 declare function extractSootheLoopID(msg: unknown): [string, boolean];
-/** Generates a new UUID request ID. */
+/** Generates a new UUID correlation ID (RFC-450 §5.2 `id`). */
 declare function newRequestID(): string;
-/** Creates a loop_input message with required fields. */
-declare function newLoopInputMessage(loopID: string, content: string): LoopInputMessage;
-/** Creates a loop_new message. */
-declare function newLoopNewMessage(opts?: LoopNewOptions | string): LoopNewMessage;
-/** Creates a loop_subscribe message. */
-declare function newLoopSubscribeMessage(loopID: string, verbosity: string, streamDelivery?: 'batch' | 'streaming'): LoopSubscribeMessage;
+/** Creates a `loop_input` notification envelope. */
+declare function newLoopInputMessage(loopID: string, content: string): NotificationEnvelope;
+/** Creates a `loop_new` request envelope. */
+declare function newLoopNewMessage(opts?: LoopNewOptions | string): RequestEnvelope;
+/** Creates a `loop_events` subscribe envelope. */
+declare function newLoopSubscribeMessage(loopID: string, verbosity: string, streamDelivery?: "batch" | "adaptive" | "streaming"): SubscribeEnvelope;
 
 /**
  * Client-facing event namespace constants for the Soothe daemon wire protocol.
@@ -339,18 +398,31 @@ declare const EventTacitusGatherSummary = "soothe.subagent.tacitus.gather.summar
 declare const EventTacitusCompleted = "soothe.subagent.tacitus.completed";
 declare const EventReplayComplete = "replay_complete";
 declare const EventLoopReattachedWire = "loop_reattached";
+declare const EventCardReplayBegin = "card.replay_begin";
+declare const EventCardCreated = "card.created";
+declare const EventCardReplayEnd = "card.replay_end";
 declare const EventToolStarted = "soothe.tool.execution.started";
 declare const EventToolCompleted = "soothe.tool.execution.completed";
 declare const EventToolError = "soothe.tool.execution.error";
 declare const EventStreamToolCallUpdate = "soothe.stream.tool_call.update";
 declare const EventToolCallUpdatesBatch = "tool_call_updates_batch";
-declare const EventAgentLoopStarted = "soothe.cognition.agent_loop.started";
-declare const EventAgentLoopIterated = "soothe.cognition.agent_loop.iterated";
-declare const EventAgentLoopCompleted = "soothe.cognition.agent_loop.completed";
-declare const EventAgentLoopReasoned = "soothe.cognition.agent_loop.reasoned";
+declare const EventStrangeLoopStarted = "soothe.cognition.strange_loop.started";
+declare const EventStrangeLoopCompleted = "soothe.cognition.strange_loop.completed";
+declare const EventStrangeLoopPlanDecision = "soothe.cognition.strange_loop.plan.decision";
+declare const EventStrangeLoopReasoned = "soothe.cognition.strange_loop.reasoned";
+declare const EventStrangeLoopStepStarted = "soothe.cognition.strange_loop.step.started";
+declare const EventStrangeLoopStepQueued = "soothe.cognition.strange_loop.step.queued";
+declare const EventStrangeLoopStepCompleted = "soothe.cognition.strange_loop.step.completed";
+declare const EventStrangeLoopContextCompacted = "soothe.cognition.strange_loop.context.compacted";
 declare const EventMessageReceived = "soothe.protocol.message.received";
 declare const EventMessageSent = "soothe.protocol.message.sent";
 declare const EventFinalReport = "soothe.output.autonomous.final_report.reported";
+declare const EventAutopilotGoalStatus = "soothe.autopilot.goal.status";
+declare const EventAutopilotGoalProgress = "soothe.autopilot.goal.progress";
+declare const EventAutopilotGoalCreated = "soothe.autopilot.goal.created";
+declare const EventAutopilotGoalCompleted = "soothe.autopilot.goal.completed";
+declare const EventAutopilotWorkerAssigned = "soothe.autopilot.worker.assigned";
+declare const EventAutopilotWorkerUnassigned = "soothe.autopilot.worker.unassigned";
 declare const EventGeneralFailed = "soothe.error.general.failed";
 /** Splits a 4-segment event namespace into domain, component, and action. */
 declare function parseNamespace(ns: string): {
@@ -364,113 +436,365 @@ declare function classifyEventVerbosity(eventTypeOrNamespace: string): Verbosity
 declare function isCompletionEvent(eventType: string): boolean;
 /** Lifecycle subagent events (started/completed) for progress UI. */
 declare function isSubagentProgressEvent(eventType: string): boolean;
-/** Essential progress event types for minimal UI surfaces. */
-declare const ESSENTIAL_EVENT_TYPES: ReadonlySet<string>;
 
 /**
- * Client manages a WebSocket session with the Soothe daemon.
- * After close(), a new Client must be created to reconnect.
+ * Client manages a WebSocket session with the Soothe daemon (RFC-450 protocol-1).
+ *
+ * After close(), a new Client must be created to reconnect. The connection
+ * begins with a bidirectional connection_init/connection_ack handshake; no
+ * requests are accepted until the daemon reports readiness_state "ready".
  */
 
+/** Input options for `sendInput` (loop_input). */
 interface InputOptions {
-    /** Subscribed AgentLoop id (required for loop_input). */
+    /** Subscribed StrangeLoop id (required for loop_input). */
     loopID?: string;
     autonomous?: boolean;
     maxIterations?: number;
     subagent?: string;
+    /** @deprecated Ignored by daemon; loop_input always uses non-interactive autonomous mode. */
     interactive?: boolean;
     model?: string;
     modelParams?: Record<string, unknown>;
     attachments?: Record<string, unknown>[];
+    /** Daemon direct-model hint or agent-path pass-through (resume_clarification, skill:foo). */
+    intentHint?: LoopInputIntentHint;
+    /** JSON Schema for structured output (text_completion or image_to_text). */
+    responseSchema?: Record<string, unknown>;
+    /** Provider schema name for structured output. */
+    responseSchemaName?: string;
+    /** Strict mode for JSON schema (default true). */
+    responseSchemaStrict?: boolean;
+    /** Clarification relay mode ("auto" / "manual"). */
+    clarificationMode?: string;
+    /** Treat this input as answer to pending clarification interrupt. */
+    clarificationAnswer?: boolean;
+    /** Per-question answers for multi-question clarifications. */
+    clarificationAnswers?: string[];
 }
+/** Capability set negotiated with the daemon. */
+type NegotiatedCapabilities = ReadonlySet<string>;
 declare class Client extends EventEmitter {
     private url;
     private config;
     private ws;
     private messageBuffer;
     private resolvers;
+    private handshakeComplete;
+    private negotiatedCapabilities;
+    private protocolVersion;
+    private readinessState;
+    private heartbeatIntervalMs;
+    private heartbeatTimer;
+    private lastPongMonotonic;
+    private disconnFired;
+    private mux;
     constructor(url: string, config?: Config);
-    /** Dials the Soothe daemon WebSocket. No WS-level ping/pong (RFC-0013). */
+    /**
+     * Dials the Soothe daemon WebSocket and completes the protocol-1 handshake
+     * (connection_init → connection_ack with readiness_state "ready").
+     */
     connect(): Promise<void>;
-    /** Shuts down the WebSocket connection. */
+    /** Sends a `disconnect` notification and closes the WebSocket. */
     close(): void;
-    /** Returns whether the client has an active WebSocket connection. */
+    /** Returns whether the client has an active, handshaked WebSocket connection. */
     isConnected(): boolean;
+    /**
+     * Returns whether the connection has dropped (the `'disconnected'` event has
+     * fired). Pair with the `'disconnected'` event for the signal. Use
+     * `disconnectCause()` to read the cause.
+     */
+    isDisconnected(): boolean;
+    /**
+     * Returns the cause of the most recent drop, or `null` if the connection has
+     * not dropped. Clean follows a `disconnect` notification (loops keep running
+     * server-side); unclean is a read/write error or missed pong.
+     */
+    disconnectCause(): DisconnectCause | null;
+    private _lastCause;
+    /**
+     * Delivers the disconnect cause exactly once via the `'disconnected'` event.
+     * Safe to call from any path; subsequent calls are no-ops. Listeners receive
+     * the cause as the event argument.
+     */
+    private _signalDisconnect;
+    /**
+     * Re-dials the daemon and re-handshakes after a connection drop (RFC-450
+     * §8.3). Does not re-establish loop subscriptions; follow with
+     * `reattachAndProbe()` to resume a loop session. The caller should invoke
+     * this after the `'disconnected'` event fires. Reuses the same Client,
+     * resetting the drop signal and multiplexer.
+     *
+     * Performs bounded-retry backoff using the configured reconnect knobs.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Resumes an existing loop after a reconnect: issues `loop_reattach`,
+     * re-subscribes to `loop_events`, then runs a `loop_get` liveness probe to
+     * detect stale loops that accept the handshake but silently drop input.
+     * Returns a `StaleLoopError` when the probe fails; callers should fall back
+     * to a fresh `loop_new` bootstrap.
+     *
+     * Per RFC-629: connection-level readiness is the handshake's readiness_state
+     * (+ daemon_status); loop_get is a loop-scoped probe only, not a readiness
+     * probe.
+     */
+    reattachAndProbe(loopID: string): Promise<void>;
+    /** Send connection_init and wait for connection_ack with readiness "ready". */
+    private _performHandshake;
+    private _startHeartbeat;
+    private _stopHeartbeat;
+    private _heartbeatTick;
+    private _sleep;
     /** Serializes msg as JSON and sends it as a WebSocket text frame. */
     sendMessage(msg: unknown): Promise<void>;
+    /** Low-level send that does not reject on a missing connection (best-effort). */
+    private _sendRaw;
     /** Returns an async iterable of decoded messages. Ends when connection closes. */
     receiveMessages(signal?: AbortSignal): AsyncGenerator<DecodedMessage>;
     /** Reads a single event from the daemon. Returns null on connection close. */
     readEvent(): Promise<Record<string, unknown> | null>;
-    /** Reads a single event with a timeout. Returns null on timeout or connection close. */
+    /** Reads a single event with a timeout. Returns null on timeout or close. */
     readEventWithTimeout(timeout: number): Promise<Record<string, unknown> | null>;
-    /** Sends user input to the daemon (loop_input; requires loopID). */
+    /**
+     * Reads the next frame directly from the live socket (via a resolver),
+     * bypassing `messageBuffer`. Used by RPC waits so that stream events
+     * previously buffered for `readEvent()`/`receiveMessages()` consumers are
+     * not re-cycled through the RPC wait loop (which would stall behind a
+     * continuous subscription stream). Non-RPC frames read here are pushed to
+     * `messageBuffer` for the stream readers.
+     */
+    private readLiveEventWithTimeout;
+    /**
+     * Sends a `request` envelope and waits for the matching `response` (or
+     * `error`) correlated by `id` (RFC-450 §5/§9). Returns the `result` object.
+     *
+     * Multiplexer-aware (RFC-629 constraint #1): registers a pending RPC wait
+     * keyed by the request id so that, even when a `receiveMessages()` reader
+     * is concurrently active, the matching `response`/`error` is routed to
+     * this caller instead of being discarded or buffered behind a stream.
+     * Non-matching frames are routed to their own waiters by the multiplexer
+     * or flow on to the resolver queue for stream readers.
+     */
+    requestResponse(method: MethodName, params: Record<string, unknown>, responseType?: string, timeout?: number): Promise<Record<string, unknown>>;
+    /**
+     * Races the multiplexer's RPC promise against a timeout and the connection
+     * drop signal. Resolves with the `result` on `response`; rejects with a
+     * `DaemonError` on `error`; rejects with a timeout/close error otherwise.
+     * The disconnect listener is always removed to avoid accumulating handlers.
+     */
+    private _raceRPC;
+    /**
+     * Sends a pre-built envelope (e.g. `unsubscribe`) that carries an `id` and
+     * waits for the matching `response`/`error`. Used for envelope types that
+     * are not `request` (e.g. `unsubscribe` → `autopilot_unsubscribe`) but still
+     * expect a correlated response from the daemon.
+     */
+    private _requestResponseForEnvelope;
+    /** Sends a fire-and-forget `notification` envelope (no response expected). */
+    notify(method: MethodName, params: Record<string, unknown>): Promise<void>;
+    /**
+     * Starts a subscription stream. Returns the subscription `id` for later
+     * correlation and `unsubscribe()`. Stream events arrive as `next` frames
+     * carrying the same `id`.
+     */
+    subscribe(method: "loop_events" | "autopilot_events", params: Record<string, unknown>, timeout?: number): Promise<string>;
+    /** Cancels an active subscription by id. */
+    unsubscribe(subscriptionId: string): Promise<void>;
+    /**
+     * Reads the next stream event from a subscription. For `next` frames the
+     * `payload` is returned; for `complete`/`error` the full envelope is
+     * returned so the caller can inspect termination.
+     */
+    next(): Promise<Record<string, unknown> | null>;
+    /** Sends user input to the daemon (loop_input notification; requires loopID). */
     sendInput(text: string, options?: InputOptions): Promise<void>;
-    /** Sends a slash command to the daemon. */
+    /** Sends a slash command to the daemon (slash_command notification). */
     sendCommand(cmd: string): Promise<void>;
-    /** Requests the daemon to create a new AgentLoop. */
+    /** Requests the daemon to create a new StrangeLoop and waits for the response. */
     sendLoopNew(opts?: LoopNewOptions | string): Promise<void>;
-    /** Subscribes to events for a loop. */
-    sendLoopSubscribe(loopID: string, verbosity: string, streamDelivery?: 'batch' | 'streaming'): Promise<void>;
-    /** Detaches from a loop (keeps loop running). */
-    sendLoopDetach(loopID: string, requestID?: string): Promise<void>;
-    /** Notifies the daemon that this client is detaching. */
+    /** Subscribes to events for a loop (subscribe → loop_events). */
+    sendLoopSubscribe(loopID: string, verbosity: string, streamDelivery?: "batch" | "adaptive" | "streaming"): Promise<void>;
+    /** Detaches from a loop (unsubscribe by subscription id). */
+    sendLoopDetach(loopID: string): Promise<void>;
+    /** Notifies the daemon that this client is leaving (disconnect notification). */
     sendDetach(): Promise<void>;
-    /** Sends the daemon_ready handshake message. */
-    sendDaemonReady(): Promise<void>;
     /** Requests daemon status check. */
-    sendDaemonStatus(requestID?: string): Promise<void>;
+    sendDaemonStatus(): Promise<void>;
     /** Requests daemon shutdown. */
-    sendDaemonShutdown(requestID?: string): Promise<void>;
+    sendDaemonShutdown(): Promise<void>;
     /** Requests a config section from the daemon. */
-    sendConfigGet(section: string, requestID?: string): Promise<void>;
-    /** Requests the persisted loop list. */
-    sendLoopList(filter?: Record<string, unknown>, limit?: number, requestID?: string): Promise<void>;
-    /** Requests detailed loop metadata. */
-    sendLoopGet(loopID: string, verbose?: boolean, requestID?: string): Promise<void>;
-    /** Requests loop tree visualization. */
-    sendLoopTree(loopID: string, format?: string, requestID?: string): Promise<void>;
-    /** Requests pruning of old failed branches. */
-    sendLoopPrune(loopID: string, retentionDays?: number, dryRun?: boolean, requestID?: string): Promise<void>;
-    /** Requests loop deletion. */
-    sendLoopDelete(loopID: string, requestID?: string): Promise<void>;
-    /** Requests reattachment to a loop with history replay. */
-    sendLoopReattach(loopID: string, requestID?: string): Promise<void>;
-    /** Requests the skills catalog (RFC-400). */
-    sendSkillsList(requestID?: string): Promise<void>;
-    /** Requests the models catalog (RFC-400). */
-    sendModelsList(requestID?: string): Promise<void>;
-    /** Invokes a skill on the daemon (RFC-400). */
-    sendInvokeSkill(skill: string, args?: string, requestID?: string): Promise<void>;
-    /** Sends a request with a unique request_id and waits for a matching response. */
-    requestResponse(payload: Record<string, unknown>, responseType: string, timeout: number): Promise<Record<string, unknown>>;
+    sendConfigGet(section: string): Promise<void>;
     /** Requests the skills catalog and waits for the response. */
     listSkills(timeout?: number): Promise<Record<string, unknown>>;
     /** Requests the models catalog and waits for the response. */
     listModels(timeout?: number): Promise<Record<string, unknown>>;
-    /** Invokes a skill on the daemon host and receives echo (RFC-400). */
+    /** Invokes a skill on the daemon host and receives echo. */
     invokeSkill(skill: string, args?: string, timeout?: number): Promise<Record<string, unknown>>;
     /** Requests loop list and waits for response. */
-    listLoops(timeout?: number): Promise<Record<string, unknown>>;
+    listLoops(timeout?: number, workspace?: string): Promise<Record<string, unknown>>;
     /** Requests loop details and waits for response. */
     getLoop(loopID: string, timeout?: number): Promise<Record<string, unknown>>;
     /** Requests loop tree and waits for response. */
     getLoopTree(loopID: string, timeout?: number): Promise<Record<string, unknown>>;
     /** Requests loop deletion and waits for response. */
     deleteLoop(loopID: string, timeout?: number): Promise<Record<string, unknown>>;
-    /** Reads events until a daemon_ready with state == "ready". */
+    /** Requests persisted conversation/activity rows. */
+    sendLoopMessages(loopID: string, limit?: number, offset?: number, includeEvents?: boolean): Promise<void>;
+    /** Requests LangGraph checkpoint channel values. */
+    sendLoopStateGet(loopID: string): Promise<void>;
+    /** Applies partial checkpoint values. */
+    sendLoopStateUpdate(loopID: string, values: Record<string, unknown>, asNode?: string): Promise<void>;
+    /** Requests display card ledger snapshot. */
+    sendLoopCardsFetch(loopID: string): Promise<void>;
+    /** Requests the full loop history (RFC-631). */
+    sendLoopHistoryFetch(loopID: string): Promise<void>;
+    /** Requests MCP server status. */
+    sendMCPStatus(): Promise<void>;
+    /** Requests daemon config reload. */
+    sendConfigReload(): Promise<void>;
+    /** Submits credentials for daemon-side authentication. */
+    sendAuth(accessKey: string, secretKey: string): Promise<void>;
+    /** Refreshes the daemon-side auth token. */
+    sendAuthRefresh(refreshToken: string): Promise<void>;
+    /** Requests persisted messages and waits for response. */
+    getLoopMessages(loopID: string, limit?: number, offset?: number, includeEvents?: boolean, timeout?: number): Promise<Record<string, unknown>>;
+    /** Requests loop state and waits for response. */
+    getLoopState(loopID: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Updates loop state and waits for response. */
+    updateLoopState(loopID: string, values: Record<string, unknown>, asNode?: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Requests display cards and waits for response. */
+    fetchLoopCards(loopID: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Requests MCP status and waits for response. */
+    getMCPStatus(timeout?: number): Promise<Record<string, unknown>>;
+    /** Requests loop history and waits for response. */
+    fetchLoopHistory(loopID: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Requests daemon config reload and waits for response. */
+    reloadConfig(timeout?: number): Promise<Record<string, unknown>>;
+    /** Submits credentials for daemon-side authentication and waits for response. */
+    authenticate(accessKey: string, secretKey: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Refreshes the daemon-side auth token and waits for response. */
+    refreshAuthToken(refreshToken: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Creates an autopilot job and waits for the response. */
+    createJob(goal: string, verificationRules?: string, workspace?: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Queries job status and waits for the response. */
+    getJobStatus(jobId: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Pauses a running job. */
+    pauseJob(jobId: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Resumes a paused job. */
+    resumeJob(jobId: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Cancels a job. */
+    cancelJob(jobId: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Requests the DAG visualization for a job. */
+    getJobDag(jobId: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Sends guidance to a job or specific goal. */
+    sendJobGuidance(jobId: string, text: string, goalId?: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Subscribes to autopilot worker events. */
+    autopilotSubscribe(timeout?: number): Promise<string>;
+    /** Unsubscribes from autopilot worker events. */
+    autopilotUnsubscribe(timeout?: number): Promise<Record<string, unknown>>;
+    /** Creates a scheduled job from natural language. */
+    cronAdd(text: string, priority?: number, timeout?: number): Promise<Record<string, unknown>>;
+    /** Lists scheduled jobs. */
+    cronList(status?: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Shows a specific scheduled job. */
+    cronShow(jobId: string, timeout?: number): Promise<Record<string, unknown>>;
+    /** Cancels a scheduled job. */
+    cronCancel(jobId: string, timeout?: number): Promise<Record<string, unknown>>;
+    /**
+     * Waits for the connection_ack to report readiness (already done in
+     * connect(); kept for callers that reconnect manually). Resolves
+     * immediately if the handshake is already complete.
+     */
     waitForDaemonReady(timeout?: number): Promise<Record<string, unknown>>;
-    /** Waits for subscription confirmation matching loop id. */
-    waitForSubscriptionConfirmed(loopID: string, _verbosity: string, timeout?: number): Promise<void>;
 }
 
 /**
- * Convenience RPC helper functions for the Soothe client.
+ * Inbound-frame multiplexer for the protocol-1 client (RFC-629 constraint #1,
+ * RFC-450 §5.2/§5.5).
+ *
+ * Routes inbound protocol-1 frames to the correct waiter by `(type, id)`
+ * instead of discarding non-matching events. This makes the Client safe for
+ * concurrent RPCs and lets an active subscription stream coexist with RPC
+ * waits without starvation.
+ *
+ * Routing rules:
+ *   - `response`/`error` with `id` in pending RPCs   → pending RPC waiter
+ *   - `next`/`complete` with `id` in pending subs     → pending subscription waiter
+ *   - `receipt_response` with `receipt` in receipts   → receipt waiter
+ *   - everything else                                  → not consumed (flows to
+ *                                                          the application event
+ *                                                          stream / resolver queue)
+ *
+ * `ping`/`pong`/`connection_ack` are id-less lifecycle frames handled by the
+ * Client before reaching the multiplexer; the multiplexer leaves them
+ * un-consumed so the Client's existing handlers still see them.
+ *
+ * A frame routed to a waiter is consumed (returns `true`) and must NOT be
+ * forwarded to the resolver queue / event stream.
+ */
+/**
+ * Multiplexer holds pending RPC, subscription, and receipt waiters keyed by
+ * their correlation id. The Client consults `route()` for each inbound frame
+ * before pushing it to the resolver queue.
+ */
+declare class Multiplexer {
+    private rpcs;
+    private subs;
+    private receipts;
+    /**
+     * Installs a pending RPC wait keyed by `id`. Returns the pending call and an
+     * unregister function that MUST be called when the wait ends (success,
+     * timeout, or cancel) to avoid leaks. If a late response arrives after the
+     * caller has unregistered, it is dropped (log-and-drop) — no leak.
+     */
+    registerRPC(id: string): {
+        call: Promise<Record<string, unknown>>;
+        unregister: () => void;
+    };
+    /**
+     * Installs a pending subscription stream keyed by `id`. Returns the stream
+     * channel (an async-iterable-like push sink), a `done` signal, and an
+     * unregister function. The Client pushes `next`/`complete` frames via
+     * `push`; the application reads from the channel.
+     */
+    registerSubscription(id: string): {
+        push: (frame: Record<string, unknown>) => void;
+        done: Promise<void>;
+        unregister: () => void;
+    };
+    /**
+     * Installs a pending receipt wait keyed by `receipt`. Returns an unregister
+     * function.
+     */
+    registerReceipt(receipt: string): {
+        wait: Promise<Record<string, unknown>>;
+        unregister: () => void;
+    };
+    /**
+     * Wires a real sink for a registered subscription's `push`. Called by the
+     * Client right after `registerSubscription` to install the channel/queue the
+     * application reads from.
+     */
+    setSubscriptionSink(id: string, sink: (frame: Record<string, unknown>) => void): void;
+    /**
+     * Inspects one decoded frame, delivers it to a matching waiter if one
+     * exists, and returns `true` (consumed). Returns `false` for frames with no
+     * matching waiter — these flow on to the resolver queue / event stream.
+     * Safe to call from the message handler.
+     */
+    route(frame: Record<string, unknown>): boolean;
+    /** Reports whether an RPC waiter is registered for `id`. */
+    hasRPCWaiter(id: string): boolean;
+}
+
+/**
+ * Convenience RPC helper functions for the Soothe client (RFC-450 protocol-1).
  */
 
 /** Checks daemon status via RPC. */
 declare function checkDaemonStatus(client: Client, timeout?: number): Promise<Record<string, unknown>>;
-/** Performs a composite health check: connect + status RPC. */
+/** Performs a composite health check: connect + handshake + status RPC. */
 declare function isDaemonLive(wsURL: string, timeout?: number): Promise<boolean>;
 /** Requests daemon shutdown via RPC. */
 declare function requestDaemonShutdown(client: Client, timeout?: number): Promise<void>;
@@ -478,20 +802,526 @@ declare function requestDaemonShutdown(client: Client, timeout?: number): Promis
 declare function fetchSkillsCatalog(client: Client, timeout?: number): Promise<Record<string, unknown>[]>;
 /** Fetches a daemon config section via RPC. */
 declare function fetchConfigSection(client: Client, section: string, timeout?: number): Promise<Record<string, unknown>>;
+/** Requests daemon config reload via RPC. */
+declare function requestDaemonConfigReload(client: Client, timeout?: number): Promise<Record<string, unknown>>;
+/** Requests loop history (RFC-631) and waits for the response. */
+declare function fetchLoopHistory(client: Client, loopID: string, timeout?: number): Promise<Record<string, unknown>>;
+/** Submits credentials for daemon-side authentication and waits for the response. */
+declare function authenticate(client: Client, accessKey: string, secretKey: string, timeout?: number): Promise<Record<string, unknown>>;
+/** Refreshes the daemon-side auth token and waits for the response. */
+declare function refreshAuthToken(client: Client, refreshToken: string, timeout?: number): Promise<Record<string, unknown>>;
 
 /**
- * Session bootstrap flows, wait helpers, and connect-with-retries.
+ * loop_new (or reuse id) → subscribe(loop_events); returns the loop id.
+ * The protocol-1 handshake is assumed to have completed in `client.connect()`.
  */
-
-/** Daemon ready → loop_new (or reuse id) → loop_subscribe; returns loop id. */
 declare function bootstrapLoopSession(client: Client, resumeLoopId: string | null | undefined, config?: Config, loopNew?: LoopNewOptions): Promise<string>;
-/** Blocks until a daemon_ready message with state == "ready". */
+/**
+ * Blocks until connection_ack reports readiness "ready". Resolves immediately
+ * if the handshake already completed during connect().
+ */
 declare function waitDaemonReady(client: Client, timeout: number): Promise<void>;
-/** Waits for a status message with a non-empty ``loop_id``. */
-declare function waitLoopStatusWithID(client: Client, timeout: number): Promise<StatusResponse>;
-/** Waits for subscription_confirmed or loop_subscribe_response matching loop id. */
+/** Waits for a status message with a non-empty loop_id. */
+declare function waitLoopStatusWithID(client: Client, timeout: number): Promise<Record<string, unknown>>;
+/** Waits for a subscription confirmation `next` matching loop id. */
 declare function waitSubscriptionConfirmed(client: Client, wantLoopID: string, _wantVerbosity: string, timeout: number): Promise<void>;
 /** Attempts to connect to the Soothe daemon with bounded retries. */
 declare function connectWithRetries(client: Client, maxRetries?: number, retryDelay?: number): Promise<void>;
 
-export { type BaseMessage, Client, type CommandMessage, type Config, type ConfigGetMessage, ConnectionError, DaemonError, type DaemonReadyResponse, type DaemonShutdownMessage, type DaemonStatusMessage, type DaemonStatusResponse, type DecodedMessage, type DetachMessage, ESSENTIAL_EVENT_TYPES, type ErrorResponse, EventAgentLoopCompleted, EventAgentLoopIterated, EventAgentLoopReasoned, EventAgentLoopStarted, EventExploreCompleted, EventExploreMilestone, EventExploreStarted, EventExploreStepCompleted, EventFinalReport, EventGeneralFailed, EventLoopReattachedWire, type EventMessage, EventMessageReceived, EventMessageSent, EventPlanCreated, EventReplayComplete, EventStreamToolCallUpdate, EventTacitusCompleted, EventTacitusGatherSummary, EventTacitusStarted, EventToolCallUpdatesBatch, EventToolCompleted, EventToolError, EventToolStarted, type HistoryReplayCompleteMessage, type HistoryReplayMessage, type InputOptions, type InvokeSkillMessage, type LoopDeleteMessage, type LoopDeleteResponse, type LoopDetachMessage, type LoopDetachResponse, type LoopGetMessage, type LoopGetResponse, type LoopInputMessage, type LoopListMessage, type LoopListResponse, type LoopNewMessage, type LoopNewOptions, type LoopNewResponse, type LoopPruneMessage, type LoopPruneResponse, type LoopReattachMessage, type LoopReattachResponse, type LoopSubscribeMessage, type LoopSubscribeResponse, type LoopTreeMessage, type LoopTreeResponse, type ModelsListMessage, type ModelsListResponse, type ShutdownAckResponse, type SkillsListMessage, type SkillsListResponse, type StatusResponse, type SubscriptionConfirmedResponse, TimeoutError, type VerbosityLevel, VerbosityTier, bootstrapLoopSession, checkDaemonStatus, classifyEventVerbosity, connectWithRetries, decodeMessage, defaultConfig, encodeMessage, extractSootheLoopID, fetchConfigSection, fetchSkillsCatalog, isCompletionEvent, isDaemonLive, isSubagentProgressEvent, isValidVerbosityLevel, loadConfigFromEnv, newLoopInputMessage, newLoopNewMessage, newLoopSubscribeMessage, newRequestID, parseNamespace, requestDaemonShutdown, shouldShow, splitWirePayload, waitDaemonReady, waitLoopStatusWithID, waitSubscriptionConfirmed };
+/**
+ * Persistence seam for appkit (RFC-629 Layer 1).
+ *
+ * SessionStore abstracts per-application storage: the session↔loop-id mapping
+ * that ConnectionPool consults to decide bootstrap vs reattach, and the
+ * message rows TurnRunner writes back when a turn completes. Applications
+ * implement this against their own store (Postgres, Redis, in-memory, …).
+ *
+ * Implementations must be safe for concurrent use.
+ */
+/** Persisted mapping between an application session id and the daemon loop id. */
+interface SessionEntry {
+    workspaceID: string;
+    sessionID: string;
+    loopID: string;
+    /** App-defined taxonomy (e.g. "primary" | "ephemeral"). */
+    sessionType: string;
+    /** Optional app key for ephemeral internal features. */
+    purpose?: string;
+    isActive: boolean;
+    resetCount: number;
+    lastUsedAt: number;
+}
+/** A persisted message row (assistant reply or error). */
+interface SessionMessage {
+    id?: string;
+    /** "assistant" | "user" | "error". */
+    role: string;
+    content: string;
+    context?: unknown;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Persistence seam between appkit and the application's storage backend.
+ *
+ * ConnectionPool consults the store to decide whether to bootstrap a fresh
+ * loop (no loop id on file) or reattach to an existing one, and records the
+ * loop id once bootstrapped. TurnRunner persists the final assistant reply
+ * and error rows via appendMessage.
+ */
+interface SessionStore {
+    /** Returns the persisted entry for sessionID, or null if no record exists. */
+    getSession(sessionID: string): Promise<SessionEntry | null>;
+    /** Persists a new session↔loop mapping. */
+    createSession(workspaceID: string, sessionID: string, loopID: string, sessionType: string): Promise<void>;
+    /** Stamps the session's last-used timestamp. */
+    updateLastUsed(sessionID: string): Promise<void>;
+    /** Bumps the reset counter (used to decide fresh bootstrap vs reattach). */
+    incrementResetCount(sessionID: string): Promise<void>;
+    /**
+     * Returns the daemon loop id for sessionID and whether one is on file.
+     * ok===false triggers a fresh loop_new bootstrap.
+     */
+    getLoopIDForSession(sessionID: string): Promise<{
+        loopID: string;
+        ok: boolean;
+    }>;
+    /** Writes a message row (assistant reply, error, etc.) for the session. */
+    appendMessage(sessionID: string, message: SessionMessage): Promise<void>;
+}
+
+/**
+ * SSE-style pub/sub fan-out for appkit (RFC-629 Layer 1).
+ *
+ * Generic, string-keyed pub/sub for SSE-style event delivery. The
+ * application-agnostic successor to a domain-keyed broadcaster: applications
+ * convert from their domain key type to `string` at their own boundary.
+ *
+ * Slow consumers do not stall the broadcaster: each subscriber has a bounded
+ * queue and overflowing events are dropped (drop-on-full).
+ */
+/** One Server-Sent Event payload. The Type vocabulary is app-defined. */
+interface SSEEvent {
+    type: string;
+    data: unknown;
+}
+/**
+ * SSEBroadcaster fans events out to all subscribers for a session id.
+ * Non-blocking: a full subscriber queue drops the event so one slow consumer
+ * cannot block the others.
+ */
+declare class SSEBroadcaster {
+    private subscribers;
+    private nextSubID;
+    /** Creates an empty broadcaster. */
+    constructor();
+    /**
+     * Registers a new subscriber channel for a session id. Returns an async
+     * iterable the subscriber reads events from. Unsubscribe via
+     * `unsubscribe()` or `close()`.
+     */
+    subscribe(sessionID: string): {
+        iterable: AsyncIterable<SSEEvent>;
+        id: string;
+    };
+    /** Removes a subscriber by id and closes its iterable. Safe if unknown. */
+    unsubscribe(sessionID: string, subID: string): void;
+    /**
+     * Sends an event to all subscribers for a session id. Non-blocking: a full
+     * subscriber queue is skipped (drop-on-full) so one slow consumer cannot
+     * block the others.
+     */
+    broadcast(sessionID: string, event: SSEEvent): void;
+    /** Closes all subscribers for a session id and removes the entry. */
+    close(sessionID: string): void;
+    /** Closes every subscriber channel across all sessions. */
+    closeAll(): void;
+}
+
+/**
+ * Thinking-step extraction for appkit (RFC-629 Layer 1).
+ *
+ * Maps an allowlisted progress event to one structured UI line. Free-form
+ * streams (tokens, reports, reasoning) are excluded. Ported from the Go
+ * appkit's thinking_step with the allowlist made configurable.
+ */
+/** Default thinking-step event allowlist (triarch's set). */
+declare const DEFAULT_THINKING_STEP_EVENTS: ReadonlySet<string>;
+/**
+ * Maps an allowlisted progress event to one structured UI line. Returns
+ * [line, true] for a recognized event; ["", false] otherwise. `allow` may be
+ * omitted to use the default allowlist.
+ */
+declare function extractThinkingStep(eventType: string, data: Record<string, unknown> | null, allow?: ReadonlySet<string>): [string, boolean];
+
+/**
+ * Event classifier for appkit (RFC-629 Layer 1).
+ *
+ * Maps a stream of decoded daemon events into deliverable/streaming/terminal
+ * outcomes, keyed on (namespace, mode, phase) per RFC-614/RFC-403
+ * (RFC-629 constraint #4). The app-agnostic successor to triarch's
+ * ProcessChatEvent, with the deliverable phase set promoted from hardcoded
+ * constants to configuration.
+ *
+ * Event shape: a protocol-1 `next` envelope carries
+ * `{type:"next", payload:{namespace, mode, data, loop_id}}`. The daemon
+ * wraps legacy free-form frames as `{payload:{namespace, mode:<orig type>,
+ * data:<orig frame>}}` (RFC-450 §9.3). The classifier inspects the payload's
+ * `mode`/`data`/`namespace` and the inner message's `phase`/`type`/`content`.
+ */
+
+/** How a processed event should end the query loop. */
+declare enum ChatEventTerminal {
+    /** Accumulate content; the query is still running. */
+    Continue = 0,
+    /** A user-visible final reply; persist it. */
+    DeliverableComplete = 1,
+    /** The query failed; persist an error. */
+    FailedComplete = 2
+}
+/** The structured outcome of classifying one daemon event. */
+interface ChatEventResult {
+    content?: string;
+    /** User-visible progress line (not a final reply). */
+    thinkingStep?: string;
+    terminal: ChatEventTerminal;
+    /** soothe wire event type when terminal === DeliverableComplete. */
+    completionEvent?: string;
+    err?: Error;
+}
+/**
+ * Product-specific decisions an EventClassifier needs. The DeliverablePhases
+ * set is the key product knob: which message `phase` values count as
+ * user-facing deliverables (triarch uses quiz, goal_completion, direct_model, and
+ * direct intent_hint phases text_completion, image_to_text, ocr, embed;
+ * other apps pass their own).
+ */
+interface ClassifierConfig {
+    /** Recognizes loop-tagged message phases that may end a query with
+     * user-facing text. Required. */
+    deliverablePhases: ReadonlySet<string>;
+    /** Minimum trimmed rune count for a reply to be persisted as final
+     * (avoids finishing on stub ACKs like "..."). Defaults to 8. */
+    minDeliverableRunes?: number;
+    /** Optional app override of the default thinking-step event allowlist. */
+    thinkingStepEvents?: ReadonlySet<string>;
+}
+/** Maps a stream of decoded daemon events into deliverable/streaming/terminal outcomes. */
+declare class EventClassifier {
+    private deliverablePhases;
+    private minDeliverableRunes;
+    private thinkingStepEvents?;
+    constructor(cfg: ClassifierConfig);
+    /**
+     * Inspects one decoded event and returns its outcome. `accumulated` is the
+     * running assistant text so far, used to pick the final reply when a
+     * deliverable event arrives.
+     */
+    classify(msg: unknown, accumulated: string): ChatEventResult;
+    /**
+     * Reports whether a persisted completion_event is user-facing. Uses the
+     * configured deliverable phase set; recognizes the protocol output namespace
+     * and final_report component as deliverable.
+     */
+    isDeliverableCompletionEvent(eventType: string): boolean;
+    isDeliverableLoopPhase(phase: string): boolean;
+    private deliverableResult;
+    private continueResult;
+    private failedResult;
+    /** Reports whether trimmed assistant text is long enough to persist as final. */
+    isSubstantiveAssistantReply(content: string): boolean;
+    /**
+     * Picks the user-visible reply for a completed query. Only a deliverable
+     * terminal result with a recognized completion event yields a final reply.
+     */
+    resolveDeliverableFinalContent(eventResult: ChatEventResult, _accumulated: string): [string, boolean];
+    /** The event→outcome mapper, ported from triarch's ProcessChatEvent. */
+    private processChatEvent;
+    /** Classifies a `next` envelope by projecting its payload. */
+    private classifyNextEnvelope;
+    /**
+     * Classifies an event payload by (namespace, mode, phase). `data` may be a
+     * map or an array of messages (mode="messages").
+     */
+    private classifyEventPayload;
+    /** Classifies a mode="messages" payload (array of message objects). */
+    private classifyMessagesMode;
+    /**
+     * Extracts plain assistant text from mode="messages" events that carry a
+     * terminal AIMessage without loop-tagged phase metadata (legacy direct_llm turns
+     * before phase tagging; prefer deliverablePhases including text_completion).
+     */
+    private messagesModeAssistantContent;
+    /** soothe output/responded events that carry user-facing final text. */
+    private isFinalOutputEvent;
+}
+
+/**
+ * Single-flight query gate for appkit (RFC-629 Layer 1).
+ *
+ * Enforces single-flight query execution per session id and the
+ * cancel-before-context ordering: when a query is cancelled, the daemon is
+ * told to stop (command_request{command:"cancel"}) BEFORE the local abort
+ * signal is cancelled, on a detached timeout so the caller's cancellation
+ * cannot block the wire send.
+ *
+ * The app-agnostic successor to triarch's AcquireQuery/CancelQuery/
+ * sendLoopCancelCommand.
+ */
+/** Returned when a session already has an in-flight query. */
+declare class ErrQueryBusy extends Error {
+    constructor();
+}
+/**
+ * QueryGate enforces single-flight query execution per session id.
+ */
+declare class QueryGate {
+    private active;
+    /** Constructs an empty gate. */
+    constructor();
+    /**
+     * Reserves sessionID for one agent turn. Returns ErrQueryBusy if a query is
+     * already in flight. `abort` is the AbortController for the query's timeout
+     * context. `sendCancel` is the daemon-cancel sender; it is invoked from
+     * `cancel()` on a detached 10s timeout.
+     */
+    acquire(sessionID: string, abort: AbortController, sendCancel: ((signal: AbortSignal) => Promise<void>) | null): void;
+    /**
+     * Cooperatively stops a running query for sessionID. Sends the daemon cancel
+     * (on a detached 10s-timeout abort so caller cancellation cannot block the
+     * wire send) BEFORE aborting the local context. Returns silently if no query
+     * is in flight (intent already satisfied).
+     */
+    cancel(sessionID: string): Promise<void>;
+    /**
+     * Clears the gate for sessionID without sending a daemon cancel. Call when a
+     * query completes normally (success or local failure) so the next turn can
+     * acquire.
+     */
+    release(sessionID: string): void;
+    /** Reports whether a query is in flight for sessionID. */
+    isActive(sessionID: string): boolean;
+}
+
+/**
+ * ManagedClient — the subset of the core Client that appkit's ConnectionPool
+ * and TurnRunner depend on (RFC-629 Layer 1).
+ *
+ * The concrete `Client` satisfies it; tests supply a fake. Defining it as an
+ * interface lets appkit be unit-tested without a live WebSocket daemon.
+ */
+
+/**
+ * ManagedClient is the subset of the core Client that appkit depends on.
+ * Methods are async (TS) rather than channel-based (Go).
+ */
+interface ManagedClient {
+    /** Dials and handshakes. */
+    connect(): Promise<void>;
+    /** Re-dials after a drop. */
+    reconnect(): Promise<void>;
+    /** Resumes a loop by id and probes liveness. */
+    reattachAndProbe(loopID: string): Promise<void>;
+    /** Sends a fire-and-forget notification (e.g. loop_input). */
+    sendMessage(msg: unknown): Promise<void>;
+    /** Sends user input to the daemon (loop_input notification). */
+    sendInput(text: string, options?: InputOptions): Promise<void>;
+    /** Starts the read loop, returning the event stream. */
+    receiveMessages(signal?: AbortSignal): AsyncGenerator<DecodedMessage>;
+    /** Returns whether the connection has dropped. */
+    isDisconnected(): boolean;
+    /** Returns the drop cause, or null if not dropped. */
+    disconnectCause(): DisconnectCause | null;
+    /** Reports connection liveness. */
+    isConnected(): boolean;
+    /** Tears down the connection. */
+    close(): void;
+}
+/**
+ * Builds a fresh ManagedClient for a daemon URL and config. ConnectionPool
+ * calls it per pooled connection. Applications may supply a custom factory
+ * (e.g. wrapping Client with logging/metrics).
+ */
+type ClientFactory = (url: string, config?: Config) => ManagedClient;
+/** Returns a ClientFactory that builds a core Client. */
+declare function defaultClientFactory(): ClientFactory;
+/**
+ * Creates a new loop (loop_new + subscribe) on a connected client and returns
+ * the new loop id. The default implementation calls bootstrapLoopSession;
+ * apps may override it.
+ */
+type BootstrapFunc = (client: ManagedClient, workspaceID: string, userID: string, config?: Config) => Promise<string>;
+/** Default bootstrap: loop_new + subscribe(loop_events). */
+declare function defaultBootstrapFunc(): BootstrapFunc;
+
+/**
+ * Per-session connection pool for appkit (RFC-629 Layer 1).
+ *
+ * Manages a pool of daemon connections, one active per session. Reuses an
+ * active connection when still live, otherwise bootstraps a fresh loop
+ * (loop_new + subscribe) or reattaches an existing one (loop_reattach +
+ * subscribe + reattachAndProbe). Persistence of session↔loop mappings is
+ * abstracted behind SessionStore.
+ *
+ * The app-agnostic successor to triarch's SoothePoolManager connection
+ * mechanics.
+ */
+
+/** Returned when no free connection slot is available. */
+declare class ErrPoolExhausted extends Error {
+    constructor();
+}
+/** Configures a ConnectionPool. Zero values use defaults. */
+interface PoolConfig {
+    poolSize: number;
+    queryTimeout: number;
+    connectionTimeout: number;
+    maxIdleTime: number;
+    healthCheckInterval: number;
+}
+/** Returns env-overridable defaults (mirrors triarch). */
+declare function defaultPoolConfig(): PoolConfig;
+/** One connection slot in the pool. */
+declare class PooledConn {
+    slotID: number;
+    client: ManagedClient;
+    eventStream: AsyncGenerator<DecodedMessage> | null;
+    streamController: AbortController | null;
+    sessionID: string;
+    loopID: string;
+    workspaceID: string;
+    lastUsed: number;
+    constructor(slotID: number, client: ManagedClient);
+    /** Reports whether the underlying client signalled a drop. */
+    isDisconnected(): boolean;
+    isConnected(): boolean;
+    getLoopID(): string;
+}
+/**
+ * ConnectionPool manages a pool of daemon connections, one active per session.
+ */
+declare class ConnectionPool {
+    private cfg;
+    private scfg;
+    private factory;
+    private bootstrap;
+    private store;
+    private pool;
+    private activeSlots;
+    private nextSlotID;
+    private url;
+    /**
+     * Constructs a pool. `url` is the daemon WebSocket URL. If cfg is null,
+     * defaultPoolConfig is used; if scfg is null, defaultConfig is used; nil
+     * factory/bootstrap fall back to the defaults.
+     */
+    constructor(url: string, store: SessionStore, cfg?: PoolConfig | null, scfg?: Config | null, factory?: ClientFactory | null);
+    /** Overrides the loop bootstrap function (useful for test fakes). */
+    withBootstrap(f: BootstrapFunc): ConnectionPool;
+    /**
+     * Returns a live connection for sessionID, reusing an active slot or
+     * bootstrapping/reattaching as needed. The caller must call `release()`
+     * when done with the connection (a turn completes or the session is reset).
+     */
+    acquire(sessionID: string, workspaceID: string, userID: string, _signal?: AbortSignal): Promise<PooledConn>;
+    /** Tears down the connection for sessionID and returns the slot. */
+    release(sessionID: string): Promise<void>;
+    /**
+     * Tears down the connection for sessionID so the next acquire bootstraps
+     * fresh. The store should archive the loop id so getLoopIDForSession returns
+     * false next time.
+     */
+    resetSession(sessionID: string): Promise<void>;
+    /** Gracefully shuts down all active connections. */
+    stop(): void;
+    /** Stats snapshot for observability. */
+    stats(): {
+        active: number;
+        idle: number;
+    };
+    /** Bootstrap a fresh loop and start the reader. */
+    private bootstrapNew;
+    /** Reconnect + reattach an existing loop, then start the reader. */
+    private resumeAndReattach;
+    /** Starts a receiveMessages generator and stores the stream + controller. */
+    private startReader;
+}
+
+/**
+ * Turn runner for appkit (RFC-629 Layer 1).
+ *
+ * Executes one query turn end-to-end: acquire a pooled connection, enforce
+ * single-flight, send loop_input, consume the event stream, classify events,
+ * resolve the deliverable, persist the reply, and broadcast completion.
+ *
+ * The app-agnostic successor to triarch's ExecuteQuery.
+ */
+
+/** Returned when a turn exceeds the configured timeout. */
+declare class ErrQueryTimeout extends Error {
+    constructor();
+}
+/** Configures a TurnRunner. */
+interface TurnConfig {
+    /** Per-turn deadline in ms. Defaults to 30m. */
+    queryTimeout: number;
+}
+/** Carries optional daemon hints on a loop_input payload. */
+interface InputOpts {
+    intentHint?: LoopInputIntentHint;
+    preferredSubagent?: string;
+    responseSchema?: Record<string, unknown>;
+    responseSchemaName?: string;
+    responseSchemaStrict?: boolean;
+}
+/** Optional attachment shape (IG-327: {mime_type, data(base64)}). */
+type Attachment = Record<string, unknown>;
+/**
+ * Builds a loop_input payload with optional attachments. Apps build this from
+ * their product modes (e.g. triarch's ask/agent/deep-research).
+ */
+declare function inputMessageForLoop(text: string, loopID: string, attachments?: Attachment[], opts?: InputOpts): Record<string, unknown>;
+/** Completion hook signature. */
+type OnComplete = (sessionID: string, loopID: string, content: string, completionEvent: string, elapsedMs: number) => void;
+/** Error hook signature. */
+type OnError = (sessionID: string, loopID: string, err: Error) => void;
+/**
+ * TurnRunner executes one query turn end-to-end.
+ */
+declare class TurnRunner {
+    private pool;
+    private gate;
+    private classifier;
+    private store;
+    private broadcaster;
+    private cfg;
+    private buildInput;
+    private onComplete;
+    private onError;
+    /**
+     * Constructs a TurnRunner. pool, gate, classifier, and store are required;
+     * broadcaster may be null.
+     */
+    constructor(pool: ConnectionPool, gate: QueryGate, classifier: EventClassifier, store: SessionStore, broadcaster: SSEBroadcaster | null, cfg: TurnConfig);
+    /** Overrides the loop_input payload builder. */
+    withInputBuilder(f: typeof inputMessageForLoop): TurnRunner;
+    /** Sets a completion hook (runs inline on success). */
+    withOnComplete(f: OnComplete): TurnRunner;
+    /** Sets an error hook (runs inline on failure). */
+    withOnError(f: OnError): TurnRunner;
+    /**
+     * Runs one query turn. The response is broadcast via the SSE broadcaster and
+     * persisted via the SessionStore; it is not returned to the caller (SSE
+     * subscribers receive it). Resolves on success; rejects on failure
+     * (ErrQueryTimeout, AbortError, or a daemon/processing error).
+     */
+    execute(sessionID: string, message: string, userID: string, workspaceID: string, attachments: Attachment[] | null, opts: InputOpts | null, signal?: AbortSignal): Promise<void>;
+    /** Asks the daemon to cooperatively stop the loop runner on a detached signal. */
+    private sendLoopCancel;
+    private persistResponse;
+    private persistFailed;
+    private broadcastThinkingStep;
+    private broadcastComplete;
+    private broadcastError;
+}
+
+export { type Attachment, type BaseEnvelope, type BootstrapFunc, CLIENT_VERSION, type ChatEventResult, ChatEventTerminal, type ClassifierConfig, Client, type ClientFactory, type CompleteEnvelope, type Config, type ConnectionAckEnvelope, ConnectionError, type ConnectionInitEnvelope, ConnectionPool, DEFAULT_CLIENT_CAPABILITIES, DEFAULT_DELIVERABLE_PHASES, DEFAULT_THINKING_STEP_EVENTS, DaemonError, type DecodedMessage, DisconnectCause, type DisconnectEnvelope, ErrPoolExhausted, ErrQueryBusy, ErrQueryTimeout, type ErrorEnvelope, EventAutopilotGoalCompleted, EventAutopilotGoalCreated, EventAutopilotGoalProgress, EventAutopilotGoalStatus, EventAutopilotWorkerAssigned, EventAutopilotWorkerUnassigned, EventCardCreated, EventCardReplayBegin, EventCardReplayEnd, EventClassifier, EventExploreCompleted, EventExploreMilestone, EventExploreStarted, EventExploreStepCompleted, EventFinalReport, EventGeneralFailed, EventLoopReattachedWire, EventMessageReceived, EventMessageSent, EventPlanCreated, EventReplayComplete, EventStrangeLoopCompleted, EventStrangeLoopContextCompacted, EventStrangeLoopPlanDecision, EventStrangeLoopReasoned, EventStrangeLoopStarted, EventStrangeLoopStepCompleted, EventStrangeLoopStepQueued, EventStrangeLoopStepStarted, EventStreamToolCallUpdate, EventTacitusCompleted, EventTacitusGatherSummary, EventTacitusStarted, EventToolCallUpdatesBatch, EventToolCompleted, EventToolError, EventToolStarted, INTENT_HINT_EMBED, INTENT_HINT_IMAGE_TO_TEXT, INTENT_HINT_OCR, INTENT_HINT_TEXT_COMPLETION, type InputOptions, type InputOpts, type IntentHint, LOOP_ASSISTANT_OUTPUT_PHASES, type LoopAssistantOutputPhase, type LoopInputIntentHint, type LoopInputParams, type LoopNewOptions, type ManagedClient, type MessageType, type MethodName, Multiplexer, type NegotiatedCapabilities, type NextEnvelope, type NotificationEnvelope, type OnComplete, type OnError, PROTO_VERSION, type PingEnvelope, type PongEnvelope, type PoolConfig, PooledConn, QueryGate, REMOVED_INTENT_HINTS, type ReceiptResponseEnvelope, ReconnectError, type RemovedIntentHint, type RequestEnvelope, type ResponseEnvelope, SSEBroadcaster, type SSEEvent, type SessionEntry, type SessionMessage, type SessionStore, StaleLoopError, type StatusFrame, type StreamEventPayload, type SubscribeEnvelope, TimeoutError, type TurnConfig, TurnRunner, type UnsubscribeEnvelope, type VerbosityLevel, VerbosityTier, authenticate, bootstrapLoopSession, checkDaemonStatus, classifyEventVerbosity, connectWithRetries, connectionInitEnvelope, decodeMessage, defaultBootstrapFunc, defaultClientFactory, defaultConfig, defaultPoolConfig, disconnectCauseName, disconnectEnvelope, encodeMessage, extractSootheLoopID, extractThinkingStep, fetchConfigSection, fetchLoopHistory, fetchSkillsCatalog, inputMessageForLoop, isCompletionEvent, isDaemonLive, isSubagentProgressEvent, isValidVerbosityLevel, loadConfigFromEnv, newLoopInputMessage, newLoopNewMessage, newLoopSubscribeMessage, newRequestID, notificationEnvelope, parseNamespace, pingEnvelope, pongEnvelope, refreshAuthToken, requestDaemonConfigReload, requestDaemonShutdown, requestEnvelope, shouldShow, splitWirePayload, subscribeEnvelope, unsubscribeEnvelope, validateLoopInputIntentHint, waitDaemonReady, waitLoopStatusWithID, waitSubscriptionConfirmed };