@mirasoth/soothe-client 0.1.0 → 0.4.0

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.4.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,331 @@ 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 inboundMaxSize;
+    private inboundDroppedCount;
+    private onStreamDegraded;
     private resolvers;
+    private handshakeComplete;
+    private negotiatedCapabilities;
+    private protocolVersion;
+    private readinessState;
+    private heartbeatIntervalMs;
+    private heartbeatTimer;
+    private lastPongMonotonic;
+    private disconnFired;
+    private mux;
+    private deliveryRecvSeq;
+    private deliveryAckedSeq;
     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). */
+    /**
+     * Remove stale handshake/terminal frames left in `messageBuffer` before a turn.
+     * Returns labels of removed frames (in order).
+     */
+    peelStalePendingControlEvents(): string[];
+    /** True when the underlying socket is still open (may not be handshaked). */
+    isConnectionAlive(): boolean;
+    /** Override pending buffer cap (tests / tuning). */
+    setInboundMaxSize(n: number): void;
+    /** How many NORMAL-priority frames were dropped under backpressure. */
+    inboundDropped(): number;
+    /** Hook invoked on the first inbound overflow drop. */
+    setStreamDegradedCallback(fn: ((dropped: number, reason: string) => void) | null): void;
+    private enqueueMessageBuffer;
+    private noteInboundDrop;
+    /**
+     * 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>;
+    private _trackInboundDeliveryAck;
+    private _sendDeliveryAck;
+    /**
+     * 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.
+ * Ephemeral one-shot RPC client for jobs / cron / autopilot.
+ * Mirrors Python AsyncCommandClient / CommandClient (RFC-629 / IG-662).
+ */
+
+declare class CommandClient {
+    readonly url: string;
+    readonly timeoutMs: number;
+    private readonly config;
+    constructor(url: string, opts?: {
+        timeoutMs?: number;
+        config?: Config;
+    });
+    private withClient;
+    /** Generic one-shot RPC. */
+    request(method: MethodName, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    jobCreate(goal: string, workspace?: string): Promise<Record<string, unknown>>;
+    jobStatus(jobId: string): Promise<Record<string, unknown>>;
+    jobCancel(jobId: string): Promise<Record<string, unknown>>;
+    cronAdd(text: string, priority?: number): Promise<Record<string, unknown>>;
+    cronList(status?: string): Promise<Record<string, unknown>>;
+}
+
+/**
+ * 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 +768,729 @@ 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>>;
+/** Fetch bound display-card snapshot for a loop. */
+declare function fetchLoopCards(client: Client, loopID: string, timeout?: number): Promise<Record<string, unknown>>;
+/** Fetch persisted conversation/activity rows for a loop. */
+declare function fetchLoopMessages(client: Client, loopID: string, opts?: {
+    limit?: number;
+    offset?: number;
+    includeEvents?: boolean;
+    timeout?: number;
+}): Promise<Record<string, unknown>>;
 /**
- * Session bootstrap flows, wait helpers, and connect-with-retries.
+ * Connect, handshake, and yield a ready Client. Always closes in finally.
  */
+declare function connectedWebsocket<T>(wsUrl: string, fn: (client: Client) => Promise<T>, timeoutMs?: number): Promise<T>;
+/**
+ * One-shot protocol-1 RPC / notify / subscribe with dict-style error contract.
+ * Callers check `if ("error" in response)`.
+ */
+declare function protocol1Rpc(wsUrl: string, method: string, params?: Record<string, unknown> | null, opts?: {
+    mode?: "request" | "notify" | "subscribe";
+    timeoutMs?: number;
+}): Promise<Record<string, unknown>>;
 
-/** Daemon ready → loop_new (or reuse id) → loop_subscribe; returns loop id. */
+/**
+ * loop_new (or reuse id) → subscribe(loop_events); returns the loop id.
+ * The protocol-1 handshake is assumed to have completed in `client.connect()`.
+ */
 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 };
+/**
+ * Shared stream/turn terminal frame helpers for Client and DaemonSession.
+ *
+ * Keeps peel-at-turn-start and turn-end detection on one vocabulary so leftover
+ * prior-goal terminals cannot blank the next query.
+ */
+/** Daemon turn-scoped stream end custom type. */
+declare const STREAM_END = "soothe.stream.end";
+/** True when `data` is a turn-scoped terminal custom payload. */
+declare function isTurnEndCustomData(data: unknown): data is Record<string, unknown>;
+/**
+ * True when a chunk proves the active turn has non-intake progress.
+ * Used so late prior-goal stream.end cannot close a turn that has only seen
+ * intake lifecycle (e.g. plan.phase).
+ */
+declare function isTurnProgressChunk(mode: string, data: unknown): boolean;
+/** True when the client should bump delivery_ack sequence for this frame. */
+declare function inboundNeedsDeliveryAck(event: Record<string, unknown>): boolean;
+
+/**
+ * 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>;
+    /**
+     * When true, a status frame with state=idle and non-empty accumulated
+     * assistant text is DeliverableComplete (typical for direct-model turns).
+     * Default false keeps Continue-on-status behaviour.
+     */
+    treatStatusIdleAsComplete?: boolean;
+}
+/** Maps a stream of decoded daemon events into deliverable/streaming/terminal outcomes. */
+declare class EventClassifier {
+    private deliverablePhases;
+    private minDeliverableRunes;
+    private thinkingStepEvents?;
+    private treatStatusIdleAsComplete;
+    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;
+/**
+ * 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>;
+
+/**
+ * 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).
+ * `maxIdleTime` is enforced on acquire; `healthCheckInterval` is reserved. */
+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;
+}
+
+/**
+ * Attachment image compaction for appkit (Go IG-651 / SIL-04 parity).
+ *
+ * When `sharp` is installed (optionalDependency), oversized image/* payloads
+ * are downscaled. Without sharp, attachments pass through unchanged.
+ */
+interface CompactImageOptions {
+    /** Max width or height in pixels. Default 768. */
+    maxDim?: number;
+    /** JPEG encode quality 1–100. Default 85. */
+    jpegQuality?: number;
+}
+/**
+ * Downscales image/* payloads when either dimension exceeds MaxDim.
+ * Non-images and decode failures pass through unchanged.
+ * PNG stays PNG; other image types re-encode as JPEG when sharp is available.
+ */
+declare function compactImageAttachment(mimeType: string, dataB64: string, opts?: CompactImageOptions | null): Promise<[string, string]>;
+/**
+ * Applies compactImageAttachment to each attachment map with mime_type + data.
+ */
+declare function compactAttachments(atts: Record<string, unknown>[], opts?: CompactImageOptions | null): Promise<Record<string, unknown>[]>;
+
+/**
+ * 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.
+ *
+ * Supports IG-651 / SIL-04 lifecycle knobs: idle timeout, soft-complete
+ * policies, attachment compaction, and stream-close soft-complete.
+ */
+
+/** Returned when a turn exceeds the configured timeout and policy is Fail. */
+declare class ErrQueryTimeout extends Error {
+    constructor();
+}
+/** Returned when no events arrive within IdleTimeout and policy is Fail. */
+declare class ErrIdleTimeout extends Error {
+    constructor();
+}
+/** Selects fail vs soft-complete behaviour for idle, query, and stream-close. */
+declare enum TimeoutPolicy {
+    Fail = 0,
+    SoftComplete = 1
+}
+type StreamClosePolicy = TimeoutPolicy;
+declare const StreamCloseFail = TimeoutPolicy.Fail;
+declare const StreamCloseSoftComplete = TimeoutPolicy.SoftComplete;
+/** Configures a TurnRunner. */
+interface TurnConfig {
+    /** Per-turn deadline in ms. Defaults to 30m. */
+    queryTimeout: number;
+    /** Max silence between classified events in ms. Zero disables (default). */
+    idleTimeout?: number;
+    /**
+     * When > 0, raises idleTimeout for turns with attachments if idleTimeout
+     * is positive but below this floor.
+     */
+    minIdleTimeoutWithAttachments?: number;
+    /** Fail vs soft-complete when the idle watchdog fires. Default Fail. */
+    onIdleTimeout?: TimeoutPolicy;
+    /** Fail vs soft-complete when queryTimeout fires. Default Fail. */
+    onQueryTimeout?: TimeoutPolicy;
+    /** Fail vs soft-complete when the event stream closes. Default Fail. */
+    onStreamClose?: StreamClosePolicy;
+    /** Run compactAttachments before buildInput. Default false. */
+    compactAttachmentsBeforeSend?: boolean;
+    /** Overrides for compactAttachmentsBeforeSend. */
+    compactImageOpts?: CompactImageOptions | null;
+}
+/** 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 ({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>;
+/** Effective idle timeout for a turn (attachment floor applied). */
+declare function idleTimeoutForTurn(cfg: TurnConfig, hasAttachments: boolean): number;
+/** 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;
+    constructor(pool: ConnectionPool, gate: QueryGate, classifier: EventClassifier, store: SessionStore, broadcaster: SSEBroadcaster | null, cfg: TurnConfig);
+    withInputBuilder(f: typeof inputMessageForLoop): TurnRunner;
+    withOnComplete(f: OnComplete): TurnRunner;
+    withOnError(f: OnError): TurnRunner;
+    execute(sessionID: string, message: string, userID: string, workspaceID: string, attachments: Attachment[] | null, opts: InputOpts | null, signal?: AbortSignal): Promise<void>;
+    private finishTimeout;
+    private completeTurn;
+    private sendLoopCancel;
+    private persistResponse;
+    private persistFailed;
+    private broadcastThinkingStep;
+    private broadcastComplete;
+    private broadcastError;
+}
+
+/**
+ * Per-turn observability counters for daemon stream consumption.
+ */
+declare class TurnEventStats {
+    total: number;
+    messages: number;
+    updates: number;
+    custom: number;
+    skipped: number;
+    filteredEarly: number;
+    toolCalls: number;
+    toolResults: number;
+    textChunks: number;
+    heartbeatsDropped: number;
+    postIdleDrained: number;
+    inboundDropped: number;
+}
+
+/**
+ * Dual-socket daemon loop session with turn streaming (Python DaemonSession parity).
+ *
+ * Owns a subscribed stream WebSocket plus an RPC sidecar so metadata calls do not
+ * starve loop events. `iterTurnChunks` handles idle timeout, post-idle drain,
+ * loop scoping, and connection-loss detection.
+ */
+
+declare const DEFAULT_POST_IDLE_DRAIN_MS = 500;
+type EarlyDropFn = (namespace: unknown[], mode: string, data: unknown) => boolean;
+type StatsFactory = () => TurnEventStats;
+type StreamDeliveryResolver = () => string;
+interface DaemonSessionOptions {
+    workspace?: string | null;
+    streamDelivery?: string | StreamDeliveryResolver;
+    postIdleDrainDeadlineMs?: number;
+    earlyDropFn?: EarlyDropFn | null;
+    statsFactory?: StatsFactory | null;
+    config?: Config;
+}
+type TurnChunk = [namespace: unknown[], mode: string, data: unknown];
+/** Daemon-backed loop session with stream + RPC sockets. */
+declare class DaemonSession {
+    private wsUrl;
+    private workspace;
+    private streamDelivery;
+    private client;
+    private rpcClient;
+    private loopId;
+    private readBusy;
+    private rpcBusy;
+    private rpcConnected;
+    private streaming;
+    private postIdleDrainDeadlineMs;
+    private closed;
+    private earlyDropFn;
+    private statsFactory;
+    private config;
+    turnEventStats: TurnEventStats;
+    lastTurnEndState: string | null;
+    lastTurnCancellationSeen: boolean;
+    lastTurnErrorMessage: string | null;
+    constructor(wsUrl: string, opts?: DaemonSessionOptions);
+    get streamClient(): Client;
+    get rpcSideClient(): Client;
+    get activeLoopId(): string | null;
+    private resolveStreamDeliveryMode;
+    get streamDeliveryMode(): string;
+    private shouldDrop;
+    connect(resumeLoopId?: string | null): Promise<Record<string, unknown>>;
+    private bootstrapLoop;
+    newLoop(): Promise<Record<string, unknown>>;
+    switchLoop(loopId: string): Promise<Record<string, unknown>>;
+    ensureConnected(): Promise<void>;
+    close(): Promise<void>;
+    detach(): Promise<void>;
+    sendTurn(text: string, options?: {
+        autonomous?: boolean;
+        maxIterations?: number;
+        preferredSubagent?: string;
+        model?: string;
+        modelParams?: Record<string, unknown>;
+        attachments?: Array<{
+            mime_type: string;
+            data: string;
+        }>;
+        clarificationMode?: string;
+        clarificationAnswer?: boolean;
+        intentHint?: string;
+    }): Promise<void>;
+    cancelActiveTurn(): Promise<void>;
+    private drainStreamEventsAfterIdle;
+    private withRpcLock;
+    private ensureRpcConnected;
+    listLoops(_limit?: number): Promise<Record<string, unknown>>;
+    fetchLoopCards(loopId: string): Promise<{
+        cards: unknown[];
+        seq: number;
+        contextTokens: number;
+        success: boolean;
+    }>;
+    fetchLoopHistory(loopId: string): Promise<{
+        goals: unknown[];
+        liveCards: unknown[];
+        liveGoalIndex: number | null;
+        contextTokens: number;
+        success: boolean;
+    }>;
+    fetchConversationLog(loopId: string, opts?: {
+        limit?: number;
+        offset?: number;
+        includeEvents?: boolean;
+    }): Promise<Record<string, unknown>[]>;
+    iterTurnChunks(opts?: {
+        maxWaitMs?: number;
+    }): AsyncGenerator<TurnChunk>;
+}
+
+export { type Attachment, type BaseEnvelope, CLIENT_VERSION, type ChatEventResult, ChatEventTerminal, type ClassifierConfig, Client, CommandClient, type CompactImageOptions, type CompleteEnvelope, type Config, type ConnectionAckEnvelope, ConnectionError, type ConnectionInitEnvelope, ConnectionPool, DEFAULT_CLIENT_CAPABILITIES, DEFAULT_DELIVERABLE_PHASES, DEFAULT_POST_IDLE_DRAIN_MS, DEFAULT_THINKING_STEP_EVENTS, DaemonError, DaemonSession, type DaemonSessionOptions, type DecodedMessage, DisconnectCause, type DisconnectEnvelope, ErrIdleTimeout, 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 MessageType, type MethodName, 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, STREAM_END, type SessionEntry, type SessionMessage, type SessionStore, StaleLoopError, type StatusFrame, StreamCloseFail, type StreamClosePolicy, StreamCloseSoftComplete, type StreamEventPayload, type SubscribeEnvelope, TimeoutError, TimeoutPolicy, type TurnChunk, type TurnConfig, TurnEventStats, TurnRunner, type UnsubscribeEnvelope, type VerbosityLevel, VerbosityTier, authenticate, bootstrapLoopSession, checkDaemonStatus, classifyEventVerbosity, compactAttachments, compactImageAttachment, connectWithRetries, connectedWebsocket, connectionInitEnvelope, decodeMessage, defaultConfig, defaultPoolConfig, disconnectCauseName, disconnectEnvelope, encodeMessage, extractSootheLoopID, extractThinkingStep, fetchConfigSection, fetchLoopCards, fetchLoopHistory, fetchLoopMessages, fetchSkillsCatalog, idleTimeoutForTurn, inboundNeedsDeliveryAck, inputMessageForLoop, isCompletionEvent, isDaemonLive, isSubagentProgressEvent, isTurnEndCustomData, isTurnProgressChunk, isValidVerbosityLevel, loadConfigFromEnv, newLoopInputMessage, newLoopNewMessage, newLoopSubscribeMessage, newRequestID, notificationEnvelope, parseNamespace, pingEnvelope, pongEnvelope, protocol1Rpc, refreshAuthToken, requestDaemonConfigReload, requestDaemonShutdown, requestEnvelope, shouldShow, splitWirePayload, subscribeEnvelope, unsubscribeEnvelope, validateLoopInputIntentHint, waitDaemonReady, waitLoopStatusWithID, waitSubscriptionConfirmed };