@mirasoth/soothe-client 0.2.1 → 0.4.0

package/dist/index.d.ts

@@ -167,7 +167,7 @@ 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";
+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";
@@ -479,6 +479,9 @@ declare class Client extends EventEmitter {
     private config;
     private ws;
     private messageBuffer;
+    private inboundMaxSize;
+    private inboundDroppedCount;
+    private onStreamDegraded;
     private resolvers;
     private handshakeComplete;
     private negotiatedCapabilities;
@@ -489,6 +492,8 @@ declare class Client extends EventEmitter {
     private lastPongMonotonic;
     private disconnFired;
     private mux;
+    private deliveryRecvSeq;
+    private deliveryAckedSeq;
     constructor(url: string, config?: Config);
     /**
      * Dials the Soothe daemon WebSocket and completes the protocol-1 handshake
@@ -556,6 +561,21 @@ declare class Client extends EventEmitter {
     readEvent(): Promise<Record<string, unknown> | null>;
     /** Reads a single event with a timeout. Returns null on timeout or close. */
     readEventWithTimeout(timeout: number): Promise<Record<string, unknown> | null>;
+    /**
+     * 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
@@ -593,6 +613,8 @@ declare class Client extends EventEmitter {
     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
@@ -710,82 +732,26 @@ declare class Client extends EventEmitter {
 }
 
 /**
- * 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.
+ * Ephemeral one-shot RPC client for jobs / cron / autopilot.
+ * Mirrors Python AsyncCommandClient / CommandClient (RFC-629 / IG-662).
  */
-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;
+
+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>>;
 }
 
 /**
@@ -810,6 +776,27 @@ declare function fetchLoopHistory(client: Client, loopID: string, timeout?: numb
 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>>;
+/**
+ * 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>>;
 
 /**
  * loop_new (or reuse id) → subscribe(loop_events); returns the loop id.
@@ -828,6 +815,25 @@ declare function waitSubscriptionConfirmed(client: Client, wantLoopID: string, _
 /** Attempts to connect to the Soothe daemon with bounded retries. */
 declare function connectWithRetries(client: Client, maxRetries?: number, retryDelay?: number): Promise<void>;
 
+/**
+ * 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).
  *
@@ -1004,12 +1010,19 @@ interface ClassifierConfig {
     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
@@ -1142,16 +1155,12 @@ interface ManagedClient {
  * (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).
@@ -1178,7 +1187,8 @@ interface PoolConfig {
     maxIdleTime: number;
     healthCheckInterval: number;
 }
-/** Returns env-overridable defaults (mirrors triarch). */
+/** 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 {
@@ -1246,6 +1256,29 @@ declare class ConnectionPool {
     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).
  *
@@ -1253,17 +1286,47 @@ declare class ConnectionPool {
  * 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.
+ * 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. */
+/** 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 {
@@ -1273,13 +1336,15 @@ interface InputOpts {
     responseSchemaName?: string;
     responseSchemaStrict?: boolean;
 }
-/** Optional attachment shape (IG-327: {mime_type, data(base64)}). */
+/** 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. */
@@ -1297,25 +1362,13 @@ declare class TurnRunner {
     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 finishTimeout;
+    private completeTurn;
     private sendLoopCancel;
     private persistResponse;
     private persistFailed;
@@ -1324,4 +1377,120 @@ declare class TurnRunner {
     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 };
+/**
+ * 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 };