@mirasoth/soothe-client 0.1.0 → 0.2.1

package/dist/index.cjs

@@ -30,6 +30,82 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/errors.ts
+function disconnectCauseName(cause) {
+  return cause === 1 /* Clean */ ? "clean" : "unclean";
+}
+var ConnectionError, DaemonError, TimeoutError, DisconnectCause, ReconnectError, StaleLoopError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    ConnectionError = class extends Error {
+      url;
+      attempt;
+      cause;
+      constructor(url, attempt, cause) {
+        super(`connection error to ${url} (attempt ${attempt}): ${cause.message}`);
+        this.name = "ConnectionError";
+        this.url = url;
+        this.attempt = attempt;
+        this.cause = cause;
+      }
+    };
+    DaemonError = class extends Error {
+      /** Numeric error code from the RFC-450 §7.3 registry. */
+      code;
+      /** The daemon's error message text. */
+      daemonMessage;
+      /** Optional machine-parseable error details. */
+      data;
+      constructor(code, message, data) {
+        super(`daemon error [${code}]: ${message}`);
+        this.name = "DaemonError";
+        this.code = code;
+        this.daemonMessage = message;
+        this.data = data;
+      }
+    };
+    TimeoutError = class extends Error {
+      operation;
+      duration;
+      constructor(operation, duration) {
+        super(`timeout after ${duration} waiting for ${operation}`);
+        this.name = "TimeoutError";
+        this.operation = operation;
+        this.duration = duration;
+      }
+    };
+    DisconnectCause = /* @__PURE__ */ ((DisconnectCause2) => {
+      DisconnectCause2[DisconnectCause2["Unclean"] = 0] = "Unclean";
+      DisconnectCause2[DisconnectCause2["Clean"] = 1] = "Clean";
+      return DisconnectCause2;
+    })(DisconnectCause || {});
+    ReconnectError = class extends Error {
+      url;
+      attempts;
+      cause;
+      constructor(url, attempts, cause) {
+        super(`reconnect to ${url} failed after ${attempts} attempts: ${cause.message}`);
+        this.name = "ReconnectError";
+        this.url = url;
+        this.attempts = attempts;
+        this.cause = cause;
+      }
+    };
+    StaleLoopError = class extends Error {
+      loopID;
+      cause;
+      constructor(loopID, cause) {
+        const detail = cause ? `: ${cause.message}` : "";
+        super(`stale loop ${loopID}: reattach accepted but liveness probe failed${detail}`);
+        this.name = "StaleLoopError";
+        this.loopID = loopID;
+        this.cause = cause;
+      }
+    };
+  }
+});
+
 // src/config.ts
 function defaultConfig() {
   return {
@@ -40,7 +116,11 @@ function defaultConfig() {
     heartbeatInterval: 3e4,
     daemonReadyTimeout: 2e4,
     loopStatusTimeout: 6e4,
-    subscriptionTimeout: 1e4
+    subscriptionTimeout: 1e4,
+    reconnectMaxAttempts: 10,
+    reconnectInitialDelay: 500,
+    reconnectMaxDelay: 1e4,
+    reattachProbeTimeout: 5e3
   };
 }
 function loadConfigFromEnv() {
@@ -90,102 +170,89 @@ function decodeMessage(data) {
   } catch {
     throw new Error(`invalid JSON: ${data}`);
   }
+  if (!parsed || typeof parsed !== "object") return parsed;
   const type = parsed.type;
   if (!type) return parsed;
   switch (type) {
-    // Client → Daemon (loop-first)
-    case "loop_input":
-      return { ...parsed };
-    case "command":
-      return { ...parsed };
-    case "daemon_status":
-      return { ...parsed };
-    case "daemon_shutdown":
-      return { ...parsed };
-    case "config_get":
-      return { ...parsed };
-    case "loop_new":
-      return { ...parsed };
-    case "loop_subscribe":
-      return { ...parsed };
-    case "loop_detach":
-      return { ...parsed };
-    case "loop_list":
-      return { ...parsed };
-    case "loop_get":
-      return { ...parsed };
-    case "loop_tree":
-      return { ...parsed };
-    case "loop_prune":
-      return { ...parsed };
-    case "loop_delete":
+    case "connection_init":
       return { ...parsed };
-    case "loop_reattach":
+    case "connection_ack":
       return { ...parsed };
-    case "skills_list":
+    case "request":
       return { ...parsed };
-    case "models_list":
+    case "response":
       return { ...parsed };
-    case "invoke_skill":
+    case "notification":
       return { ...parsed };
-    case "detach":
+    case "subscribe":
       return { ...parsed };
-    // Daemon → Client
-    case "event":
-      return { ...parsed };
-    case "status": {
-      const msg = { ...parsed };
-      if (!msg.loop_id && parsed.loopId && typeof parsed.loopId === "string") {
-        msg.loop_id = parsed.loopId;
-      }
-      return msg;
-    }
-    case "subscription_confirmed":
+    case "next":
       return { ...parsed };
     case "error":
       return { ...parsed };
-    case "daemon_ready":
-      return { ...parsed };
-    case "daemon_status_response":
-      return { ...parsed };
-    case "shutdown_ack":
-      return { ...parsed };
-    case "loop_new_response":
-      return { ...parsed };
-    case "loop_subscribe_response":
-      return { ...parsed };
-    case "loop_detach_response":
+    case "complete":
       return { ...parsed };
-    case "loop_list_response":
+    case "unsubscribe":
       return { ...parsed };
-    case "loop_get_response":
+    case "ping":
       return { ...parsed };
-    case "loop_tree_response":
+    case "pong":
       return { ...parsed };
-    case "loop_prune_response":
+    case "receipt_response":
       return { ...parsed };
-    case "loop_delete_response":
+    case "disconnect":
       return { ...parsed };
-    case "loop_reattach_response":
-      return { ...parsed };
-    case "history_replay":
-      return { ...parsed };
-    case "history_replay_complete":
-    case "replay_complete":
-      return { ...parsed };
-    case "loop_reattached":
-      return { ...parsed };
-    case "config_get_response":
-    case "invoke_skill_response":
-      return parsed;
-    case "skills_list_response":
-      return { ...parsed };
-    case "models_list_response":
+    case "status":
       return { ...parsed };
     default:
       return parsed;
   }
 }
+function requestEnvelope(method, params, id) {
+  return {
+    proto: PROTO_VERSION,
+    type: "request",
+    method,
+    params,
+    id: id ?? newRequestID()
+  };
+}
+function notificationEnvelope(method, params) {
+  return { proto: PROTO_VERSION, type: "notification", method, params };
+}
+function subscribeEnvelope(method, params, id) {
+  return {
+    proto: PROTO_VERSION,
+    type: "subscribe",
+    method,
+    params,
+    id: id ?? newRequestID()
+  };
+}
+function unsubscribeEnvelope(id) {
+  return { proto: PROTO_VERSION, type: "unsubscribe", id };
+}
+function connectionInitEnvelope(opts) {
+  return {
+    proto: PROTO_VERSION,
+    type: "connection_init",
+    params: {
+      client_version: opts?.client_version ?? CLIENT_VERSION,
+      client_name: opts?.client_name ?? "soothe-client-ts",
+      accept_proto: opts?.accept_proto ?? [PROTO_VERSION],
+      capabilities: opts?.capabilities ?? DEFAULT_CLIENT_CAPABILITIES
+    }
+  };
+}
+function pingEnvelope() {
+  return { proto: PROTO_VERSION, type: "ping" };
+}
+function pongEnvelope() {
+  return { proto: PROTO_VERSION, type: "pong" };
+}
+function disconnectEnvelope() {
+  return { proto: PROTO_VERSION, type: "disconnect" };
+}
 function splitWirePayload(data) {
   const trimmed = data.trim();
   if (trimmed === "") return [];
@@ -195,21 +262,25 @@ function splitWirePayload(data) {
 function extractSootheLoopID(msg) {
   if (!msg || typeof msg !== "object") return ["", false];
   const m = msg;
+  if (m.type === "next") {
+    const payload = m.payload;
+    if (payload && typeof payload === "object") {
+      const data = payload.data;
+      if (data && typeof data === "object") {
+        const id = data.loop_id;
+        if (id && id !== "") return [id, true];
+      }
+      const pid = payload.loop_id;
+      if (pid && pid !== "") return [pid, true];
+    }
+    return ["", false];
+  }
   if (m.type === "status") {
     const id = m.loop_id;
     if (id && id !== "") return [id, true];
     return ["", false];
   }
-  if (m.type === "event") {
-    const top = m.loop_id;
-    if (top && top !== "") return [top, true];
-    const data = m.data;
-    if (data && typeof data === "object") {
-      const dataId = data["loop_id"] ?? data["loopId"];
-      if (dataId && dataId !== "") return [dataId, true];
-    }
-  }
-  const generic = m["loop_id"] ?? m["loopId"];
+  const generic = m.loop_id;
   if (generic && generic !== "") return [generic, true];
   return ["", false];
 }
@@ -217,52 +288,232 @@ function newRequestID() {
   return (0, import_node_crypto.randomUUID)();
 }
 function newLoopInputMessage(loopID, content) {
-  return {
-    request_id: newRequestID(),
-    type: "loop_input",
+  return notificationEnvelope("loop_input", {
     loop_id: loopID,
     content,
     autonomous: false
-  };
+  });
 }
 function newLoopNewMessage(opts) {
   const options = typeof opts === "string" ? { client_workspace: opts } : opts ?? {};
   const clientWorkspace = options.client_workspace ?? options.workspace;
-  const msg = {
-    request_id: newRequestID(),
-    type: "loop_new"
-  };
+  const params = {};
   if (clientWorkspace?.trim()) {
-    msg.client_workspace = clientWorkspace.trim();
+    params.client_workspace = clientWorkspace.trim();
   }
   if (options.user_id?.trim()) {
-    msg.user_id = options.user_id.trim();
+    params.user_id = options.user_id.trim();
   }
   if (options.client_workspace_id?.trim()) {
-    msg.client_workspace_id = options.client_workspace_id.trim();
+    params.client_workspace_id = options.client_workspace_id.trim();
   }
   if (options.is_ephemeral) {
-    msg.is_ephemeral = true;
+    params.is_ephemeral = true;
   }
-  return msg;
+  return requestEnvelope("loop_new", params);
 }
 function newLoopSubscribeMessage(loopID, verbosity, streamDelivery) {
-  const msg = {
-    request_id: newRequestID(),
-    type: "loop_subscribe",
-    loop_id: loopID,
-    verbosity
-  };
+  const params = { loop_id: loopID, verbosity };
   if (streamDelivery) {
-    msg.stream_delivery = streamDelivery;
+    params.stream_delivery = streamDelivery;
   }
-  return msg;
+  return subscribeEnvelope("loop_events", params);
 }
-var import_node_crypto;
+var import_node_crypto, PROTO_VERSION, DEFAULT_CLIENT_CAPABILITIES, CLIENT_VERSION;
 var init_protocol = __esm({
   "src/protocol.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
+    PROTO_VERSION = "1";
+    DEFAULT_CLIENT_CAPABILITIES = ["streaming", "batch", "heartbeat", "receipts"];
+    CLIENT_VERSION = "0.1.0";
+  }
+});
+
+// src/intent_hints.ts
+function validateLoopInputIntentHint(hint) {
+  const key = hint.trim().toLowerCase();
+  if (key === "direct_llm" || key === "quiz") {
+    return REMOVED_INTENT_HINT_MESSAGES[key];
+  }
+  return null;
+}
+var INTENT_HINT_TEXT_COMPLETION, INTENT_HINT_IMAGE_TO_TEXT, INTENT_HINT_OCR, INTENT_HINT_EMBED, REMOVED_INTENT_HINTS, REMOVED_INTENT_HINT_MESSAGES, LOOP_ASSISTANT_OUTPUT_PHASES, DEFAULT_DELIVERABLE_PHASES;
+var init_intent_hints = __esm({
+  "src/intent_hints.ts"() {
+    "use strict";
+    INTENT_HINT_TEXT_COMPLETION = "text_completion";
+    INTENT_HINT_IMAGE_TO_TEXT = "image_to_text";
+    INTENT_HINT_OCR = "ocr";
+    INTENT_HINT_EMBED = "embed";
+    REMOVED_INTENT_HINTS = ["direct_llm", "quiz"];
+    REMOVED_INTENT_HINT_MESSAGES = {
+      direct_llm: "intent_hint direct_llm is removed; use text_completion (text-only) or image_to_text (with attachments)",
+      quiz: "intent_hint quiz is removed; omit intent_hint and let intake classify the turn"
+    };
+    LOOP_ASSISTANT_OUTPUT_PHASES = [
+      "goal_completion",
+      "quiz",
+      "autonomous_goal",
+      "direct_model",
+      "text_completion",
+      "image_to_text",
+      "ocr",
+      "embed",
+      "plan_direct"
+    ];
+    DEFAULT_DELIVERABLE_PHASES = /* @__PURE__ */ new Set([
+      "quiz",
+      "goal_completion",
+      "direct_model",
+      "text_completion",
+      "image_to_text",
+      "ocr",
+      "embed"
+    ]);
+  }
+});
+
+// src/multiplexer.ts
+var Multiplexer;
+var init_multiplexer = __esm({
+  "src/multiplexer.ts"() {
+    "use strict";
+    init_errors();
+    Multiplexer = class {
+      rpcs = /* @__PURE__ */ new Map();
+      subs = /* @__PURE__ */ new Map();
+      receipts = /* @__PURE__ */ new Map();
+      /**
+       * 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) {
+        let callResolve;
+        let callReject;
+        const call = new Promise((resolve, reject) => {
+          callResolve = resolve;
+          callReject = reject;
+        });
+        const pending = { resolve: callResolve, reject: callReject };
+        this.rpcs.set(id, pending);
+        const unregister = () => {
+          if (this.rpcs.get(id) === pending) {
+            this.rpcs.delete(id);
+          }
+        };
+        return { call, unregister };
+      }
+      /**
+       * 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) {
+        let resolveDone;
+        const done = new Promise((resolve) => {
+          resolveDone = resolve;
+        });
+        const pending = {
+          push: () => {
+          },
+          done,
+          resolveDone,
+          settled: false
+        };
+        const push = (frame) => {
+          if (pending.settled) return;
+          pending.push(frame);
+        };
+        pending.push = () => {
+        };
+        this.subs.set(id, pending);
+        const unregister = () => {
+          if (this.subs.get(id) === pending) {
+            pending.settled = true;
+            this.subs.delete(id);
+            resolveDone();
+          }
+        };
+        return { push, done, unregister };
+      }
+      /**
+       * Installs a pending receipt wait keyed by `receipt`. Returns an unregister
+       * function.
+       */
+      registerReceipt(receipt) {
+        let resolveWait;
+        const wait = new Promise((resolve) => {
+          resolveWait = resolve;
+        });
+        this.receipts.set(receipt, resolveWait);
+        const unregister = () => {
+          this.receipts.delete(receipt);
+        };
+        return { wait, unregister };
+      }
+      /**
+       * 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, sink) {
+        const sub = this.subs.get(id);
+        if (sub) sub.push = sink;
+      }
+      /**
+       * 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) {
+        if (!frame || typeof frame !== "object") return false;
+        const typ = frame.type;
+        const id = frame.id;
+        if (typ === "response" || typ === "error") {
+          if (!id) return false;
+          const pc = this.rpcs.get(id);
+          if (!pc) return false;
+          if (typ === "error") {
+            const errObj = frame.error ?? {};
+            const code = typeof errObj.code === "number" ? errObj.code : -32603;
+            const message = errObj.message ?? "daemon error";
+            pc.reject(new DaemonError(code, message, errObj.data));
+          } else {
+            const result = frame.result ?? frame;
+            pc.resolve(result);
+          }
+          this.rpcs.delete(id);
+          return true;
+        }
+        if (typ === "next" || typ === "complete") {
+          if (!id) return false;
+          const ps = this.subs.get(id);
+          if (!ps) return false;
+          if (ps.settled) return true;
+          ps.push(frame);
+          return true;
+        }
+        if (typ === "receipt_response") {
+          const rid = frame.receipt;
+          if (!rid) return false;
+          const ch = this.receipts.get(rid);
+          if (!ch) return false;
+          ch(frame);
+          this.receipts.delete(rid);
+          return true;
+        }
+        return false;
+      }
+      /** Reports whether an RPC waiter is registered for `id`. */
+      hasRPCWaiter(id) {
+        return this.rpcs.has(id);
+      }
+    };
   }
 });
 
@@ -278,6 +529,9 @@ var init_client = __esm({
     import_node_events = require("events");
     import_ws = __toESM(require("ws"), 1);
     init_config();
+    init_errors();
+    init_multiplexer();
+    init_intent_hints();
     init_protocol();
     Client = class extends import_node_events.EventEmitter {
       url;
@@ -285,6 +539,22 @@ var init_client = __esm({
       ws = null;
       messageBuffer = [];
       resolvers = [];
+      // Protocol-1 handshake state (RFC-450 §8.2)
+      handshakeComplete = false;
+      negotiatedCapabilities = /* @__PURE__ */ new Set();
+      protocolVersion = null;
+      readinessState = null;
+      heartbeatIntervalMs = 0;
+      heartbeatTimer = null;
+      lastPongMonotonic = 0;
+      // Mid-session drop signal (RFC-450 §8.3). The 'disconnected' event is
+      // emitted exactly once when the connection drops, carrying a DisconnectCause
+      // that distinguishes clean (peer `disconnect`) from unclean (read/write
+      // error or missed pong). `disconnFired` guards the once-only delivery.
+      disconnFired = false;
+      // Pending-request/subscription multiplexer (RFC-629 constraint #1). Routes
+      // inbound frames by (type, id) instead of discarding non-matching events.
+      mux = new Multiplexer();
       constructor(url, config) {
         super();
         this.url = url;
@@ -293,7 +563,10 @@ var init_client = __esm({
       // ---------------------------------------------------------------------------
       // Connection lifecycle
       // ---------------------------------------------------------------------------
-      /** 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() {
         return new Promise((resolve, reject) => {
           const ws = new import_ws.default(this.url, {
@@ -301,9 +574,27 @@ var init_client = __esm({
           });
           ws.on("open", () => {
             this.ws = ws;
-            resolve();
+            this.disconnFired = false;
+            this._lastCause = null;
+            this.mux = new Multiplexer();
+            this._performHandshake().then((ack) => {
+              this.handshakeComplete = true;
+              this.readinessState = ack.result?.readiness_state ?? "ready";
+              this._startHeartbeat();
+              resolve();
+            }).catch((err) => {
+              this._stopHeartbeat();
+              this.ws = null;
+              this.handshakeComplete = false;
+              try {
+                ws.close(1011, "handshake failed");
+              } catch {
+              }
+              reject(err);
+            });
           });
           ws.on("error", (err) => {
+            this._signalDisconnect(0 /* Unclean */);
             if (!this.ws) {
               reject(new Error(`soothe dial: ${err.message}`));
             }
@@ -311,20 +602,42 @@ var init_client = __esm({
           ws.on("message", (data) => {
             const text = data.toString();
             for (const frame of splitWirePayload(text)) {
+              let msg;
               try {
-                const msg = decodeMessage(frame);
-                if (msg !== null) {
-                  this.messageBuffer.push(msg);
-                  this.emit("message", msg);
-                  const resolver = this.resolvers.shift();
-                  if (resolver) resolver(msg);
-                }
+                msg = decodeMessage(frame);
               } catch {
+                continue;
               }
+              if (msg === null) continue;
+              const m = msg;
+              if (m.type === "ping") {
+                this._sendRaw(pongEnvelope());
+                continue;
+              }
+              if (m.type === "pong") {
+                this.lastPongMonotonic = Date.now();
+                continue;
+              }
+              if (m.type === "disconnect") {
+                this._signalDisconnect(1 /* Clean */);
+              }
+              if (this.mux.route(m)) {
+                continue;
+              }
+              const resolver = this.resolvers.shift();
+              if (resolver) {
+                resolver(msg);
+              } else {
+                this.messageBuffer.push(msg);
+              }
+              this.emit("message", msg);
             }
           });
           ws.on("close", () => {
             this.ws = null;
+            this._stopHeartbeat();
+            this.handshakeComplete = false;
+            this._signalDisconnect(0 /* Unclean */);
             this.emit("close");
             for (const resolver of this.resolvers) {
               resolver(null);
@@ -333,18 +646,219 @@ var init_client = __esm({
           });
         });
       }
-      /** Shuts down the WebSocket connection. */
+      /** Sends a `disconnect` notification and closes the WebSocket. */
       close() {
+        this._stopHeartbeat();
         if (!this.ws) return;
         try {
+          if (this.ws.readyState === import_ws.default.OPEN) {
+            this.ws.send(JSON.stringify(disconnectEnvelope()));
+          }
           this.ws.close(1e3, "");
         } catch {
         }
         this.ws = null;
+        this.handshakeComplete = false;
       }
-      /** Returns whether the client has an active WebSocket connection. */
+      /** Returns whether the client has an active, handshaked WebSocket connection. */
       isConnected() {
-        return this.ws !== null && this.ws.readyState === import_ws.default.OPEN;
+        return this.ws !== null && this.ws.readyState === import_ws.default.OPEN && this.handshakeComplete;
+      }
+      // ---------------------------------------------------------------------------
+      // Mid-session drop signal + reconnect/reattach (RFC-450 §8.3, RFC-629 L0)
+      // ---------------------------------------------------------------------------
+      /**
+       * 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() {
+        return this.disconnFired;
+      }
+      /**
+       * 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() {
+        if (!this.disconnFired) return null;
+        return this._lastCause ?? 0 /* Unclean */;
+      }
+      _lastCause = null;
+      /**
+       * 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.
+       */
+      _signalDisconnect(cause) {
+        if (this.disconnFired) return;
+        this.disconnFired = true;
+        this._lastCause = cause;
+        try {
+          this.emit("disconnected", cause);
+        } catch {
+        }
+      }
+      /**
+       * 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.
+       */
+      async reconnect() {
+        const maxAttempts = this.config.reconnectMaxAttempts || 10;
+        const initialDelay = this.config.reconnectInitialDelay || 500;
+        const maxDelay = this.config.reconnectMaxDelay || 1e4;
+        let lastErr = null;
+        let delay = initialDelay;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+          try {
+            await this.connect();
+            return;
+          } catch (err) {
+            lastErr = err;
+          }
+          if (attempt < maxAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay = Math.min(delay * 2, maxDelay);
+          }
+        }
+        throw new ReconnectError(this.url, maxAttempts, lastErr ?? new Error("unknown error"));
+      }
+      /**
+       * 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.
+       */
+      async reattachAndProbe(loopID) {
+        if (!loopID || !loopID.trim()) {
+          throw new Error("soothe: reattachAndProbe requires a loop id");
+        }
+        const lid = loopID.trim();
+        const reattachTimeout = this.config.loopStatusTimeout || 15e3;
+        try {
+          await this.requestResponse(
+            "loop_reattach",
+            { loop_id: lid },
+            "loop_reattach",
+            reattachTimeout
+          );
+        } catch (err) {
+          throw new Error(`loop_reattach: ${err.message}`);
+        }
+        const subTimeout = this.config.subscriptionTimeout || 1e4;
+        try {
+          await this.subscribe(
+            "loop_events",
+            { loop_id: lid, verbosity: this.config.verbosityLevel },
+            subTimeout
+          );
+        } catch (err) {
+          throw new Error(`loop events subscription failed: ${err.message}`);
+        }
+        const probeTimeout = this.config.reattachProbeTimeout || 5e3;
+        try {
+          await this.getLoop(lid, probeTimeout);
+        } catch (err) {
+          if (err instanceof DaemonError && err.code === -32200) {
+            throw new StaleLoopError(lid, err);
+          }
+          throw new StaleLoopError(lid, err);
+        }
+      }
+      // ---------------------------------------------------------------------------
+      // Protocol-1 handshake (RFC-450 §8.2)
+      // ---------------------------------------------------------------------------
+      /** Send connection_init and wait for connection_ack with readiness "ready". */
+      async _performHandshake() {
+        const init = connectionInitEnvelope({
+          client_version: CLIENT_VERSION,
+          client_name: "soothe-client-ts",
+          accept_proto: [PROTO_VERSION],
+          capabilities: DEFAULT_CLIENT_CAPABILITIES
+        });
+        await this.sendMessage(init);
+        const deadline = Date.now() + this.config.daemonReadyTimeout;
+        while (Date.now() < deadline) {
+          const remaining = deadline - Date.now();
+          if (remaining <= 0) break;
+          const ev = await this.readEventWithTimeout(remaining);
+          if (ev === null) {
+            throw new Error("connection closed during handshake");
+          }
+          if (ev.type === "status") {
+            continue;
+          }
+          if (ev.type !== "connection_ack") {
+            continue;
+          }
+          const ack = ev;
+          const result = ack.result ?? {};
+          const state = result.readiness_state ?? "ready";
+          this.protocolVersion = result.protocol_version ?? PROTO_VERSION;
+          this.negotiatedCapabilities = new Set(result.capabilities ?? []);
+          this.heartbeatIntervalMs = result.heartbeat_interval_ms ?? 0;
+          if (state === "incompatible") {
+            throw new Error(`protocol version incompatible: daemon returned ${this.protocolVersion}`);
+          }
+          if (state === "ready") {
+            return ack;
+          }
+          if (state === "error") {
+            throw new Error("daemon startup failed");
+          }
+          if (state === "degraded") {
+            throw new Error("daemon is degraded");
+          }
+          await this._sleep(50);
+          await this.sendMessage(init);
+        }
+        throw new Error(`timeout after ${this.config.daemonReadyTimeout}ms waiting for connection_ack`);
+      }
+      // ---------------------------------------------------------------------------
+      // Heartbeat (RFC-450 §8.3)
+      // ---------------------------------------------------------------------------
+      _startHeartbeat() {
+        if (!this.negotiatedCapabilities.has("heartbeat")) return;
+        const interval = this.heartbeatIntervalMs;
+        if (interval <= 0) return;
+        this.lastPongMonotonic = Date.now();
+        this.heartbeatTimer = setInterval(() => this._heartbeatTick(interval), interval);
+      }
+      _stopHeartbeat() {
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = null;
+        }
+      }
+      _heartbeatTick(intervalMs) {
+        if (!this.ws || this.ws.readyState !== import_ws.default.OPEN) return;
+        const timeoutMs = Math.max(1e4, intervalMs * 2);
+        const now = Date.now();
+        if (now - (this.lastPongMonotonic || now) > intervalMs + timeoutMs) {
+          this._signalDisconnect(0 /* Unclean */);
+          try {
+            this.ws.close(1001, "heartbeat timeout");
+          } catch {
+          }
+          return;
+        }
+        try {
+          this.ws.send(JSON.stringify(pingEnvelope()));
+        } catch {
+        }
+      }
+      _sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
       }
       // ---------------------------------------------------------------------------
       // Core messaging
@@ -352,17 +866,29 @@ var init_client = __esm({
       /** Serializes msg as JSON and sends it as a WebSocket text frame. */
       sendMessage(msg) {
         return new Promise((resolve, reject) => {
-          if (!this.ws) {
+          if (!this.ws || this.ws.readyState !== import_ws.default.OPEN) {
             reject(new Error("soothe: not connected"));
             return;
           }
           const payload = JSON.stringify(msg);
           this.ws.send(payload, (err) => {
-            if (err) reject(err);
-            else resolve();
+            if (err) {
+              this._signalDisconnect(0 /* Unclean */);
+              reject(err);
+            } else {
+              resolve();
+            }
           });
         });
       }
+      /** Low-level send that does not reject on a missing connection (best-effort). */
+      _sendRaw(msg) {
+        if (!this.ws || this.ws.readyState !== import_ws.default.OPEN) return;
+        try {
+          this.ws.send(JSON.stringify(msg));
+        } catch {
+        }
+      }
       /** Returns an async iterable of decoded messages. Ends when connection closes. */
       async *receiveMessages(signal) {
         while (true) {
@@ -395,7 +921,7 @@ var init_client = __esm({
         if (msg === null) return null;
         return msg;
       }
-      /** 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) {
         if (this.messageBuffer.length > 0) {
           const msg = this.messageBuffer.shift();
@@ -416,269 +942,490 @@ var init_client = __esm({
         });
       }
       // ---------------------------------------------------------------------------
+      // Protocol-1 RPC primitives (RFC-450 §5/§9)
+      // ---------------------------------------------------------------------------
+      /**
+       * 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.
+       */
+      readLiveEventWithTimeout(timeout) {
+        if (!this.ws) return Promise.resolve(null);
+        return new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            const idx = this.resolvers.indexOf(resolver);
+            if (idx >= 0) this.resolvers.splice(idx, 1);
+            resolve(null);
+          }, timeout);
+          const resolver = (val) => {
+            clearTimeout(timer);
+            resolve(val);
+          };
+          this.resolvers.push(resolver);
+        });
+      }
+      /**
+       * 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.
+       */
+      async requestResponse(method, params, responseType, timeout = 15e3) {
+        const req = requestEnvelope(method, params);
+        const rid = req.id;
+        const { call, unregister } = this.mux.registerRPC(rid);
+        const label = responseType ?? method;
+        try {
+          await this.sendMessage(req);
+          const result = await this._raceRPC(call, timeout, label);
+          return result;
+        } finally {
+          unregister();
+        }
+      }
+      /**
+       * 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.
+       */
+      async _raceRPC(call, timeout, label) {
+        let timer;
+        let cleanupDisconnect = () => {
+        };
+        const timeoutP = new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error(`timeout after ${timeout}ms waiting for ${label}`)),
+            timeout
+          );
+        });
+        const closedP = new Promise((_, reject) => {
+          if (this.disconnFired) {
+            reject(new Error(`connection closed waiting for ${label}`));
+            return;
+          }
+          const onDisconnect = () => {
+            reject(new Error(`connection closed waiting for ${label}`));
+          };
+          this.once("disconnected", onDisconnect);
+          cleanupDisconnect = () => this.removeListener("disconnected", onDisconnect);
+        });
+        try {
+          return await Promise.race([call, timeoutP, closedP]);
+        } finally {
+          if (timer) clearTimeout(timer);
+          cleanupDisconnect();
+        }
+      }
+      /**
+       * 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.
+       */
+      async _requestResponseForEnvelope(env, label, timeout) {
+        const rid = env.id;
+        const { call, unregister } = this.mux.registerRPC(rid);
+        try {
+          await this.sendMessage(env);
+          return await this._raceRPC(call, timeout, label);
+        } finally {
+          unregister();
+        }
+      }
+      /** Sends a fire-and-forget `notification` envelope (no response expected). */
+      notify(method, params) {
+        return this.sendMessage(notificationEnvelope(method, params));
+      }
+      /**
+       * Starts a subscription stream. Returns the subscription `id` for later
+       * correlation and `unsubscribe()`. Stream events arrive as `next` frames
+       * carrying the same `id`.
+       */
+      async subscribe(method, params, timeout = 5e3) {
+        const req = subscribeEnvelope(method, params);
+        const subId = req.id;
+        await this.sendMessage(req);
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+          const remaining = deadline - Date.now();
+          if (remaining <= 0) break;
+          const ev = await this.readLiveEventWithTimeout(remaining);
+          if (ev === null) break;
+          const evId = ev.id;
+          if (evId !== subId) {
+            this.messageBuffer.push(ev);
+            continue;
+          }
+          const typ = ev.type;
+          if (typ === "error") {
+            const errObj = ev.error ?? {};
+            throw new DaemonError(
+              errObj.code ?? -32603,
+              errObj.message ?? "subscription rejected",
+              errObj.data
+            );
+          }
+          if (typ === "next" || typ === "complete") {
+            this.messageBuffer.unshift(ev);
+            break;
+          }
+        }
+        return subId;
+      }
+      /** Cancels an active subscription by id. */
+      unsubscribe(subscriptionId) {
+        return this.sendMessage(unsubscribeEnvelope(subscriptionId));
+      }
+      /**
+       * 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.
+       */
+      async next() {
+        const ev = await this.readEvent();
+        if (ev === null) return null;
+        if (ev.type === "next") {
+          return ev.payload ?? {};
+        }
+        return ev;
+      }
+      // ---------------------------------------------------------------------------
       // High-level API methods (Loop-first, RFC-503)
       // ---------------------------------------------------------------------------
-      /** Sends user input to the daemon (loop_input; requires loopID). */
+      /** Sends user input to the daemon (loop_input notification; requires loopID). */
       sendInput(text, options) {
         const loopId = (options?.loopID ?? "").trim();
         if (!loopId) {
           return Promise.reject(new Error("sendInput requires options.loopID"));
         }
-        const payload = {
-          type: "loop_input",
+        const params = {
           loop_id: loopId,
           content: text,
           autonomous: options?.autonomous ?? false
         };
-        if (options?.maxIterations !== void 0) payload.max_iterations = options.maxIterations;
-        if (options?.subagent) payload.preferred_subagent = options.subagent;
-        if (options?.interactive) payload.interactive = true;
-        if (options?.model) payload.model = options.model;
-        if (options?.modelParams) payload.model_params = options.modelParams;
-        if (options?.attachments) payload.attachments = options.attachments;
-        return this.sendMessage(payload);
-      }
-      /** Sends a slash command to the daemon. */
+        if (options?.maxIterations !== void 0) params.max_iterations = options.maxIterations;
+        if (options?.subagent) params.preferred_subagent = options.subagent;
+        if (options?.model) params.model = options.model;
+        if (options?.modelParams) params.model_params = options.modelParams;
+        if (options?.attachments) params.attachments = options.attachments;
+        if (options?.intentHint) {
+          const hintError = validateLoopInputIntentHint(options.intentHint);
+          if (hintError) {
+            return Promise.reject(new Error(hintError));
+          }
+          params.intent_hint = options.intentHint;
+        }
+        if (options?.responseSchema) params.response_schema = options.responseSchema;
+        if (options?.responseSchemaName) params.response_schema_name = options.responseSchemaName;
+        if (options?.responseSchemaStrict !== void 0)
+          params.response_schema_strict = options.responseSchemaStrict;
+        if (options?.clarificationMode) params.clarification_mode = options.clarificationMode;
+        if (options?.clarificationAnswer) params.clarification_answer = true;
+        if (options?.clarificationAnswers) params.clarification_answers = options.clarificationAnswers;
+        return this.notify("loop_input", params);
+      }
+      /** Sends a slash command to the daemon (slash_command notification). */
       sendCommand(cmd) {
-        return this.sendMessage({ type: "command", cmd });
+        return this.notify("slash_command", { cmd });
       }
       // ---------------------------------------------------------------------------
       // Loop lifecycle methods (RFC-503)
       // ---------------------------------------------------------------------------
-      /** Requests the daemon to create a new AgentLoop. */
+      /** Requests the daemon to create a new StrangeLoop and waits for the response. */
       sendLoopNew(opts) {
         return this.sendMessage(newLoopNewMessage(opts));
       }
-      /** Subscribes to events for a loop. */
-      sendLoopSubscribe(loopID, verbosity, streamDelivery) {
-        const msg = newLoopSubscribeMessage(loopID, verbosity);
-        if (streamDelivery) {
-          msg.stream_delivery = streamDelivery;
-        }
-        return this.sendMessage(msg);
-      }
-      /** Detaches from a loop (keeps loop running). */
-      sendLoopDetach(loopID, requestID) {
-        return this.sendMessage({
-          type: "loop_detach",
+      /** Subscribes to events for a loop (subscribe → loop_events). */
+      async sendLoopSubscribe(loopID, verbosity, streamDelivery) {
+        await this.subscribe("loop_events", {
           loop_id: loopID,
-          request_id: requestID ?? newRequestID()
+          verbosity,
+          stream_delivery: streamDelivery
         });
       }
-      /** Notifies the daemon that this client is detaching. */
-      sendDetach() {
-        return this.sendMessage({ type: "detach" });
+      /** Detaches from a loop (unsubscribe by subscription id). */
+      sendLoopDetach(loopID) {
+        return this.sendMessage(unsubscribeEnvelope(loopID));
       }
-      /** Sends the daemon_ready handshake message. */
-      sendDaemonReady() {
-        return this.sendMessage({ type: "daemon_ready" });
+      /** Notifies the daemon that this client is leaving (disconnect notification). */
+      sendDetach() {
+        return this.sendMessage(disconnectEnvelope());
       }
       /** Requests daemon status check. */
-      sendDaemonStatus(requestID) {
-        return this.sendMessage({
-          type: "daemon_status",
-          request_id: requestID ?? newRequestID()
-        });
+      sendDaemonStatus() {
+        return this.sendMessage(requestEnvelope("daemon_status", {}));
       }
       /** Requests daemon shutdown. */
-      sendDaemonShutdown(requestID) {
-        return this.sendMessage({
-          type: "daemon_shutdown",
-          request_id: requestID ?? newRequestID()
-        });
+      sendDaemonShutdown() {
+        return this.sendMessage(requestEnvelope("daemon_shutdown", {}));
       }
       /** Requests a config section from the daemon. */
-      sendConfigGet(section, requestID) {
-        return this.sendMessage({
-          type: "config_get",
-          section,
-          request_id: requestID ?? newRequestID()
-        });
+      sendConfigGet(section) {
+        return this.sendMessage(requestEnvelope("config_get", { section }));
       }
       // ---------------------------------------------------------------------------
-      // Loop management RPC methods (RFC-504)
+      // Convenience RPC methods (blocking request/response)
       // ---------------------------------------------------------------------------
-      /** Requests the persisted loop list. */
-      sendLoopList(filter, limit, requestID) {
-        const msg = {
-          type: "loop_list",
-          request_id: requestID ?? newRequestID()
-        };
-        if (filter) msg.filter = filter;
-        if (limit !== void 0) msg.limit = limit;
-        return this.sendMessage(msg);
-      }
-      /** Requests detailed loop metadata. */
-      sendLoopGet(loopID, verbose, requestID) {
-        const msg = {
-          type: "loop_get",
-          loop_id: loopID,
-          request_id: requestID ?? newRequestID()
-        };
-        if (verbose) msg.verbose = verbose;
-        return this.sendMessage(msg);
-      }
-      /** Requests loop tree visualization. */
-      sendLoopTree(loopID, format, requestID) {
-        const msg = {
-          type: "loop_tree",
-          loop_id: loopID,
-          request_id: requestID ?? newRequestID()
-        };
-        if (format) msg.format = format;
-        return this.sendMessage(msg);
+      /** Requests the skills catalog and waits for the response. */
+      listSkills(timeout) {
+        return this.requestResponse("skills_list", {}, "skills_list", timeout ?? 15e3);
       }
-      /** Requests pruning of old failed branches. */
-      sendLoopPrune(loopID, retentionDays, dryRun, requestID) {
-        const msg = {
-          type: "loop_prune",
-          loop_id: loopID,
-          request_id: requestID ?? newRequestID()
-        };
-        if (retentionDays !== void 0) msg.retention_days = retentionDays;
-        if (dryRun !== void 0) msg.dry_run = dryRun;
-        return this.sendMessage(msg);
-      }
-      /** Requests loop deletion. */
-      sendLoopDelete(loopID, requestID) {
-        return this.sendMessage({
-          type: "loop_delete",
-          loop_id: loopID,
-          request_id: requestID ?? newRequestID()
-        });
+      /** Requests the models catalog and waits for the response. */
+      listModels(timeout) {
+        return this.requestResponse("models_list", {}, "models_list", timeout ?? 15e3);
       }
-      /** Requests reattachment to a loop with history replay. */
-      sendLoopReattach(loopID, requestID) {
-        return this.sendMessage({
-          type: "loop_reattach",
-          loop_id: loopID,
-          request_id: requestID ?? newRequestID()
-        });
+      /** Invokes a skill on the daemon host and receives echo. */
+      invokeSkill(skill, args, timeout) {
+        const params = { skill, args: args ?? "" };
+        return this.requestResponse("invoke_skill", params, "invoke_skill", timeout ?? 12e4);
       }
-      // ---------------------------------------------------------------------------
-      // Skills and models
-      // ---------------------------------------------------------------------------
-      /** Requests the skills catalog (RFC-400). */
-      sendSkillsList(requestID) {
-        return this.sendMessage({
-          type: "skills_list",
-          request_id: requestID ?? newRequestID()
-        });
+      /** Requests loop list and waits for response. */
+      listLoops(timeout, workspace) {
+        const params = {};
+        if (workspace) params.filter = { workspace };
+        return this.requestResponse("loop_list", params, "loop_list", timeout ?? 15e3);
       }
-      /** Requests the models catalog (RFC-400). */
-      sendModelsList(requestID) {
-        return this.sendMessage({
-          type: "models_list",
-          request_id: requestID ?? newRequestID()
-        });
+      /** Requests loop details and waits for response. */
+      getLoop(loopID, timeout) {
+        return this.requestResponse("loop_get", { loop_id: loopID }, "loop_get", timeout ?? 15e3);
       }
-      /** Invokes a skill on the daemon (RFC-400). */
-      sendInvokeSkill(skill, args, requestID) {
-        const msg = {
-          type: "invoke_skill",
-          skill,
-          request_id: requestID ?? newRequestID()
-        };
-        if (args) msg.args = args;
-        return this.sendMessage(msg);
+      /** Requests loop tree and waits for response. */
+      getLoopTree(loopID, timeout) {
+        return this.requestResponse("loop_tree", { loop_id: loopID }, "loop_tree", timeout ?? 15e3);
       }
-      // ---------------------------------------------------------------------------
-      // Request-Response pattern
-      // ---------------------------------------------------------------------------
-      /** Sends a request with a unique request_id and waits for a matching response. */
-      async requestResponse(payload, responseType, timeout) {
-        const rid = newRequestID();
-        payload.request_id = rid;
-        await this.sendMessage(payload);
-        const deadline = Date.now() + timeout;
-        while (Date.now() < deadline) {
-          const remaining = deadline - Date.now();
-          if (remaining <= 0) break;
-          const ev = await this.readEventWithTimeout(remaining);
-          if (ev === null) {
-            break;
-          }
-          const evRid = ev.request_id;
-          if (evRid !== rid) continue;
-          const typ = ev.type;
-          if (typ === "error") {
-            const msg = ev.message ?? "unknown error";
-            throw new Error(`daemon error: ${msg}`);
-          }
-          if (typ === responseType) {
-            return ev;
-          }
-        }
-        throw new Error(`timeout after ${timeout}ms waiting for ${responseType}`);
+      /** Requests loop deletion and waits for response. */
+      deleteLoop(loopID, timeout) {
+        return this.requestResponse(
+          "loop_delete",
+          { loop_id: loopID },
+          "loop_delete",
+          timeout ?? 15e3
+        );
+      }
+      /** Requests persisted conversation/activity rows. */
+      sendLoopMessages(loopID, limit, offset, includeEvents) {
+        const params = { loop_id: loopID };
+        if (limit !== void 0) params.limit = limit;
+        if (offset !== void 0) params.offset = offset;
+        if (includeEvents) params.include_events = true;
+        return this.sendMessage(requestEnvelope("loop_messages", params));
+      }
+      /** Requests LangGraph checkpoint channel values. */
+      sendLoopStateGet(loopID) {
+        return this.sendMessage(requestEnvelope("loop_state_get", { loop_id: loopID }));
+      }
+      /** Applies partial checkpoint values. */
+      sendLoopStateUpdate(loopID, values, asNode) {
+        const params = { loop_id: loopID, values };
+        if (asNode) params.as_node = asNode;
+        return this.sendMessage(requestEnvelope("loop_state_update", params));
+      }
+      /** Requests display card ledger snapshot. */
+      sendLoopCardsFetch(loopID) {
+        return this.sendMessage(requestEnvelope("loop_cards_fetch", { loop_id: loopID }));
+      }
+      /** Requests the full loop history (RFC-631). */
+      sendLoopHistoryFetch(loopID) {
+        return this.sendMessage(requestEnvelope("loop_history_fetch", { loop_id: loopID }));
+      }
+      /** Requests MCP server status. */
+      sendMCPStatus() {
+        return this.sendMessage(requestEnvelope("mcp_status", {}));
+      }
+      /** Requests daemon config reload. */
+      sendConfigReload() {
+        return this.sendMessage(requestEnvelope("config_reload", {}));
+      }
+      /** Submits credentials for daemon-side authentication. */
+      sendAuth(accessKey, secretKey) {
+        return this.sendMessage(
+          requestEnvelope("auth", { access_key: accessKey, secret_key: secretKey })
+        );
+      }
+      /** Refreshes the daemon-side auth token. */
+      sendAuthRefresh(refreshToken) {
+        return this.sendMessage(requestEnvelope("auth_refresh", { refresh_token: refreshToken }));
+      }
+      /** Requests persisted messages and waits for response. */
+      getLoopMessages(loopID, limit, offset, includeEvents, timeout) {
+        const params = { loop_id: loopID };
+        if (limit !== void 0) params.limit = limit;
+        if (offset !== void 0) params.offset = offset;
+        if (includeEvents) params.include_events = true;
+        return this.requestResponse("loop_messages", params, "loop_messages", timeout ?? 15e3);
+      }
+      /** Requests loop state and waits for response. */
+      getLoopState(loopID, timeout) {
+        return this.requestResponse(
+          "loop_state_get",
+          { loop_id: loopID },
+          "loop_state_get",
+          timeout ?? 15e3
+        );
+      }
+      /** Updates loop state and waits for response. */
+      updateLoopState(loopID, values, asNode, timeout) {
+        const params = { loop_id: loopID, values };
+        if (asNode) params.as_node = asNode;
+        return this.requestResponse(
+          "loop_state_update",
+          params,
+          "loop_state_update",
+          timeout ?? 15e3
+        );
+      }
+      /** Requests display cards and waits for response. */
+      fetchLoopCards(loopID, timeout) {
+        return this.requestResponse(
+          "loop_cards_fetch",
+          { loop_id: loopID },
+          "loop_cards_fetch",
+          timeout ?? 15e3
+        );
+      }
+      /** Requests MCP status and waits for response. */
+      getMCPStatus(timeout) {
+        return this.requestResponse("mcp_status", {}, "mcp_status", timeout ?? 15e3);
+      }
+      /** Requests loop history and waits for response. */
+      fetchLoopHistory(loopID, timeout) {
+        return this.requestResponse(
+          "loop_history_fetch",
+          { loop_id: loopID },
+          "loop_history_fetch",
+          timeout ?? 15e3
+        );
+      }
+      /** Requests daemon config reload and waits for response. */
+      reloadConfig(timeout) {
+        return this.requestResponse("config_reload", {}, "config_reload", timeout ?? 15e3);
+      }
+      /** Submits credentials for daemon-side authentication and waits for response. */
+      authenticate(accessKey, secretKey, timeout) {
+        return this.requestResponse(
+          "auth",
+          { access_key: accessKey, secret_key: secretKey },
+          "auth",
+          timeout ?? 15e3
+        );
+      }
+      /** Refreshes the daemon-side auth token and waits for response. */
+      refreshAuthToken(refreshToken, timeout) {
+        return this.requestResponse(
+          "auth_refresh",
+          { refresh_token: refreshToken },
+          "auth_refresh",
+          timeout ?? 15e3
+        );
       }
       // ---------------------------------------------------------------------------
-      // Convenience RPC methods
+      // RFC-228 Job IPC methods
       // ---------------------------------------------------------------------------
-      /** Requests the skills catalog and waits for the response. */
-      listSkills(timeout) {
-        return this.requestResponse({ type: "skills_list" }, "skills_list_response", timeout ?? 15e3);
+      /** Creates an autopilot job and waits for the response. */
+      createJob(goal, verificationRules, workspace, timeout) {
+        const params = { goal };
+        if (verificationRules) params.verification_rules = verificationRules;
+        if (workspace) params.workspace = workspace;
+        return this.requestResponse("job_create", params, "job_create", timeout ?? 15e3);
       }
-      /** Requests the models catalog and waits for the response. */
-      listModels(timeout) {
-        return this.requestResponse({ type: "models_list" }, "models_list_response", timeout ?? 15e3);
+      /** Queries job status and waits for the response. */
+      getJobStatus(jobId, timeout) {
+        return this.requestResponse("job_status", { job_id: jobId }, "job_status", timeout ?? 15e3);
       }
-      /** Invokes a skill on the daemon host and receives echo (RFC-400). */
-      invokeSkill(skill, args, timeout) {
-        return this.requestResponse({ type: "invoke_skill", skill, args }, "invoke_skill_response", timeout ?? 12e4);
+      /** Pauses a running job. */
+      pauseJob(jobId, timeout) {
+        return this.requestResponse("job_pause", { job_id: jobId }, "job_pause", timeout ?? 15e3);
       }
-      /** Requests loop list and waits for response. */
-      listLoops(timeout) {
-        return this.requestResponse({ type: "loop_list" }, "loop_list_response", timeout ?? 15e3);
+      /** Resumes a paused job. */
+      resumeJob(jobId, timeout) {
+        return this.requestResponse("job_resume", { job_id: jobId }, "job_resume", timeout ?? 15e3);
       }
-      /** Requests loop details and waits for response. */
-      getLoop(loopID, timeout) {
-        return this.requestResponse({ type: "loop_get", loop_id: loopID }, "loop_get_response", timeout ?? 15e3);
+      /** Cancels a job. */
+      cancelJob(jobId, timeout) {
+        return this.requestResponse("job_cancel", { job_id: jobId }, "job_cancel", timeout ?? 15e3);
       }
-      /** Requests loop tree and waits for response. */
-      getLoopTree(loopID, timeout) {
-        return this.requestResponse({ type: "loop_tree", loop_id: loopID }, "loop_tree_response", timeout ?? 15e3);
+      /** Requests the DAG visualization for a job. */
+      getJobDag(jobId, timeout) {
+        return this.requestResponse("job_dag", { job_id: jobId }, "job_dag", timeout ?? 15e3);
       }
-      /** Requests loop deletion and waits for response. */
-      deleteLoop(loopID, timeout) {
-        return this.requestResponse({ type: "loop_delete", loop_id: loopID }, "loop_delete_response", timeout ?? 15e3);
+      /** Sends guidance to a job or specific goal. */
+      sendJobGuidance(jobId, text, goalId, timeout) {
+        const params = { job_id: jobId, content: text };
+        if (goalId) params.goal_id = goalId;
+        return this.requestResponse("job_guidance", params, "job_guidance", timeout ?? 3e4);
+      }
+      /** Subscribes to autopilot worker events. */
+      autopilotSubscribe(timeout) {
+        return this.subscribe("autopilot_events", {}, timeout ?? 15e3);
+      }
+      /** Unsubscribes from autopilot worker events. */
+      autopilotUnsubscribe(timeout) {
+        const req = unsubscribeEnvelope(newRequestID());
+        return this._requestResponseForEnvelope(req, "autopilot_unsubscribe", timeout ?? 15e3);
       }
       // ---------------------------------------------------------------------------
-      // Wait helpers
+      // RFC-229 Cron IPC methods
+      // ---------------------------------------------------------------------------
+      /** Creates a scheduled job from natural language. */
+      cronAdd(text, priority, timeout) {
+        const params = { text };
+        if (priority !== void 0) params.priority = priority;
+        return this.requestResponse(
+          "cron_add",
+          params,
+          "cron_add",
+          timeout ?? 3e4
+          // Longer timeout for NL extraction
+        );
+      }
+      /** Lists scheduled jobs. */
+      cronList(status, timeout) {
+        const params = {};
+        if (status !== void 0) params.status = status;
+        return this.requestResponse("cron_list", params, "cron_list", timeout ?? 15e3);
+      }
+      /** Shows a specific scheduled job. */
+      cronShow(jobId, timeout) {
+        return this.requestResponse("cron_show", { job_id: jobId }, "cron_show", timeout ?? 15e3);
+      }
+      /** Cancels a scheduled job. */
+      cronCancel(jobId, timeout) {
+        return this.requestResponse("cron_cancel", { job_id: jobId }, "cron_cancel", timeout ?? 15e3);
+      }
       // ---------------------------------------------------------------------------
-      /** Reads events until a daemon_ready with state == "ready". */
+      // Wait helpers
+      /**
+       * 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.
+       */
       async waitForDaemonReady(timeout) {
-        const t = timeout ?? 1e4;
-        const deadline = Date.now() + t;
-        while (Date.now() < deadline) {
-          const remaining = deadline - Date.now();
-          if (remaining <= 0) break;
-          const ev = await this.readEventWithTimeout(remaining);
-          if (ev === null) break;
-          if (ev.type !== "daemon_ready") continue;
-          if (ev.state === "ready") return ev;
-          const msg = ev.message ?? `daemon state is ${ev.state}`;
-          throw new Error(`daemon not ready: ${msg}`);
+        if (this.handshakeComplete) {
+          return { readiness_state: this.readinessState ?? "ready" };
         }
-        throw new Error(`timeout after ${t}ms waiting for daemon_ready`);
-      }
-      /** Waits for subscription confirmation matching loop id. */
-      async waitForSubscriptionConfirmed(loopID, _verbosity, timeout) {
-        const t = timeout ?? 5e3;
+        const t = timeout ?? 1e4;
         const deadline = Date.now() + t;
         while (Date.now() < deadline) {
           const remaining = deadline - Date.now();
           if (remaining <= 0) break;
           const ev = await this.readEventWithTimeout(remaining);
           if (ev === null) break;
-          if (ev.type === "loop_subscribe_response" && ev.success === true) {
-            if (String(ev.loop_id ?? "") === loopID) return;
-            continue;
-          }
-          if (ev.type !== "subscription_confirmed") continue;
-          const lid = String(ev.loop_id ?? "");
-          if (lid === loopID) return;
+          if (ev.type !== "connection_ack") continue;
+          const result = ev.result ?? {};
+          const state = result.readiness_state;
+          if (state === "ready") return ev;
+          throw new Error(`daemon not ready: state=${state ?? "unknown"}`);
         }
-        throw new Error(`timeout after ${t}ms waiting for subscription_confirmed`);
+        throw new Error(`timeout after ${t}ms waiting for connection_ack`);
       }
     };
   }
@@ -687,14 +1434,29 @@ var init_client = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CLIENT_VERSION: () => CLIENT_VERSION,
+  ChatEventTerminal: () => ChatEventTerminal,
   Client: () => Client,
   ConnectionError: () => ConnectionError,
+  ConnectionPool: () => ConnectionPool,
+  DEFAULT_CLIENT_CAPABILITIES: () => DEFAULT_CLIENT_CAPABILITIES,
+  DEFAULT_DELIVERABLE_PHASES: () => DEFAULT_DELIVERABLE_PHASES,
+  DEFAULT_THINKING_STEP_EVENTS: () => DEFAULT_THINKING_STEP_EVENTS,
   DaemonError: () => DaemonError,
-  ESSENTIAL_EVENT_TYPES: () => ESSENTIAL_EVENT_TYPES,
-  EventAgentLoopCompleted: () => EventAgentLoopCompleted,
-  EventAgentLoopIterated: () => EventAgentLoopIterated,
-  EventAgentLoopReasoned: () => EventAgentLoopReasoned,
-  EventAgentLoopStarted: () => EventAgentLoopStarted,
+  DisconnectCause: () => DisconnectCause,
+  ErrPoolExhausted: () => ErrPoolExhausted,
+  ErrQueryBusy: () => ErrQueryBusy,
+  ErrQueryTimeout: () => ErrQueryTimeout,
+  EventAutopilotGoalCompleted: () => EventAutopilotGoalCompleted,
+  EventAutopilotGoalCreated: () => EventAutopilotGoalCreated,
+  EventAutopilotGoalProgress: () => EventAutopilotGoalProgress,
+  EventAutopilotGoalStatus: () => EventAutopilotGoalStatus,
+  EventAutopilotWorkerAssigned: () => EventAutopilotWorkerAssigned,
+  EventAutopilotWorkerUnassigned: () => EventAutopilotWorkerUnassigned,
+  EventCardCreated: () => EventCardCreated,
+  EventCardReplayBegin: () => EventCardReplayBegin,
+  EventCardReplayEnd: () => EventCardReplayEnd,
+  EventClassifier: () => EventClassifier,
   EventExploreCompleted: () => EventExploreCompleted,
   EventExploreMilestone: () => EventExploreMilestone,
   EventExploreStarted: () => EventExploreStarted,
@@ -706,6 +1468,14 @@ __export(index_exports, {
   EventMessageSent: () => EventMessageSent,
   EventPlanCreated: () => EventPlanCreated,
   EventReplayComplete: () => EventReplayComplete,
+  EventStrangeLoopCompleted: () => EventStrangeLoopCompleted,
+  EventStrangeLoopContextCompacted: () => EventStrangeLoopContextCompacted,
+  EventStrangeLoopPlanDecision: () => EventStrangeLoopPlanDecision,
+  EventStrangeLoopReasoned: () => EventStrangeLoopReasoned,
+  EventStrangeLoopStarted: () => EventStrangeLoopStarted,
+  EventStrangeLoopStepCompleted: () => EventStrangeLoopStepCompleted,
+  EventStrangeLoopStepQueued: () => EventStrangeLoopStepQueued,
+  EventStrangeLoopStepStarted: () => EventStrangeLoopStepStarted,
   EventStreamToolCallUpdate: () => EventStreamToolCallUpdate,
   EventTacitusCompleted: () => EventTacitusCompleted,
   EventTacitusGatherSummary: () => EventTacitusGatherSummary,
@@ -714,18 +1484,42 @@ __export(index_exports, {
   EventToolCompleted: () => EventToolCompleted,
   EventToolError: () => EventToolError,
   EventToolStarted: () => EventToolStarted,
+  INTENT_HINT_EMBED: () => INTENT_HINT_EMBED,
+  INTENT_HINT_IMAGE_TO_TEXT: () => INTENT_HINT_IMAGE_TO_TEXT,
+  INTENT_HINT_OCR: () => INTENT_HINT_OCR,
+  INTENT_HINT_TEXT_COMPLETION: () => INTENT_HINT_TEXT_COMPLETION,
+  LOOP_ASSISTANT_OUTPUT_PHASES: () => LOOP_ASSISTANT_OUTPUT_PHASES,
+  Multiplexer: () => Multiplexer,
+  PROTO_VERSION: () => PROTO_VERSION,
+  PooledConn: () => PooledConn,
+  QueryGate: () => QueryGate,
+  REMOVED_INTENT_HINTS: () => REMOVED_INTENT_HINTS,
+  ReconnectError: () => ReconnectError,
+  SSEBroadcaster: () => SSEBroadcaster,
+  StaleLoopError: () => StaleLoopError,
   TimeoutError: () => TimeoutError,
+  TurnRunner: () => TurnRunner,
   VerbosityTier: () => VerbosityTier,
+  authenticate: () => authenticate,
   bootstrapLoopSession: () => bootstrapLoopSession,
   checkDaemonStatus: () => checkDaemonStatus,
   classifyEventVerbosity: () => classifyEventVerbosity,
   connectWithRetries: () => connectWithRetries,
+  connectionInitEnvelope: () => connectionInitEnvelope,
   decodeMessage: () => decodeMessage,
+  defaultBootstrapFunc: () => defaultBootstrapFunc,
+  defaultClientFactory: () => defaultClientFactory,
   defaultConfig: () => defaultConfig,
+  defaultPoolConfig: () => defaultPoolConfig,
+  disconnectCauseName: () => disconnectCauseName,
+  disconnectEnvelope: () => disconnectEnvelope,
   encodeMessage: () => encodeMessage,
   extractSootheLoopID: () => extractSootheLoopID,
+  extractThinkingStep: () => extractThinkingStep,
   fetchConfigSection: () => fetchConfigSection,
+  fetchLoopHistory: () => fetchLoopHistory,
   fetchSkillsCatalog: () => fetchSkillsCatalog,
+  inputMessageForLoop: () => inputMessageForLoop,
   isCompletionEvent: () => isCompletionEvent,
   isDaemonLive: () => isDaemonLive,
   isSubagentProgressEvent: () => isSubagentProgressEvent,
@@ -735,50 +1529,25 @@ __export(index_exports, {
   newLoopNewMessage: () => newLoopNewMessage,
   newLoopSubscribeMessage: () => newLoopSubscribeMessage,
   newRequestID: () => newRequestID,
+  notificationEnvelope: () => notificationEnvelope,
   parseNamespace: () => parseNamespace,
+  pingEnvelope: () => pingEnvelope,
+  pongEnvelope: () => pongEnvelope,
+  refreshAuthToken: () => refreshAuthToken,
+  requestDaemonConfigReload: () => requestDaemonConfigReload,
   requestDaemonShutdown: () => requestDaemonShutdown,
+  requestEnvelope: () => requestEnvelope,
   shouldShow: () => shouldShow,
   splitWirePayload: () => splitWirePayload,
+  subscribeEnvelope: () => subscribeEnvelope,
+  unsubscribeEnvelope: () => unsubscribeEnvelope,
+  validateLoopInputIntentHint: () => validateLoopInputIntentHint,
   waitDaemonReady: () => waitDaemonReady,
   waitLoopStatusWithID: () => waitLoopStatusWithID,
   waitSubscriptionConfirmed: () => waitSubscriptionConfirmed
 });
 module.exports = __toCommonJS(index_exports);
-
-// src/errors.ts
-var ConnectionError = class extends Error {
-  url;
-  attempt;
-  cause;
-  constructor(url, attempt, cause) {
-    super(`connection error to ${url} (attempt ${attempt}): ${cause.message}`);
-    this.name = "ConnectionError";
-    this.url = url;
-    this.attempt = attempt;
-    this.cause = cause;
-  }
-};
-var DaemonError = class extends Error {
-  code;
-  /** The daemon's error message text. */
-  daemonMessage;
-  constructor(code, message) {
-    super(`daemon error [${code}]: ${message}`);
-    this.name = "DaemonError";
-    this.code = code;
-    this.daemonMessage = message;
-  }
-};
-var TimeoutError = class extends Error {
-  operation;
-  duration;
-  constructor(operation, duration) {
-    super(`timeout after ${duration} waiting for ${operation}`);
-    this.name = "TimeoutError";
-    this.operation = operation;
-    this.duration = duration;
-  }
-};
+init_errors();
 
 // src/verbosity.ts
 var VerbosityTier = /* @__PURE__ */ ((VerbosityTier2) => {
@@ -808,6 +1577,7 @@ function isValidVerbosityLevel(s) {
 // src/index.ts
 init_config();
 init_protocol();
+init_intent_hints();
 
 // src/events.ts
 var EventPlanCreated = "soothe.cognition.plan.created";
@@ -820,18 +1590,31 @@ var EventTacitusGatherSummary = "soothe.subagent.tacitus.gather.summary";
 var EventTacitusCompleted = "soothe.subagent.tacitus.completed";
 var EventReplayComplete = "replay_complete";
 var EventLoopReattachedWire = "loop_reattached";
+var EventCardReplayBegin = "card.replay_begin";
+var EventCardCreated = "card.created";
+var EventCardReplayEnd = "card.replay_end";
 var EventToolStarted = "soothe.tool.execution.started";
 var EventToolCompleted = "soothe.tool.execution.completed";
 var EventToolError = "soothe.tool.execution.error";
 var EventStreamToolCallUpdate = "soothe.stream.tool_call.update";
 var EventToolCallUpdatesBatch = "tool_call_updates_batch";
-var EventAgentLoopStarted = "soothe.cognition.agent_loop.started";
-var EventAgentLoopIterated = "soothe.cognition.agent_loop.iterated";
-var EventAgentLoopCompleted = "soothe.cognition.agent_loop.completed";
-var EventAgentLoopReasoned = "soothe.cognition.agent_loop.reasoned";
+var EventStrangeLoopStarted = "soothe.cognition.strange_loop.started";
+var EventStrangeLoopCompleted = "soothe.cognition.strange_loop.completed";
+var EventStrangeLoopPlanDecision = "soothe.cognition.strange_loop.plan.decision";
+var EventStrangeLoopReasoned = "soothe.cognition.strange_loop.reasoned";
+var EventStrangeLoopStepStarted = "soothe.cognition.strange_loop.step.started";
+var EventStrangeLoopStepQueued = "soothe.cognition.strange_loop.step.queued";
+var EventStrangeLoopStepCompleted = "soothe.cognition.strange_loop.step.completed";
+var EventStrangeLoopContextCompacted = "soothe.cognition.strange_loop.context.compacted";
 var EventMessageReceived = "soothe.protocol.message.received";
 var EventMessageSent = "soothe.protocol.message.sent";
 var EventFinalReport = "soothe.output.autonomous.final_report.reported";
+var EventAutopilotGoalStatus = "soothe.autopilot.goal.status";
+var EventAutopilotGoalProgress = "soothe.autopilot.goal.progress";
+var EventAutopilotGoalCreated = "soothe.autopilot.goal.created";
+var EventAutopilotGoalCompleted = "soothe.autopilot.goal.completed";
+var EventAutopilotWorkerAssigned = "soothe.autopilot.worker.assigned";
+var EventAutopilotWorkerUnassigned = "soothe.autopilot.worker.unassigned";
 var EventGeneralFailed = "soothe.error.general.failed";
 function parseNamespace(ns) {
   const parts = splitNamespace(ns);
@@ -872,6 +1655,8 @@ function classifyByDomainAndComponent(domain, _component, full) {
       return 99 /* Internal */;
     case "subagent":
       return classifySubagentEvent(full);
+    case "autopilot":
+      return 1 /* Normal */;
     case "output":
     case "error":
       return 0 /* Quiet */;
@@ -909,25 +1694,15 @@ function isSubagentProgressEvent(eventType) {
   }
   return parsed.action === "started" || parsed.action === "completed";
 }
-var ESSENTIAL_EVENT_TYPES = /* @__PURE__ */ new Set([
-  EventAgentLoopStarted,
-  EventAgentLoopCompleted,
-  EventAgentLoopReasoned,
-  EventPlanCreated,
-  EventExploreStarted,
-  EventExploreCompleted,
-  EventTacitusStarted,
-  EventTacitusCompleted,
-  EventGeneralFailed
-]);
 
 // src/index.ts
 init_client();
+init_multiplexer();
 
 // src/helpers.ts
 init_config();
 async function checkDaemonStatus(client, timeout) {
-  return client.requestResponse({ type: "daemon_status" }, "daemon_status_response", timeout ?? 5e3);
+  return client.requestResponse("daemon_status", {}, "daemon_status", timeout ?? 5e3);
 }
 async function isDaemonLive(wsURL, timeout) {
   const { Client: Client2 } = await Promise.resolve().then(() => (init_client(), client_exports));
@@ -948,70 +1723,106 @@ async function isDaemonLive(wsURL, timeout) {
   }
 }
 async function requestDaemonShutdown(client, timeout) {
-  const resp = await client.requestResponse({ type: "daemon_shutdown" }, "shutdown_ack", timeout ?? 1e4);
+  const resp = await client.requestResponse(
+    "daemon_shutdown",
+    {},
+    "daemon_shutdown",
+    timeout ?? 1e4
+  );
   if (resp.status !== "acknowledged") {
     throw new Error(`shutdown not acknowledged: ${JSON.stringify(resp)}`);
   }
 }
 async function fetchSkillsCatalog(client, timeout) {
-  const resp = await client.requestResponse({ type: "skills_list" }, "skills_list_response", timeout ?? 15e3);
+  const resp = await client.requestResponse("skills_list", {}, "skills_list", timeout ?? 15e3);
   const skillsRaw = resp.skills;
   if (!skillsRaw || !Array.isArray(skillsRaw)) return [];
   return skillsRaw.filter((s) => typeof s === "object" && s !== null);
 }
 async function fetchConfigSection(client, section, timeout) {
-  const resp = await client.requestResponse({ type: "config_get", section }, "config_get_response", timeout ?? 5e3);
+  const resp = await client.requestResponse(
+    "config_get",
+    { section },
+    "config_get",
+    timeout ?? 5e3
+  );
   const sec = resp[section];
   if (sec && typeof sec === "object") {
     return sec;
   }
   return resp;
 }
+async function requestDaemonConfigReload(client, timeout) {
+  return client.requestResponse("config_reload", {}, "config_reload", timeout ?? 15e3);
+}
+async function fetchLoopHistory(client, loopID, timeout) {
+  return client.requestResponse(
+    "loop_history_fetch",
+    { loop_id: loopID },
+    "loop_history_fetch",
+    timeout ?? 15e3
+  );
+}
+async function authenticate(client, accessKey, secretKey, timeout) {
+  return client.requestResponse(
+    "auth",
+    { access_key: accessKey, secret_key: secretKey },
+    "auth",
+    timeout ?? 15e3
+  );
+}
+async function refreshAuthToken(client, refreshToken, timeout) {
+  return client.requestResponse(
+    "auth_refresh",
+    { refresh_token: refreshToken },
+    "auth_refresh",
+    timeout ?? 15e3
+  );
+}
 
 // src/session.ts
 init_config();
 init_protocol();
+init_errors();
 async function bootstrapLoopSession(client, resumeLoopId, config, loopNew) {
   const cfg = config ?? defaultConfig();
-  await client.sendMessage({ type: "daemon_ready" });
-  await waitDaemonReady(client, cfg.daemonReadyTimeout);
   let loopId = (resumeLoopId ?? "").trim();
   if (!loopId) {
+    const env = newLoopNewMessage(loopNew);
     const newResp = await client.requestResponse(
-      newLoopNewMessage(loopNew),
-      "loop_new_response",
+      env.method,
+      env.params ?? {},
+      "loop_new",
       cfg.loopStatusTimeout
     );
     loopId = String(newResp.loop_id ?? "").trim();
     if (!loopId) {
-      throw new Error("loop_new_response missing loop_id");
+      throw new Error("loop_new response missing loop_id");
     }
   }
-  const subResp = await client.requestResponse(
-    { type: "loop_subscribe", loop_id: loopId, verbosity: cfg.verbosityLevel },
-    "loop_subscribe_response",
+  await client.subscribe(
+    "loop_events",
+    { loop_id: loopId, verbosity: cfg.verbosityLevel },
     cfg.subscriptionTimeout
   );
-  if (subResp.success === false) {
-    throw new Error(String(subResp.message ?? "loop_subscribe failed"));
-  }
   return loopId;
 }
 async function waitDaemonReady(client, timeout) {
+  if (client.isConnected()) return;
   const deadline = Date.now() + timeout;
   while (Date.now() < deadline) {
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
     const ev = await client.readEventWithTimeout(remaining);
     if (ev === null) break;
-    if (ev.type === "daemon_ready") {
-      if (ev.state === "ready") return;
-      throw new Error(
-        `daemon not ready: state=${JSON.stringify(ev.state)} message=${JSON.stringify(ev.message ?? "")}`
-      );
+    if (ev.type === "connection_ack") {
+      const result = ev.result ?? {};
+      const state = result.readiness_state;
+      if (state === "ready") return;
+      throw new Error(`daemon not ready: state=${JSON.stringify(state ?? "unknown")}`);
     }
   }
-  throw new Error(`timeout after ${timeout}ms waiting for daemon_ready (state=ready)`);
+  throw new Error(`timeout after ${timeout}ms waiting for connection_ack (ready)`);
 }
 async function waitLoopStatusWithID(client, timeout) {
   const deadline = Date.now() + timeout;
@@ -1021,14 +1832,13 @@ async function waitLoopStatusWithID(client, timeout) {
     const ev = await client.readEventWithTimeout(remaining);
     if (ev === null) break;
     if (ev.type === "error") {
-      const errResp = ev;
-      throw new Error(`daemon error: ${errResp.code}: ${errResp.message}`);
+      const errObj = ev.error ?? {};
+      throw new DaemonError(errObj.code ?? -32603, errObj.message ?? "daemon error");
     }
     if (ev.type === "status") {
-      const status = ev;
-      const lid = status.loop_id;
+      const lid = ev.loop_id;
       if (lid && lid !== "") {
-        return status;
+        return ev;
       }
     }
   }
@@ -1041,15 +1851,18 @@ async function waitSubscriptionConfirmed(client, wantLoopID, _wantVerbosity, tim
     if (remaining <= 0) break;
     const ev = await client.readEventWithTimeout(remaining);
     if (ev === null) break;
-    if (ev.type === "loop_subscribe_response" && ev.success === true) {
-      if (String(ev.loop_id ?? "") === wantLoopID) return;
+    if (ev.type === "next") {
+      const payload = ev.payload ?? {};
+      const lid = String(payload.loop_id ?? "");
+      if (lid === wantLoopID && payload.success === true) return;
+      continue;
     }
-    if (ev.type === "subscription_confirmed") {
-      const lid = String(ev.loop_id ?? "");
-      if (lid === wantLoopID) return;
+    if (ev.type === "error") {
+      const errObj = ev.error ?? {};
+      throw new Error(`daemon error: ${errObj.message ?? "subscription failed"}`);
     }
   }
-  throw new Error(`timeout after ${timeout}ms waiting for subscription_confirmed`);
+  throw new Error(`timeout after ${timeout}ms waiting for subscription confirmation`);
 }
 async function connectWithRetries(client, maxRetries, retryDelay) {
   const retries = maxRetries && maxRetries > 0 ? maxRetries : 40;
@@ -1064,18 +1877,1128 @@ async function connectWithRetries(client, maxRetries, retryDelay) {
     }
     await new Promise((resolve) => setTimeout(resolve, delay));
   }
-  throw new Error(`failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`);
+  throw new Error(
+    `failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`
+  );
+}
+
+// src/appkit/broadcaster.ts
+var SUBSCRIBER_QUEUE_CAP = 100;
+var SSEBroadcaster = class {
+  subscribers = /* @__PURE__ */ new Map();
+  nextSubID = 0;
+  /** 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) {
+    const subID = String(this.nextSubID++);
+    const sub = { queue: [], waiters: [], closed: false };
+    let subs = this.subscribers.get(sessionID);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Map();
+      this.subscribers.set(sessionID, subs);
+    }
+    subs.set(subID, sub);
+    const iterable = {
+      [Symbol.asyncIterator]() {
+        return {
+          next() {
+            if (sub.queue.length > 0) {
+              return Promise.resolve({ value: sub.queue.shift(), done: false });
+            }
+            if (sub.closed) {
+              return Promise.resolve({ value: void 0, done: true });
+            }
+            return new Promise((resolve) => {
+              sub.waiters.push((ev) => {
+                if (ev === null) {
+                  resolve({ value: void 0, done: true });
+                } else {
+                  resolve({ value: ev, done: false });
+                }
+              });
+            });
+          }
+        };
+      }
+    };
+    return { iterable, id: subID };
+  }
+  /** Removes a subscriber by id and closes its iterable. Safe if unknown. */
+  unsubscribe(sessionID, subID) {
+    const subs = this.subscribers.get(sessionID);
+    if (!subs) return;
+    const sub = subs.get(subID);
+    if (!sub) return;
+    sub.closed = true;
+    for (const w of sub.waiters) w(null);
+    sub.waiters = [];
+    subs.delete(subID);
+    if (subs.size === 0) this.subscribers.delete(sessionID);
+  }
+  /**
+   * 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, event) {
+    const subs = this.subscribers.get(sessionID);
+    if (!subs) return;
+    for (const sub of subs.values()) {
+      if (sub.closed) continue;
+      if (sub.waiters.length > 0) {
+        const w = sub.waiters.shift();
+        w(event);
+      } else if (sub.queue.length < SUBSCRIBER_QUEUE_CAP) {
+        sub.queue.push(event);
+      }
+    }
+  }
+  /** Closes all subscribers for a session id and removes the entry. */
+  close(sessionID) {
+    const subs = this.subscribers.get(sessionID);
+    if (!subs) return;
+    for (const sub of subs.values()) {
+      sub.closed = true;
+      for (const w of sub.waiters) w(null);
+      sub.waiters = [];
+    }
+    this.subscribers.delete(sessionID);
+  }
+  /** Closes every subscriber channel across all sessions. */
+  closeAll() {
+    for (const [sessionID, subs] of this.subscribers) {
+      for (const sub of subs.values()) {
+        sub.closed = true;
+        for (const w of sub.waiters) w(null);
+        sub.waiters = [];
+      }
+      this.subscribers.delete(sessionID);
+    }
+  }
+};
+
+// src/appkit/classifier.ts
+init_errors();
+
+// src/appkit/thinking_step.ts
+var MAX_THINKING_STEP_RUNES = 280;
+var DEFAULT_THINKING_STEP_EVENTS = /* @__PURE__ */ new Set([
+  "soothe.cognition.plan.step.started",
+  "soothe.cognition.plan.step.completed",
+  "soothe.cognition.plan.step.failed",
+  "soothe.lifecycle.iteration.started",
+  "soothe.agent.loop.step.started",
+  "soothe.agent.loop.started",
+  "soothe.cognition.plan.batch.started",
+  "soothe.cognition.plan.created",
+  "soothe.cognition.goal.created",
+  "soothe.tool.execution.started"
+]);
+function extractThinkingStep(eventType, data, allow) {
+  if (!eventType || !data) return ["", false];
+  const et = eventType.trim();
+  if (!et) return ["", false];
+  const allowlist = allow ?? DEFAULT_THINKING_STEP_EVENTS;
+  if (!allowlist.has(et)) return ["", false];
+  let line = "";
+  switch (et) {
+    case "soothe.cognition.plan.step.started":
+      line = formatPlanStepLine(data, "");
+      break;
+    case "soothe.cognition.plan.step.completed":
+      line = formatPlanStepLine(data, "done");
+      break;
+    case "soothe.cognition.plan.step.failed": {
+      const stepID = strField(data, "step_id");
+      const errMsg = strField(data, "error");
+      if (stepID && errMsg) line = `Step ${stepID} failed: ${errMsg}`;
+      else if (stepID) line = `Step ${stepID} failed`;
+      else if (errMsg) line = `Step failed: ${errMsg}`;
+      break;
+    }
+    case "soothe.agent.loop.step.started":
+      line = formatAgentStepLine(data, "");
+      break;
+    case "soothe.cognition.plan.batch.started": {
+      const n = data["parallel_count"];
+      if (typeof n === "number" && n > 0) line = `Running ${Math.floor(n)} steps in parallel`;
+      break;
+    }
+    case "soothe.cognition.plan.created":
+    case "soothe.agent.loop.started": {
+      const g = strField(data, "goal");
+      if (g) line = "Goal: " + g;
+      break;
+    }
+    case "soothe.cognition.goal.created": {
+      const g = strField(data, "friendly_message", "description");
+      if (g) line = "Goal: " + g;
+      break;
+    }
+    case "soothe.lifecycle.iteration.started": {
+      const g = strField(data, "goal_description");
+      if (g) line = "Iteration: " + g;
+      break;
+    }
+    case "soothe.tool.execution.started": {
+      const name = strField(data, "tool_name", "name");
+      if (name) line = "Tool: " + name;
+      break;
+    }
+    default:
+      return ["", false];
+  }
+  line = line.trim();
+  if (!line) return ["", false];
+  const runes = [...line];
+  if (runes.length > MAX_THINKING_STEP_RUNES) {
+    line = runes.slice(0, MAX_THINKING_STEP_RUNES).join("") + "\u2026";
+  }
+  return [line, true];
 }
+function formatPlanStepLine(data, suffix) {
+  const stepID = strField(data, "step_id");
+  const desc = strField(data, "description");
+  if (stepID && suffix) return `Step ${stepID}: ${suffix}`;
+  if (stepID && desc) return `Step ${stepID}: ${desc}`;
+  if (stepID) return `Step ${stepID}`;
+  if (desc && suffix) return `Step: ${suffix}`;
+  if (desc) return `Step: ${desc}`;
+  if (suffix) return "Step: " + suffix;
+  return "";
+}
+function formatAgentStepLine(data, suffix) {
+  const stepID = strField(data, "step_id");
+  const desc = strField(data, "description");
+  if (stepID && desc) return `Step ${stepID}: ${desc}`;
+  if (desc) return suffix ? `Step: ${suffix}` : `Step: ${desc}`;
+  if (stepID) return `Step ${stepID}`;
+  return "";
+}
+function strField(data, ...keys) {
+  for (const key of keys) {
+    const v = data[key];
+    if (typeof v === "string") {
+      const s = v.trim();
+      if (s) return s;
+    }
+  }
+  return "";
+}
+
+// src/appkit/classifier.ts
+var ChatEventTerminal = /* @__PURE__ */ ((ChatEventTerminal2) => {
+  ChatEventTerminal2[ChatEventTerminal2["Continue"] = 0] = "Continue";
+  ChatEventTerminal2[ChatEventTerminal2["DeliverableComplete"] = 1] = "DeliverableComplete";
+  ChatEventTerminal2[ChatEventTerminal2["FailedComplete"] = 2] = "FailedComplete";
+  return ChatEventTerminal2;
+})(ChatEventTerminal || {});
+var EVENT_LOOP_HISTORY_REPLAYED = "soothe.lifecycle.loop.history.replayed";
+var EventClassifier = class {
+  deliverablePhases;
+  minDeliverableRunes;
+  thinkingStepEvents;
+  constructor(cfg) {
+    if (!cfg.deliverablePhases) {
+      throw new Error("appkit: ClassifierConfig.deliverablePhases must not be nil");
+    }
+    this.deliverablePhases = cfg.deliverablePhases;
+    this.minDeliverableRunes = cfg.minDeliverableRunes && cfg.minDeliverableRunes > 0 ? cfg.minDeliverableRunes : 8;
+    this.thinkingStepEvents = cfg.thinkingStepEvents;
+  }
+  /**
+   * 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, accumulated) {
+    return this.processChatEvent(msg, accumulated);
+  }
+  /**
+   * 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) {
+    if (!eventType) return false;
+    if (eventType === EventFinalReport) return true;
+    if (eventType.startsWith("soothe.protocol.message.")) {
+      const phase = eventType.slice("soothe.protocol.message.".length);
+      return this.isDeliverableLoopPhase(phase);
+    }
+    return eventType.includes("soothe.output") && eventType.includes("responded");
+  }
+  isDeliverableLoopPhase(phase) {
+    return this.deliverablePhases.has(phase);
+  }
+  deliverableResult(content, completionEvent) {
+    return { content, terminal: 1 /* DeliverableComplete */, completionEvent };
+  }
+  continueResult(content) {
+    return { content, terminal: 0 /* Continue */ };
+  }
+  failedResult(err) {
+    return { terminal: 2 /* FailedComplete */, err };
+  }
+  /** Reports whether trimmed assistant text is long enough to persist as final. */
+  isSubstantiveAssistantReply(content) {
+    return [...content.trim()].length >= this.minDeliverableRunes;
+  }
+  /**
+   * 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, _accumulated) {
+    if (eventResult.terminal !== 1 /* DeliverableComplete */) return ["", false];
+    if (!this.isDeliverableCompletionEvent(eventResult.completionEvent ?? "")) return ["", false];
+    const final = (eventResult.content ?? "").trim();
+    if (final) return [final, true];
+    return ["", false];
+  }
+  /** The event→outcome mapper, ported from triarch's ProcessChatEvent. */
+  processChatEvent(msg, _accumulated) {
+    if (!msg || typeof msg !== "object") {
+      return { terminal: 0 /* Continue */ };
+    }
+    const m = msg;
+    const typ = m.type;
+    if (typ === "next") {
+      return this.classifyNextEnvelope(m);
+    }
+    if (typ === "response" || typ === "complete" || typ === "receipt_response" || typ === "connection_ack" || typ === "status") {
+      return { terminal: 0 /* Continue */ };
+    }
+    if (typ === "error") {
+      const errObj = m.error ?? {};
+      const code = typeof errObj.code === "number" ? errObj.code : -32603;
+      return this.failedResult(
+        new DaemonError(code, errObj.message ?? "daemon error", errObj.data)
+      );
+    }
+    if (typ === "event") {
+      return this.classifyEventPayload(
+        m.namespace ?? null,
+        m.mode ?? "",
+        m.data
+      );
+    }
+    return { terminal: 0 /* Continue */ };
+  }
+  /** Classifies a `next` envelope by projecting its payload. */
+  classifyNextEnvelope(env) {
+    const payload = env.payload ?? {};
+    const innerData = payload.data;
+    if (innerData && typeof innerData === "object") {
+      const innerMode = innerData.mode ?? "";
+      if (innerMode) {
+        return this.classifyEventPayload(
+          innerData.namespace ?? payload.namespace ?? null,
+          innerMode,
+          innerData.data
+        );
+      }
+    }
+    const mode = payload.mode ?? "";
+    if (mode) {
+      return this.classifyEventPayload(payload.namespace ?? null, mode, payload.data);
+    }
+    return { terminal: 0 /* Continue */ };
+  }
+  /**
+   * Classifies an event payload by (namespace, mode, phase). `data` may be a
+   * map or an array of messages (mode="messages").
+   */
+  classifyEventPayload(namespace, mode, data) {
+    const ns = namespaceToString(namespace);
+    const dataMap = normalizeEventData(data);
+    if (dataMap) {
+      let dataType2 = ns;
+      const dt2 = dataMap["type"];
+      if (typeof dt2 === "string" && dt2) dataType2 = dt2;
+      if (dataType2 === EVENT_LOOP_HISTORY_REPLAYED) {
+        return { terminal: 0 /* Continue */ };
+      }
+      const [step, ok] = extractThinkingStep(dataType2, dataMap, this.thinkingStepEvents);
+      if (ok) {
+        return { thinkingStep: step, terminal: 0 /* Continue */ };
+      }
+    }
+    if (mode === "messages") {
+      const result = this.classifyMessagesMode(data, ns);
+      if (result) return result;
+    }
+    if (!dataMap) {
+      return { terminal: 0 /* Continue */ };
+    }
+    let dataType = ns;
+    const dt = dataMap["type"];
+    if (typeof dt === "string" && dt) dataType = dt;
+    let completionEvent = dataType;
+    if (!completionEvent) completionEvent = ns;
+    if (isNamespaceMatch(ns, dataType, "soothe.output") || isNamespaceMatch(ns, dataType, "responded")) {
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) {
+        if (this.isFinalOutputEvent(dataType, ns)) {
+          return this.deliverableResult(content, completionEvent);
+        }
+        return this.continueResult(content);
+      }
+    }
+    if (isNamespaceMatch(ns, dataType, "agent_loop.completed") || isNamespaceMatch(ns, dataType, "agent_loop.reasoned") || isNamespaceMatch(ns, dataType, "loop.completed")) {
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) return this.continueResult(content);
+    }
+    if (isNamespaceMatch(ns, dataType, "final_report")) {
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) return this.deliverableResult(content, completionEvent);
+    }
+    if (dataType.includes("soothe.error.") || ns.includes("soothe.error.")) {
+      const errType = dataType || ns;
+      const msg = dataMap["message"];
+      if (typeof msg === "string" && msg) {
+        return this.failedResult(new Error(`${errType}: ${msg}`));
+      }
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) return this.failedResult(new Error(`${errType}: ${content}`));
+      return this.failedResult(new Error(errType));
+    }
+    if (isNamespaceMatch(ns, dataType, "stream") || isNamespaceMatch(ns, dataType, "progress") || isNamespaceMatch(ns, dataType, "tool_call_updates_batch") || isNamespaceMatch(ns, dataType, "soothe.stream.tool_call.update")) {
+      const delta = dataMap["delta"];
+      if (typeof delta === "string") return this.continueResult(delta);
+    }
+    if (isNamespaceMatch(ns, dataType, "heartbeat") || isNamespaceMatch(ns, dataType, "system.daemon") || isNamespaceMatch(ns, dataType, "agent_loop.started") || isNamespaceMatch(ns, dataType, "intent.classified")) {
+      return { terminal: 0 /* Continue */ };
+    }
+    return { terminal: 0 /* Continue */ };
+  }
+  /** Classifies a mode="messages" payload (array of message objects). */
+  classifyMessagesMode(data, _ns) {
+    const items = Array.isArray(data) ? data : null;
+    if (!items || items.length === 0) return null;
+    const first = items[0];
+    if (!first || typeof first !== "object") return null;
+    const [msgType, rawContent, phase, hasPayload] = firstMessagePayload(data);
+    if (hasPayload && rawContent && isStreamingMessageType(msgType)) {
+      return this.continueResult(rawContent);
+    }
+    const loopMsg = loopAIMessage(data);
+    if (loopMsg) {
+      const content = loopMsg.content;
+      if (content) {
+        if (isStreamingMessageType(loopMsg.type)) {
+          return this.continueResult(content);
+        }
+        if (this.isDeliverableLoopPhase(loopMsg.phase) && this.isSubstantiveAssistantReply(content)) {
+          return this.deliverableResult(content, "soothe.protocol.message." + loopMsg.phase);
+        }
+        return this.continueResult(content);
+      }
+    }
+    const [directContent, directOk] = this.messagesModeAssistantContent(data);
+    if (directOk && this.isSubstantiveAssistantReply(directContent)) {
+      return this.deliverableResult(directContent, "soothe.protocol.message.direct_model");
+    }
+    if (hasPayload && rawContent) {
+      if (isTerminalMessageType(msgType) || msgType === "") {
+        if (this.isDeliverableLoopPhase(phase) && this.isSubstantiveAssistantReply(rawContent)) {
+          return this.deliverableResult(rawContent, "soothe.protocol.message." + phase);
+        }
+        return this.continueResult(rawContent);
+      }
+      return this.continueResult(rawContent);
+    }
+    return null;
+  }
+  /**
+   * 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).
+   */
+  messagesModeAssistantContent(data) {
+    if (!Array.isArray(data) || data.length === 0) return ["", false];
+    const msgMap = data[0];
+    if (!msgMap || typeof msgMap !== "object") return ["", false];
+    const phase = typeof msgMap.phase === "string" ? msgMap.phase.trim() : "";
+    if (phase) return ["", false];
+    const msgType = typeof msgMap.type === "string" ? msgMap.type : "";
+    if (msgType && !isTerminalMessageType(msgType)) return ["", false];
+    const content = extractContentFromMessage(msgMap).trim();
+    if (!content) return ["", false];
+    return [content, true];
+  }
+  /** soothe output/responded events that carry user-facing final text. */
+  isFinalOutputEvent(dataType, ns) {
+    const combined = dataType + " " + ns;
+    if (combined.includes("final_report")) return true;
+    for (const phase of this.deliverablePhases) {
+      if (combined.includes(phase)) return true;
+    }
+    return false;
+  }
+};
+function isStreamingMessageType(msgType) {
+  return msgType === "AIMessageChunk" || msgType === "ai_chunk" || msgType === "message_chunk";
+}
+function isTerminalMessageType(msgType) {
+  return msgType === "AIMessage" || msgType === "ai" || msgType === "assistant";
+}
+function firstMessagePayload(data) {
+  if (!Array.isArray(data) || data.length === 0) return ["", "", "", false];
+  const msgMap = data[0];
+  if (!msgMap || typeof msgMap !== "object") return ["", "", "", false];
+  const msgType = typeof msgMap.type === "string" ? msgMap.type : "";
+  const phase = typeof msgMap.phase === "string" ? msgMap.phase : "";
+  const content = extractContentFromMessage(msgMap);
+  return [msgType, content, phase, true];
+}
+function loopAIMessage(data) {
+  if (!Array.isArray(data) || data.length === 0) return null;
+  const msgMap = data[0];
+  if (!msgMap || typeof msgMap !== "object") return null;
+  const phase = typeof msgMap.phase === "string" ? msgMap.phase.trim() : "";
+  if (!phase) return null;
+  const type = typeof msgMap.type === "string" ? msgMap.type : "";
+  const content = extractContentFromMessage(msgMap);
+  return { type, content, phase };
+}
+function extractContentFromMessage(msgMap) {
+  const c = msgMap.content;
+  if (typeof c === "string" && c) return c;
+  if (Array.isArray(c) && c.length > 0) {
+    let b = "";
+    for (const item of c) {
+      if (typeof item === "string") {
+        b += item;
+        continue;
+      }
+      if (item && typeof item === "object") {
+        const blk = item;
+        const t = blk.text;
+        if (typeof t === "string") b += t;
+      }
+    }
+    return b;
+  }
+  const blocks = msgMap.content_blocks;
+  if (Array.isArray(blocks) && blocks.length > 0) {
+    let b = "";
+    for (const blk of blocks) {
+      if (blk && typeof blk === "object") {
+        const m = blk;
+        const t = m.text;
+        if (typeof t === "string") b += t;
+      }
+    }
+    return b;
+  }
+  return "";
+}
+function extractContentFromData(data) {
+  for (const key of [
+    "final_stdout_message",
+    "completion_summary",
+    "content",
+    "text",
+    "response",
+    "output",
+    "message",
+    "report"
+  ]) {
+    const val = data[key];
+    if (typeof val === "string" && val) return [val, true];
+  }
+  const nested = data.data;
+  if (nested && typeof nested === "object") {
+    const nm = nested;
+    for (const key of [
+      "final_stdout_message",
+      "completion_summary",
+      "content",
+      "text",
+      "response",
+      "output",
+      "message",
+      "report"
+    ]) {
+      const val = nm[key];
+      if (typeof val === "string" && val) return [val, true];
+    }
+  }
+  return ["", false];
+}
+function isNamespaceMatch(ns, dataType, pattern) {
+  return dataType.includes(pattern) || ns.includes(pattern);
+}
+function namespaceToString(namespace) {
+  if (typeof namespace === "string") return namespace;
+  if (Array.isArray(namespace)) return namespace.filter((s) => typeof s === "string").join(".");
+  return "";
+}
+function normalizeEventData(data) {
+  if (data == null) return null;
+  if (typeof data === "object" && !Array.isArray(data)) {
+    return data;
+  }
+  if (typeof data === "string") {
+    try {
+      const m = JSON.parse(data);
+      if (m && typeof m === "object" && !Array.isArray(m)) return m;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/appkit/query_gate.ts
+var ErrQueryBusy = class extends Error {
+  constructor() {
+    super("appkit: query already in progress for session");
+    this.name = "ErrQueryBusy";
+  }
+};
+var QueryGate = class {
+  active = /* @__PURE__ */ new Map();
+  /** 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, abort, sendCancel) {
+    if (this.active.has(sessionID)) {
+      throw new ErrQueryBusy();
+    }
+    this.active.set(sessionID, { abort, sendCancel });
+  }
+  /**
+   * 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).
+   */
+  async cancel(sessionID) {
+    const state = this.active.get(sessionID);
+    if (!state) return;
+    this.active.delete(sessionID);
+    if (state.sendCancel) {
+      const detached = new AbortController();
+      const timer = setTimeout(() => detached.abort(), 1e4);
+      try {
+        await state.sendCancel(detached.signal);
+      } catch {
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    state.abort.abort();
+  }
+  /**
+   * 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) {
+    this.active.delete(sessionID);
+  }
+  /** Reports whether a query is in flight for sessionID. */
+  isActive(sessionID) {
+    return this.active.has(sessionID);
+  }
+};
+
+// src/appkit/pool.ts
+init_errors();
+init_config();
+
+// src/appkit/client.ts
+init_config();
+init_client();
+function defaultClientFactory() {
+  return (url, config) => {
+    return new Client(url, config ?? defaultConfig());
+  };
+}
+function defaultBootstrapFunc() {
+  return async (client, workspaceID, userID, config) => {
+    const c = client;
+    const opts = {
+      client_workspace: workspaceID,
+      user_id: userID,
+      client_workspace_id: workspaceID
+    };
+    return bootstrapLoopSession(c, "", config, opts);
+  };
+}
+
+// src/appkit/pool.ts
+var ErrPoolExhausted = class extends Error {
+  constructor() {
+    super("appkit: connection pool exhausted");
+    this.name = "ErrPoolExhausted";
+  }
+};
+function defaultPoolConfig() {
+  return {
+    poolSize: 1e3,
+    queryTimeout: 30 * 60 * 1e3,
+    connectionTimeout: 3e4,
+    maxIdleTime: 10 * 60 * 1e3,
+    healthCheckInterval: 3e4
+  };
+}
+var PooledConn = class {
+  slotID;
+  client;
+  eventStream = null;
+  streamController = null;
+  sessionID = "";
+  loopID = "";
+  workspaceID = "";
+  lastUsed = 0;
+  constructor(slotID, client) {
+    this.slotID = slotID;
+    this.client = client;
+  }
+  /** Reports whether the underlying client signalled a drop. */
+  isDisconnected() {
+    return this.client.isDisconnected();
+  }
+  isConnected() {
+    return this.client.isConnected() && !this.isDisconnected();
+  }
+  getLoopID() {
+    return this.loopID;
+  }
+};
+var ConnectionPool = class {
+  cfg;
+  scfg;
+  factory;
+  bootstrap;
+  store;
+  pool = [];
+  activeSlots = /* @__PURE__ */ new Map();
+  nextSlotID = 1;
+  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, store, cfg, scfg, factory) {
+    this.cfg = cfg ?? defaultPoolConfig();
+    this.scfg = scfg ?? defaultConfig();
+    this.factory = factory ?? defaultClientFactory();
+    this.bootstrap = defaultBootstrapFunc();
+    this.store = store;
+    this.url = url;
+    for (let i = 0; i < this.cfg.poolSize; i++) {
+      this.pool.push(new PooledConn(this.nextSlotID++, this.factory(url, this.scfg)));
+    }
+  }
+  /** Overrides the loop bootstrap function (useful for test fakes). */
+  withBootstrap(f) {
+    if (f) this.bootstrap = f;
+    return this;
+  }
+  /**
+   * 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).
+   */
+  async acquire(sessionID, workspaceID, userID, _signal) {
+    const existing = this.activeSlots.get(sessionID);
+    if (existing) {
+      if (existing.isDisconnected() || !existing.isConnected()) {
+        await this.release(sessionID);
+      } else {
+        existing.lastUsed = Date.now();
+        await this.store.updateLastUsed(sessionID).catch(() => {
+        });
+        return existing;
+      }
+    }
+    const conn = this.pool.pop();
+    if (!conn) throw new ErrPoolExhausted();
+    this.activeSlots.set(sessionID, conn);
+    const { loopID, ok } = await this.store.getLoopIDForSession(sessionID).catch(() => ({ loopID: "", ok: false }));
+    let finalLoopID = "";
+    try {
+      if (!ok || !loopID) {
+        await conn.client.connect();
+        finalLoopID = await this.bootstrapNew(conn, workspaceID, userID);
+        await this.store.createSession(workspaceID, sessionID, finalLoopID, "").catch(() => {
+        });
+      } else {
+        try {
+          await this.resumeAndReattach(conn, loopID);
+          finalLoopID = loopID;
+        } catch {
+          await conn.client.connect();
+          finalLoopID = await this.bootstrapNew(conn, workspaceID, userID);
+          await this.store.createSession(workspaceID, sessionID, finalLoopID, "").catch(() => {
+          });
+        }
+      }
+    } catch (err) {
+      await this.release(sessionID);
+      throw err;
+    }
+    conn.sessionID = sessionID;
+    conn.loopID = finalLoopID;
+    conn.workspaceID = workspaceID;
+    conn.lastUsed = Date.now();
+    await this.store.updateLastUsed(sessionID).catch(() => {
+    });
+    return conn;
+  }
+  /** Tears down the connection for sessionID and returns the slot. */
+  async release(sessionID) {
+    const conn = this.activeSlots.get(sessionID);
+    if (!conn) return;
+    this.activeSlots.delete(sessionID);
+    if (conn.streamController) {
+      conn.streamController.abort();
+      conn.streamController = null;
+    }
+    try {
+      conn.client.close();
+    } catch {
+    }
+    conn.sessionID = "";
+    conn.loopID = "";
+    conn.eventStream = null;
+    this.pool.push(new PooledConn(this.nextSlotID++, this.factory(this.url, this.scfg)));
+  }
+  /**
+   * 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.
+   */
+  async resetSession(sessionID) {
+    await this.release(sessionID);
+  }
+  /** Gracefully shuts down all active connections. */
+  stop() {
+    for (const [sid, conn] of this.activeSlots) {
+      if (conn.streamController) conn.streamController.abort();
+      try {
+        conn.client.close();
+      } catch {
+      }
+      this.activeSlots.delete(sid);
+    }
+  }
+  /** Stats snapshot for observability. */
+  stats() {
+    return { active: this.activeSlots.size, idle: this.pool.length };
+  }
+  /** Bootstrap a fresh loop and start the reader. */
+  async bootstrapNew(conn, workspaceID, userID) {
+    const loopID = await this.bootstrap(conn.client, workspaceID, userID, this.scfg);
+    this.startReader(conn);
+    return loopID;
+  }
+  /** Reconnect + reattach an existing loop, then start the reader. */
+  async resumeAndReattach(conn, loopID) {
+    await conn.client.connect();
+    try {
+      await conn.client.reattachAndProbe(loopID);
+    } catch (err) {
+      if (err instanceof StaleLoopError) throw err;
+      throw err;
+    }
+    this.startReader(conn);
+  }
+  /** Starts a receiveMessages generator and stores the stream + controller. */
+  startReader(conn) {
+    const controller = new AbortController();
+    conn.streamController = controller;
+    conn.eventStream = conn.client.receiveMessages(controller.signal);
+  }
+};
+
+// src/appkit/turn_runner.ts
+init_intent_hints();
+var ErrQueryTimeout = class extends Error {
+  constructor() {
+    super("appkit: query timeout");
+    this.name = "ErrQueryTimeout";
+  }
+};
+function inputMessageForLoop(text, loopID, attachments, opts) {
+  const msg = { type: "loop_input", content: text };
+  if (loopID) msg.loop_id = loopID;
+  if (attachments && attachments.length > 0) msg.attachments = attachments;
+  if (opts) {
+    if (opts.intentHint?.trim()) {
+      const hintError = validateLoopInputIntentHint(opts.intentHint);
+      if (hintError) {
+        throw new Error(hintError);
+      }
+      msg.intent_hint = opts.intentHint.trim();
+    }
+    if (opts.preferredSubagent?.trim()) msg.preferred_subagent = opts.preferredSubagent.trim();
+    if (opts.responseSchema && Object.keys(opts.responseSchema).length > 0) {
+      msg.response_schema = opts.responseSchema;
+    }
+    if (opts.responseSchemaName?.trim()) msg.response_schema_name = opts.responseSchemaName.trim();
+    if (opts.responseSchemaStrict !== void 0)
+      msg.response_schema_strict = opts.responseSchemaStrict;
+  }
+  return msg;
+}
+var TurnRunner = class {
+  pool;
+  gate;
+  classifier;
+  store;
+  broadcaster;
+  cfg;
+  buildInput = inputMessageForLoop;
+  onComplete = null;
+  onError = null;
+  /**
+   * Constructs a TurnRunner. pool, gate, classifier, and store are required;
+   * broadcaster may be null.
+   */
+  constructor(pool, gate, classifier, store, broadcaster, cfg) {
+    this.pool = pool;
+    this.gate = gate;
+    this.classifier = classifier;
+    this.store = store;
+    this.broadcaster = broadcaster;
+    this.cfg = { queryTimeout: cfg.queryTimeout > 0 ? cfg.queryTimeout : 30 * 60 * 1e3 };
+  }
+  /** Overrides the loop_input payload builder. */
+  withInputBuilder(f) {
+    if (f) this.buildInput = f;
+    return this;
+  }
+  /** Sets a completion hook (runs inline on success). */
+  withOnComplete(f) {
+    this.onComplete = f;
+    return this;
+  }
+  /** Sets an error hook (runs inline on failure). */
+  withOnError(f) {
+    this.onError = f;
+    return this;
+  }
+  /**
+   * 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).
+   */
+  async execute(sessionID, message, userID, workspaceID, attachments, opts, signal) {
+    let conn;
+    try {
+      conn = await this.pool.acquire(sessionID, workspaceID, userID, signal);
+    } catch (err) {
+      await this.persistFailed(sessionID, "", err);
+      this.broadcastError(sessionID, err);
+      this.onError?.(sessionID, "", err);
+      throw err;
+    }
+    const loopID = conn.getLoopID();
+    const timeoutController = new AbortController();
+    const timeoutMs = this.cfg.queryTimeout;
+    const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+    const sendCancel = async (detachedSignal) => {
+      await this.sendLoopCancel(detachedSignal, conn, loopID);
+    };
+    try {
+      this.gate.acquire(sessionID, timeoutController, sendCancel);
+    } catch (err) {
+      clearTimeout(timer);
+      await this.pool.release(sessionID);
+      await this.persistFailed(sessionID, loopID, err);
+      this.broadcastError(sessionID, err);
+      this.onError?.(sessionID, loopID, err);
+      throw err;
+    }
+    try {
+      const inputMsg = this.buildInput(
+        message,
+        loopID,
+        attachments ?? void 0,
+        opts ?? void 0
+      );
+      try {
+        await conn.client.sendMessage(inputMsg);
+      } catch (err) {
+        await this.persistFailed(sessionID, loopID, err);
+        this.broadcastError(sessionID, err);
+        this.onError?.(sessionID, loopID, err);
+        throw err;
+      }
+      const eventStream = conn.eventStream;
+      if (!eventStream) {
+        const err = new Error(`missing event stream for session ${sessionID} (loop ${loopID})`);
+        await this.persistFailed(sessionID, loopID, err);
+        this.broadcastError(sessionID, err);
+        this.onError?.(sessionID, loopID, err);
+        throw err;
+      }
+      let assistantContent = "";
+      const startedAt = Date.now();
+      const abortRace = new Promise((resolve) => {
+        const onTimeout = () => resolve("timeout");
+        timeoutController.signal.addEventListener("abort", onTimeout, { once: true });
+        if (signal) {
+          const onCaller = () => resolve("caller");
+          signal.addEventListener("abort", onCaller, { once: true });
+        }
+      });
+      const iterator = eventStream[Symbol.asyncIterator]();
+      while (true) {
+        const next = iterator.next();
+        const raced = await Promise.race([
+          next.then((res2) => ({ tag: "msg", res: res2 })),
+          abortRace.then((tag) => ({ tag }))
+        ]);
+        if ("tag" in raced && raced.tag !== "msg") {
+          if (raced.tag === "caller" || signal?.aborted) {
+            const err = new Error("aborted");
+            await this.persistFailed(sessionID, loopID, err);
+            this.broadcastError(sessionID, err);
+            this.onError?.(sessionID, loopID, err);
+            throw err;
+          }
+          await this.sendLoopCancel(new AbortController().signal, conn, loopID).catch(() => {
+          });
+          await this.persistFailed(sessionID, loopID, new ErrQueryTimeout());
+          this.broadcastError(sessionID, new ErrQueryTimeout());
+          this.onError?.(sessionID, loopID, new ErrQueryTimeout());
+          throw new ErrQueryTimeout();
+        }
+        const res = raced.res;
+        if (res.done) {
+          const err = new Error("event stream closed");
+          await this.persistFailed(sessionID, loopID, err);
+          this.broadcastError(sessionID, err);
+          this.onError?.(sessionID, loopID, err);
+          throw err;
+        }
+        const msg = res.value;
+        const eventResult = this.classifier.classify(msg, assistantContent);
+        if (eventResult.err && eventResult.terminal === 2 /* FailedComplete */) {
+          await this.persistFailed(sessionID, loopID, eventResult.err);
+          this.broadcastError(sessionID, eventResult.err);
+          this.onError?.(sessionID, loopID, eventResult.err);
+          throw eventResult.err;
+        }
+        const step = (eventResult.thinkingStep ?? "").trim();
+        if (step) this.broadcastThinkingStep(sessionID, step);
+        if (eventResult.content) {
+          if (eventResult.content.startsWith(assistantContent)) {
+            assistantContent = eventResult.content;
+          } else {
+            assistantContent += eventResult.content;
+          }
+        }
+        const [final, deliverable] = this.classifier.resolveDeliverableFinalContent(
+          eventResult,
+          assistantContent
+        );
+        if (deliverable) {
+          const elapsedMs = Date.now() - startedAt;
+          await this.persistResponse(
+            sessionID,
+            loopID,
+            final,
+            startedAt,
+            eventResult.completionEvent ?? ""
+          );
+          this.broadcastComplete(sessionID, final);
+          this.onComplete?.(sessionID, loopID, final, eventResult.completionEvent ?? "", elapsedMs);
+          return;
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+      this.gate.release(sessionID);
+    }
+  }
+  /** Asks the daemon to cooperatively stop the loop runner on a detached signal. */
+  async sendLoopCancel(_signal, conn, loopID) {
+    const lid = (loopID ?? "").trim();
+    if (!conn || !lid) return;
+    const cancelMsg = { type: "command_request", command: "cancel", loop_id: lid };
+    await conn.client.sendMessage(cancelMsg);
+  }
+  async persistResponse(sessionID, loopID, content, startedAt, completionEvent) {
+    const msg = {
+      role: "assistant",
+      content,
+      metadata: {
+        started_at: startedAt,
+        completed_at: Date.now(),
+        duration_ms: Date.now() - startedAt,
+        status: "completed",
+        completion_event: completionEvent,
+        deliverable: true
+      }
+    };
+    await this.store.appendMessage(sessionID, msg).catch(() => {
+    });
+  }
+  async persistFailed(sessionID, _loopID, err) {
+    const msg = {
+      role: "error",
+      content: err.message,
+      metadata: { status: "failed", error_message: err.message }
+    };
+    await this.store.appendMessage(sessionID, msg).catch(() => {
+    });
+  }
+  broadcastThinkingStep(sessionID, step) {
+    if (!this.broadcaster) return;
+    this.broadcaster.broadcast(sessionID, { type: "delta", data: step + "\n" });
+  }
+  broadcastComplete(sessionID, content) {
+    this.broadcaster?.broadcast(sessionID, { type: "complete", data: content });
+  }
+  broadcastError(sessionID, err) {
+    this.broadcaster?.broadcast(sessionID, { type: "query_error", data: err.message });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CLIENT_VERSION,
+  ChatEventTerminal,
   Client,
   ConnectionError,
+  ConnectionPool,
+  DEFAULT_CLIENT_CAPABILITIES,
+  DEFAULT_DELIVERABLE_PHASES,
+  DEFAULT_THINKING_STEP_EVENTS,
   DaemonError,
-  ESSENTIAL_EVENT_TYPES,
-  EventAgentLoopCompleted,
-  EventAgentLoopIterated,
-  EventAgentLoopReasoned,
-  EventAgentLoopStarted,
+  DisconnectCause,
+  ErrPoolExhausted,
+  ErrQueryBusy,
+  ErrQueryTimeout,
+  EventAutopilotGoalCompleted,
+  EventAutopilotGoalCreated,
+  EventAutopilotGoalProgress,
+  EventAutopilotGoalStatus,
+  EventAutopilotWorkerAssigned,
+  EventAutopilotWorkerUnassigned,
+  EventCardCreated,
+  EventCardReplayBegin,
+  EventCardReplayEnd,
+  EventClassifier,
   EventExploreCompleted,
   EventExploreMilestone,
   EventExploreStarted,
@@ -1087,6 +3010,14 @@ async function connectWithRetries(client, maxRetries, retryDelay) {
   EventMessageSent,
   EventPlanCreated,
   EventReplayComplete,
+  EventStrangeLoopCompleted,
+  EventStrangeLoopContextCompacted,
+  EventStrangeLoopPlanDecision,
+  EventStrangeLoopReasoned,
+  EventStrangeLoopStarted,
+  EventStrangeLoopStepCompleted,
+  EventStrangeLoopStepQueued,
+  EventStrangeLoopStepStarted,
   EventStreamToolCallUpdate,
   EventTacitusCompleted,
   EventTacitusGatherSummary,
@@ -1095,18 +3026,42 @@ async function connectWithRetries(client, maxRetries, retryDelay) {
   EventToolCompleted,
   EventToolError,
   EventToolStarted,
+  INTENT_HINT_EMBED,
+  INTENT_HINT_IMAGE_TO_TEXT,
+  INTENT_HINT_OCR,
+  INTENT_HINT_TEXT_COMPLETION,
+  LOOP_ASSISTANT_OUTPUT_PHASES,
+  Multiplexer,
+  PROTO_VERSION,
+  PooledConn,
+  QueryGate,
+  REMOVED_INTENT_HINTS,
+  ReconnectError,
+  SSEBroadcaster,
+  StaleLoopError,
   TimeoutError,
+  TurnRunner,
   VerbosityTier,
+  authenticate,
   bootstrapLoopSession,
   checkDaemonStatus,
   classifyEventVerbosity,
   connectWithRetries,
+  connectionInitEnvelope,
   decodeMessage,
+  defaultBootstrapFunc,
+  defaultClientFactory,
   defaultConfig,
+  defaultPoolConfig,
+  disconnectCauseName,
+  disconnectEnvelope,
   encodeMessage,
   extractSootheLoopID,
+  extractThinkingStep,
   fetchConfigSection,
+  fetchLoopHistory,
   fetchSkillsCatalog,
+  inputMessageForLoop,
   isCompletionEvent,
   isDaemonLive,
   isSubagentProgressEvent,
@@ -1116,10 +3071,19 @@ async function connectWithRetries(client, maxRetries, retryDelay) {
   newLoopNewMessage,
   newLoopSubscribeMessage,
   newRequestID,
+  notificationEnvelope,
   parseNamespace,
+  pingEnvelope,
+  pongEnvelope,
+  refreshAuthToken,
+  requestDaemonConfigReload,
   requestDaemonShutdown,
+  requestEnvelope,
   shouldShow,
   splitWirePayload,
+  subscribeEnvelope,
+  unsubscribeEnvelope,
+  validateLoopInputIntentHint,
   waitDaemonReady,
   waitLoopStatusWithID,
   waitSubscriptionConfirmed