@mirasoth/soothe-client 0.1.0 → 0.4.0

package/dist/index.cjs

@@ -30,6 +30,113 @@ 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/verbosity.ts
+function shouldShow(tier, verbosity) {
+  if (tier === 99 /* Internal */) {
+    return false;
+  }
+  const level = verbosityLevelValues[verbosity] ?? 1;
+  return tier <= level;
+}
+function isValidVerbosityLevel(s) {
+  return s in verbosityLevelValues;
+}
+var VerbosityTier, verbosityLevelValues;
+var init_verbosity = __esm({
+  "src/verbosity.ts"() {
+    "use strict";
+    VerbosityTier = /* @__PURE__ */ ((VerbosityTier2) => {
+      VerbosityTier2[VerbosityTier2["Quiet"] = 0] = "Quiet";
+      VerbosityTier2[VerbosityTier2["Normal"] = 1] = "Normal";
+      VerbosityTier2[VerbosityTier2["Detailed"] = 2] = "Detailed";
+      VerbosityTier2[VerbosityTier2["Debug"] = 3] = "Debug";
+      VerbosityTier2[VerbosityTier2["Internal"] = 99] = "Internal";
+      return VerbosityTier2;
+    })(VerbosityTier || {});
+    verbosityLevelValues = {
+      quiet: 0,
+      normal: 1,
+      debug: 3
+    };
+  }
+});
+
 // src/config.ts
 function defaultConfig() {
   return {
@@ -40,7 +147,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 +201,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 +293,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 +319,552 @@ 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.4.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/events.ts
+function parseNamespace(ns) {
+  const parts = splitNamespace(ns);
+  if (parts.length < 4 || parts[0] !== "soothe") {
+    return null;
+  }
+  if (parts[1] === "internal") {
+    return null;
+  }
+  return { domain: parts[1], component: parts[2], action: parts[3] };
+}
+function splitNamespace(ns) {
+  const parts = [];
+  let start = 0;
+  for (let i = 0; i < ns.length; i++) {
+    if (ns[i] === ".") {
+      parts.push(ns.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(ns.slice(start));
+  return parts;
+}
+function classifyEventVerbosity(eventTypeOrNamespace) {
+  const parsed = parseNamespace(eventTypeOrNamespace);
+  if (!parsed) {
+    return classifyByEventTypeString(eventTypeOrNamespace);
+  }
+  return classifyByDomainAndComponent(parsed.domain, parsed.component, eventTypeOrNamespace);
+}
+function classifyByDomainAndComponent(domain, _component, full) {
+  switch (domain) {
+    case "cognition":
+      return 1 /* Normal */;
+    case "protocol":
+      return 2 /* Detailed */;
+    case "tool":
+      return 99 /* Internal */;
+    case "subagent":
+      return classifySubagentEvent(full);
+    case "autopilot":
+      return 1 /* Normal */;
+    case "output":
+    case "error":
+      return 0 /* Quiet */;
+    default:
+      return 1 /* Normal */;
+  }
+}
+function classifySubagentEvent(full) {
+  const parsed = parseNamespace(full);
+  if (!parsed) return 1 /* Normal */;
+  switch (parsed.action) {
+    case "started":
+    case "completed":
+      return 1 /* Normal */;
+    default:
+      return 2 /* Detailed */;
+  }
+}
+function classifyByEventTypeString(eventType) {
+  if (eventType === EventFinalReport || eventType === EventGeneralFailed) {
+    return 0 /* Quiet */;
+  }
+  if (eventType === EventToolStarted) {
+    return 99 /* Internal */;
+  }
+  return 1 /* Normal */;
+}
+function isCompletionEvent(eventType) {
+  return eventType.endsWith(".completed") || eventType.endsWith(".failed") || eventType === EventGeneralFailed;
+}
+function isSubagentProgressEvent(eventType) {
+  const parsed = parseNamespace(eventType);
+  if (!parsed || parsed.domain !== "subagent") {
+    return false;
+  }
+  return parsed.action === "started" || parsed.action === "completed";
+}
+var EventPlanCreated, EventExploreStarted, EventExploreMilestone, EventExploreStepCompleted, EventExploreCompleted, EventTacitusStarted, EventTacitusGatherSummary, EventTacitusCompleted, EventReplayComplete, EventLoopReattachedWire, EventCardReplayBegin, EventCardCreated, EventCardReplayEnd, EventToolStarted, EventToolCompleted, EventToolError, EventStreamToolCallUpdate, EventToolCallUpdatesBatch, EventStrangeLoopStarted, EventStrangeLoopCompleted, EventStrangeLoopPlanDecision, EventStrangeLoopReasoned, EventStrangeLoopStepStarted, EventStrangeLoopStepQueued, EventStrangeLoopStepCompleted, EventStrangeLoopContextCompacted, EventMessageReceived, EventMessageSent, EventFinalReport, EventAutopilotGoalStatus, EventAutopilotGoalProgress, EventAutopilotGoalCreated, EventAutopilotGoalCompleted, EventAutopilotWorkerAssigned, EventAutopilotWorkerUnassigned, EventGeneralFailed;
+var init_events = __esm({
+  "src/events.ts"() {
+    "use strict";
+    init_verbosity();
+    EventPlanCreated = "soothe.cognition.plan.created";
+    EventExploreStarted = "soothe.subagent.explore.started";
+    EventExploreMilestone = "soothe.subagent.explore.milestone";
+    EventExploreStepCompleted = "soothe.subagent.explore.step.completed";
+    EventExploreCompleted = "soothe.subagent.explore.completed";
+    EventTacitusStarted = "soothe.subagent.tacitus.started";
+    EventTacitusGatherSummary = "soothe.subagent.tacitus.gather.summary";
+    EventTacitusCompleted = "soothe.subagent.tacitus.completed";
+    EventReplayComplete = "replay_complete";
+    EventLoopReattachedWire = "loop_reattached";
+    EventCardReplayBegin = "card.replay_begin";
+    EventCardCreated = "card.created";
+    EventCardReplayEnd = "card.replay_end";
+    EventToolStarted = "soothe.tool.execution.started";
+    EventToolCompleted = "soothe.tool.execution.completed";
+    EventToolError = "soothe.tool.execution.error";
+    EventStreamToolCallUpdate = "soothe.stream.tool_call.update";
+    EventToolCallUpdatesBatch = "tool_call_updates_batch";
+    EventStrangeLoopStarted = "soothe.cognition.strange_loop.started";
+    EventStrangeLoopCompleted = "soothe.cognition.strange_loop.completed";
+    EventStrangeLoopPlanDecision = "soothe.cognition.strange_loop.plan.decision";
+    EventStrangeLoopReasoned = "soothe.cognition.strange_loop.reasoned";
+    EventStrangeLoopStepStarted = "soothe.cognition.strange_loop.step.started";
+    EventStrangeLoopStepQueued = "soothe.cognition.strange_loop.step.queued";
+    EventStrangeLoopStepCompleted = "soothe.cognition.strange_loop.step.completed";
+    EventStrangeLoopContextCompacted = "soothe.cognition.strange_loop.context.compacted";
+    EventMessageReceived = "soothe.protocol.message.received";
+    EventMessageSent = "soothe.protocol.message.sent";
+    EventFinalReport = "soothe.output.autonomous.final_report.reported";
+    EventAutopilotGoalStatus = "soothe.autopilot.goal.status";
+    EventAutopilotGoalProgress = "soothe.autopilot.goal.progress";
+    EventAutopilotGoalCreated = "soothe.autopilot.goal.created";
+    EventAutopilotGoalCompleted = "soothe.autopilot.goal.completed";
+    EventAutopilotWorkerAssigned = "soothe.autopilot.worker.assigned";
+    EventAutopilotWorkerUnassigned = "soothe.autopilot.worker.unassigned";
+    EventGeneralFailed = "soothe.error.general.failed";
+  }
+});
+
+// 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);
+      }
+    };
+  }
+});
+
+// src/stream_terminal.ts
+function isTurnEndCustomData(data) {
+  if (!data || typeof data !== "object") return false;
+  const customType = String(data.type ?? "").trim();
+  if (!TURN_END_CUSTOM_TYPES.has(customType)) return false;
+  if (customType === STREAM_END) {
+    const scope = String(data.scope ?? "turn").trim().toLowerCase();
+    return scope === "" || scope === "turn";
+  }
+  return true;
+}
+function isTurnProgressChunk(mode, data) {
+  if (mode === "messages" || mode === "updates") return true;
+  if (mode !== "custom" || !data || typeof data !== "object") return false;
+  if (isTurnEndCustomData(data)) return false;
+  const customType = String(data.type ?? "").trim();
+  if (TURN_PROGRESS_CUSTOM_TYPES.has(customType)) return true;
+  if (customType.startsWith("soothe.cognition.strange_loop.step")) return true;
+  return false;
+}
+function stalePendingFrameLabel(event) {
+  const eventType = String(event.type ?? "");
+  if (STALE_TURN_PENDING_TYPES.has(eventType)) return eventType;
+  if (eventType === "next") {
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object") return null;
+    const p = payload;
+    const staleMode = String(p.mode ?? "");
+    if (STALE_TURN_PENDING_TYPES.has(staleMode)) return staleMode;
+    const inner = p.data;
+    if (inner && typeof inner === "object") {
+      return stalePendingFrameLabel(inner);
+    }
+    return null;
+  }
+  if (eventType === "event") {
+    const mode = String(event.mode ?? "");
+    const data = event.data;
+    if (mode === "custom" && isTurnEndCustomData(data)) {
+      return String(data.type ?? "").trim();
+    }
+  }
+  return null;
+}
+function inboundNeedsDeliveryAck(event) {
+  const eventType = String(event.type ?? "");
+  if (eventType === "complete") return true;
+  if (eventType === "next") {
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object") return false;
+    const p = payload;
+    const inner = p.data;
+    if (!inner || typeof inner !== "object") return false;
+    if (String(p.mode ?? "") === "event") {
+      return inboundNeedsAckFromEventShape(inner);
+    }
+    return false;
+  }
+  if (eventType === "event") return inboundNeedsAckFromEventShape(event);
+  return false;
+}
+function inboundNeedsAckFromEventShape(event) {
+  const mode = String(event.mode ?? "");
+  const data = event.data;
+  if (mode === "custom" && isTurnEndCustomData(data)) return true;
+  if (mode === "messages" && Array.isArray(data) && data.length > 0) {
+    const body = data[0];
+    if (!body || typeof body !== "object") return false;
+    const t = String(body.type ?? "");
+    return t === STREAM_END || t.includes("stream.end");
+  }
+  return false;
+}
+function extractLoopIdFromInbound(event) {
+  const direct = String(event.loop_id ?? "").trim();
+  if (direct) return direct;
+  if (String(event.type ?? "") !== "next") return "";
+  const payload = event.payload;
+  if (!payload || typeof payload !== "object") return "";
+  const p = payload;
+  const fromPayload = String(p.loop_id ?? "").trim();
+  if (fromPayload) return fromPayload;
+  const inner = p.data;
+  if (inner && typeof inner === "object") {
+    return String(inner.loop_id ?? "").trim();
+  }
+  return "";
+}
+var STREAM_END, TURN_END_CUSTOM_TYPES, TURN_PROGRESS_CUSTOM_TYPES, STALE_TURN_PENDING_TYPES;
+var init_stream_terminal = __esm({
+  "src/stream_terminal.ts"() {
+    "use strict";
+    init_events();
+    STREAM_END = "soothe.stream.end";
+    TURN_END_CUSTOM_TYPES = /* @__PURE__ */ new Set([
+      STREAM_END,
+      EventStrangeLoopCompleted
+    ]);
+    TURN_PROGRESS_CUSTOM_TYPES = /* @__PURE__ */ new Set([
+      EventPlanCreated,
+      EventStrangeLoopStepStarted,
+      EventStrangeLoopStepQueued,
+      EventStrangeLoopStepCompleted
+    ]);
+    STALE_TURN_PENDING_TYPES = /* @__PURE__ */ new Set([
+      "connection_ack",
+      EventCardReplayBegin,
+      EventCardReplayEnd,
+      EventCardCreated,
+      "complete"
+    ]);
+  }
+});
+
+// src/inbound_priority.ts
+function inboundFrameDropPriority(event) {
+  if (!event) return DROP_PRIORITY_CRITICAL;
+  let eventType = String(event.type ?? "");
+  if (eventType === "event_batch" || eventType === "tool_call_updates_batch") {
+    return DROP_PRIORITY_HIGH;
+  }
+  if (eventType === "next") {
+    const payload = event.payload;
+    if (payload && typeof payload === "object") {
+      const p = payload;
+      const innerMode = String(p.mode ?? "");
+      const innerData = p.data;
+      if (innerMode === "messages") {
+        if (messagesWireTerminal(innerData)) return DROP_PRIORITY_CRITICAL;
+        if (Array.isArray(innerData) && innerData[0] && typeof innerData[0] === "object") {
+          if (String(innerData[0].phase ?? "") === "goal_completion") {
+            return DROP_PRIORITY_CRITICAL;
+          }
+        }
+      }
+      if (String(p.type ?? "") === "complete") return DROP_PRIORITY_CRITICAL;
+      if (innerData && typeof innerData === "object") {
+        return inboundFrameDropPriority(innerData);
+      }
+      eventType = String(p.type ?? "");
+    }
+  }
+  if (eventType === "complete" || eventType === "error" || eventType === "connection_ack") {
+    return DROP_PRIORITY_CRITICAL;
+  }
+  if (eventType === "status") {
+    const state = String(event.state ?? "");
+    if (["idle", "running", "stopped", "detached"].includes(state)) {
+      return DROP_PRIORITY_CRITICAL;
+    }
+  }
+  if (eventType === "event") {
+    const mode = String(event.mode ?? "");
+    const data = event.data;
+    if (mode === "custom") {
+      if (isTurnEndCustomData(data)) return DROP_PRIORITY_CRITICAL;
+      if (data && typeof data === "object") {
+        const customType = String(data.type ?? "");
+        if (customType.startsWith("soothe.cognition.")) return DROP_PRIORITY_HIGH;
+        if (customType.startsWith("soothe.error.") || customType === "stream_degraded") {
+          return DROP_PRIORITY_CRITICAL;
+        }
+        if (customType === "soothe.ux.stream_tool_wire.tool_call_updates_batch") {
+          return DROP_PRIORITY_HIGH;
+        }
+      }
+    }
+    if (mode === "messages") {
+      if (messagesWireTerminal(data)) return DROP_PRIORITY_CRITICAL;
+      if (Array.isArray(data) && data[0] && typeof data[0] === "object") {
+        if (String(data[0].phase ?? "") === "goal_completion") {
+          return DROP_PRIORITY_CRITICAL;
+        }
+      }
+    }
+  }
+  return DROP_PRIORITY_NORMAL;
+}
+function messagesWireTerminal(data) {
+  if (!Array.isArray(data) || data.length === 0) return false;
+  const body = data[0];
+  if (!body || typeof body !== "object") return false;
+  const t = String(body.type ?? "");
+  return t === STREAM_END || t.includes("stream.end");
+}
+var DROP_PRIORITY_CRITICAL, DROP_PRIORITY_HIGH, DROP_PRIORITY_NORMAL, DEFAULT_INBOUND_MAX_SIZE;
+var init_inbound_priority = __esm({
+  "src/inbound_priority.ts"() {
+    "use strict";
+    init_stream_terminal();
+    DROP_PRIORITY_CRITICAL = 0;
+    DROP_PRIORITY_HIGH = 1;
+    DROP_PRIORITY_NORMAL = 2;
+    DEFAULT_INBOUND_MAX_SIZE = 2e4;
   }
 });
 
@@ -278,13 +880,39 @@ 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_stream_terminal();
+    init_inbound_priority();
     init_protocol();
     Client = class extends import_node_events.EventEmitter {
       url;
       config;
       ws = null;
       messageBuffer = [];
+      inboundMaxSize = DEFAULT_INBOUND_MAX_SIZE;
+      inboundDroppedCount = 0;
+      onStreamDegraded = null;
       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();
+      deliveryRecvSeq = /* @__PURE__ */ new Map();
+      deliveryAckedSeq = /* @__PURE__ */ new Map();
       constructor(url, config) {
         super();
         this.url = url;
@@ -293,7 +921,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 +932,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 +960,44 @@ 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)) {
+                this._trackInboundDeliveryAck(m);
+                continue;
+              }
+              this._trackInboundDeliveryAck(m);
+              const resolver = this.resolvers.shift();
+              if (resolver) {
+                resolver(msg);
+              } else {
+                this.enqueueMessageBuffer(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 +1006,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 +1226,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 +1281,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();
@@ -415,270 +1301,598 @@ var init_client = __esm({
           this.resolvers.push(resolver);
         });
       }
+      /**
+       * Remove stale handshake/terminal frames left in `messageBuffer` before a turn.
+       * Returns labels of removed frames (in order).
+       */
+      peelStalePendingControlEvents() {
+        if (this.messageBuffer.length === 0) return [];
+        const kept = [];
+        const removed = [];
+        while (this.messageBuffer.length > 0) {
+          const event = this.messageBuffer.shift();
+          const label = stalePendingFrameLabel(event);
+          if (label !== null) {
+            removed.push(label);
+            continue;
+          }
+          kept.push(event);
+        }
+        this.messageBuffer = kept;
+        return removed;
+      }
+      /** True when the underlying socket is still open (may not be handshaked). */
+      isConnectionAlive() {
+        return this.ws !== null && this.ws.readyState === import_ws.default.OPEN;
+      }
+      /** Override pending buffer cap (tests / tuning). */
+      setInboundMaxSize(n) {
+        if (n > 0) this.inboundMaxSize = n;
+      }
+      /** How many NORMAL-priority frames were dropped under backpressure. */
+      inboundDropped() {
+        return this.inboundDroppedCount;
+      }
+      /** Hook invoked on the first inbound overflow drop. */
+      setStreamDegradedCallback(fn) {
+        this.onStreamDegraded = fn;
+      }
+      enqueueMessageBuffer(msg) {
+        const max = this.inboundMaxSize > 0 ? this.inboundMaxSize : DEFAULT_INBOUND_MAX_SIZE;
+        if (this.messageBuffer.length < max) {
+          this.messageBuffer.push(msg);
+          return;
+        }
+        const ev = msg;
+        let dropIdx = -1;
+        let dropPri = -1;
+        for (let i = 0; i < this.messageBuffer.length; i++) {
+          const p = inboundFrameDropPriority(this.messageBuffer[i]);
+          if (p > dropPri) {
+            dropPri = p;
+            dropIdx = i;
+          }
+        }
+        const incomingPri = inboundFrameDropPriority(ev);
+        if (dropIdx >= 0 && dropPri >= DROP_PRIORITY_NORMAL) {
+          this.messageBuffer.splice(dropIdx, 1);
+          this.messageBuffer.push(msg);
+          this.noteInboundDrop();
+          return;
+        }
+        if (incomingPri >= DROP_PRIORITY_NORMAL) {
+          this.noteInboundDrop();
+          return;
+        }
+        if (this.messageBuffer.length > 0) {
+          this.messageBuffer.shift();
+          this.noteInboundDrop();
+        }
+        this.messageBuffer.push(msg);
+      }
+      noteInboundDrop() {
+        this.inboundDroppedCount += 1;
+        if (this.onStreamDegraded && this.inboundDroppedCount === 1) {
+          try {
+            this.onStreamDegraded(1, "inbound_queue_overflow");
+          } catch {
+          }
+        }
+      }
+      // ---------------------------------------------------------------------------
+      // 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));
+      }
+      _trackInboundDeliveryAck(event) {
+        if (String(event.type ?? "") === "event_batch") {
+          const events = event.events;
+          if (Array.isArray(events)) {
+            for (const sub of events) {
+              if (sub && typeof sub === "object") {
+                this._trackInboundDeliveryAck(sub);
+              }
+            }
+          }
+          return;
+        }
+        if (!inboundNeedsDeliveryAck(event)) return;
+        const loopId = extractLoopIdFromInbound(event);
+        if (!loopId) return;
+        const next = (this.deliveryRecvSeq.get(loopId) ?? 0) + 1;
+        this.deliveryRecvSeq.set(loopId, next);
+        void this._sendDeliveryAck(loopId, next);
+      }
+      async _sendDeliveryAck(loopId, seq) {
+        const acked = this.deliveryAckedSeq.get(loopId) ?? 0;
+        if (seq <= acked) return;
+        this.deliveryAckedSeq.set(loopId, seq);
+        if (!this.isConnected()) return;
+        try {
+          await this.notify("delivery_ack", { loop_id: loopId, seq });
+        } catch {
+        }
+      }
+      /**
+       * 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.enqueueMessageBuffer(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()
-        });
-      }
-      // ---------------------------------------------------------------------------
-      // Loop management RPC methods (RFC-504)
-      // ---------------------------------------------------------------------------
-      /** 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 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 reattachment to a loop with history replay. */
-      sendLoopReattach(loopID, requestID) {
-        return this.sendMessage({
-          type: "loop_reattach",
-          loop_id: loopID,
-          request_id: requestID ?? newRequestID()
-        });
-      }
-      // ---------------------------------------------------------------------------
-      // Skills and models
-      // ---------------------------------------------------------------------------
-      /** Requests the skills catalog (RFC-400). */
-      sendSkillsList(requestID) {
-        return this.sendMessage({
-          type: "skills_list",
-          request_id: requestID ?? newRequestID()
-        });
-      }
-      /** Requests the models catalog (RFC-400). */
-      sendModelsList(requestID) {
-        return this.sendMessage({
-          type: "models_list",
-          request_id: requestID ?? newRequestID()
-        });
-      }
-      /** 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);
-      }
-      // ---------------------------------------------------------------------------
-      // 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}`);
+      sendConfigGet(section) {
+        return this.sendMessage(requestEnvelope("config_get", { section }));
       }
       // ---------------------------------------------------------------------------
-      // Convenience RPC methods
+      // Convenience RPC methods (blocking request/response)
       // ---------------------------------------------------------------------------
       /** Requests the skills catalog and waits for the response. */
       listSkills(timeout) {
-        return this.requestResponse({ type: "skills_list" }, "skills_list_response", timeout ?? 15e3);
+        return this.requestResponse("skills_list", {}, "skills_list", timeout ?? 15e3);
       }
       /** Requests the models catalog and waits for the response. */
       listModels(timeout) {
-        return this.requestResponse({ type: "models_list" }, "models_list_response", timeout ?? 15e3);
+        return this.requestResponse("models_list", {}, "models_list", timeout ?? 15e3);
       }
-      /** Invokes a skill on the daemon host and receives echo (RFC-400). */
+      /** Invokes a skill on the daemon host and receives echo. */
       invokeSkill(skill, args, timeout) {
-        return this.requestResponse({ type: "invoke_skill", skill, args }, "invoke_skill_response", timeout ?? 12e4);
+        const params = { skill, args: args ?? "" };
+        return this.requestResponse("invoke_skill", params, "invoke_skill", timeout ?? 12e4);
       }
       /** Requests loop list and waits for response. */
-      listLoops(timeout) {
-        return this.requestResponse({ type: "loop_list" }, "loop_list_response", timeout ?? 15e3);
+      listLoops(timeout, workspace) {
+        const params = {};
+        if (workspace) params.filter = { workspace };
+        return this.requestResponse("loop_list", params, "loop_list", 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);
+        return this.requestResponse("loop_get", { loop_id: loopID }, "loop_get", 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);
+        return this.requestResponse("loop_tree", { loop_id: loopID }, "loop_tree", 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);
+        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
+        );
       }
       // ---------------------------------------------------------------------------
-      // Wait helpers
+      // RFC-228 Job IPC methods
+      // ---------------------------------------------------------------------------
+      /** 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);
+      }
+      /** Queries job status and waits for the response. */
+      getJobStatus(jobId, timeout) {
+        return this.requestResponse("job_status", { job_id: jobId }, "job_status", timeout ?? 15e3);
+      }
+      /** Pauses a running job. */
+      pauseJob(jobId, timeout) {
+        return this.requestResponse("job_pause", { job_id: jobId }, "job_pause", timeout ?? 15e3);
+      }
+      /** Resumes a paused job. */
+      resumeJob(jobId, timeout) {
+        return this.requestResponse("job_resume", { job_id: jobId }, "job_resume", timeout ?? 15e3);
+      }
+      /** Cancels a job. */
+      cancelJob(jobId, timeout) {
+        return this.requestResponse("job_cancel", { job_id: jobId }, "job_cancel", timeout ?? 15e3);
+      }
+      /** Requests the DAG visualization for a job. */
+      getJobDag(jobId, timeout) {
+        return this.requestResponse("job_dag", { job_id: jobId }, "job_dag", 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);
+      }
       // ---------------------------------------------------------------------------
-      /** Reads events until a daemon_ready with state == "ready". */
+      // 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);
+      }
+      // ---------------------------------------------------------------------------
+      // 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 +1901,33 @@ var init_client = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CLIENT_VERSION: () => CLIENT_VERSION,
+  ChatEventTerminal: () => ChatEventTerminal,
   Client: () => Client,
+  CommandClient: () => CommandClient,
   ConnectionError: () => ConnectionError,
+  ConnectionPool: () => ConnectionPool,
+  DEFAULT_CLIENT_CAPABILITIES: () => DEFAULT_CLIENT_CAPABILITIES,
+  DEFAULT_DELIVERABLE_PHASES: () => DEFAULT_DELIVERABLE_PHASES,
+  DEFAULT_POST_IDLE_DRAIN_MS: () => DEFAULT_POST_IDLE_DRAIN_MS,
+  DEFAULT_THINKING_STEP_EVENTS: () => DEFAULT_THINKING_STEP_EVENTS,
   DaemonError: () => DaemonError,
-  ESSENTIAL_EVENT_TYPES: () => ESSENTIAL_EVENT_TYPES,
-  EventAgentLoopCompleted: () => EventAgentLoopCompleted,
-  EventAgentLoopIterated: () => EventAgentLoopIterated,
-  EventAgentLoopReasoned: () => EventAgentLoopReasoned,
-  EventAgentLoopStarted: () => EventAgentLoopStarted,
+  DaemonSession: () => DaemonSession,
+  DisconnectCause: () => DisconnectCause,
+  ErrIdleTimeout: () => ErrIdleTimeout,
+  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 +1939,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,220 +1955,247 @@ __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,
+  PROTO_VERSION: () => PROTO_VERSION,
+  PooledConn: () => PooledConn,
+  QueryGate: () => QueryGate,
+  REMOVED_INTENT_HINTS: () => REMOVED_INTENT_HINTS,
+  ReconnectError: () => ReconnectError,
+  SSEBroadcaster: () => SSEBroadcaster,
+  STREAM_END: () => STREAM_END,
+  StaleLoopError: () => StaleLoopError,
+  StreamCloseFail: () => StreamCloseFail,
+  StreamCloseSoftComplete: () => StreamCloseSoftComplete,
   TimeoutError: () => TimeoutError,
+  TimeoutPolicy: () => TimeoutPolicy,
+  TurnEventStats: () => TurnEventStats,
+  TurnRunner: () => TurnRunner,
   VerbosityTier: () => VerbosityTier,
+  authenticate: () => authenticate,
   bootstrapLoopSession: () => bootstrapLoopSession,
   checkDaemonStatus: () => checkDaemonStatus,
   classifyEventVerbosity: () => classifyEventVerbosity,
+  compactAttachments: () => compactAttachments,
+  compactImageAttachment: () => compactImageAttachment,
   connectWithRetries: () => connectWithRetries,
+  connectedWebsocket: () => connectedWebsocket,
+  connectionInitEnvelope: () => connectionInitEnvelope,
   decodeMessage: () => decodeMessage,
   defaultConfig: () => defaultConfig,
+  defaultPoolConfig: () => defaultPoolConfig,
+  disconnectCauseName: () => disconnectCauseName,
+  disconnectEnvelope: () => disconnectEnvelope,
   encodeMessage: () => encodeMessage,
   extractSootheLoopID: () => extractSootheLoopID,
+  extractThinkingStep: () => extractThinkingStep,
   fetchConfigSection: () => fetchConfigSection,
+  fetchLoopCards: () => fetchLoopCards,
+  fetchLoopHistory: () => fetchLoopHistory,
+  fetchLoopMessages: () => fetchLoopMessages,
   fetchSkillsCatalog: () => fetchSkillsCatalog,
+  idleTimeoutForTurn: () => idleTimeoutForTurn,
+  inboundNeedsDeliveryAck: () => inboundNeedsDeliveryAck,
+  inputMessageForLoop: () => inputMessageForLoop,
   isCompletionEvent: () => isCompletionEvent,
   isDaemonLive: () => isDaemonLive,
   isSubagentProgressEvent: () => isSubagentProgressEvent,
+  isTurnEndCustomData: () => isTurnEndCustomData,
+  isTurnProgressChunk: () => isTurnProgressChunk,
   isValidVerbosityLevel: () => isValidVerbosityLevel,
   loadConfigFromEnv: () => loadConfigFromEnv,
   newLoopInputMessage: () => newLoopInputMessage,
   newLoopNewMessage: () => newLoopNewMessage,
   newLoopSubscribeMessage: () => newLoopSubscribeMessage,
   newRequestID: () => newRequestID,
+  notificationEnvelope: () => notificationEnvelope,
   parseNamespace: () => parseNamespace,
+  pingEnvelope: () => pingEnvelope,
+  pongEnvelope: () => pongEnvelope,
+  protocol1Rpc: () => protocol1Rpc,
+  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);
+init_errors();
+init_verbosity();
+init_config();
+init_protocol();
+init_intent_hints();
+init_events();
+init_client();
 
-// 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;
-  }
-};
+// src/command_client.ts
+init_client();
+init_config();
 
-// src/verbosity.ts
-var VerbosityTier = /* @__PURE__ */ ((VerbosityTier2) => {
-  VerbosityTier2[VerbosityTier2["Quiet"] = 0] = "Quiet";
-  VerbosityTier2[VerbosityTier2["Normal"] = 1] = "Normal";
-  VerbosityTier2[VerbosityTier2["Detailed"] = 2] = "Detailed";
-  VerbosityTier2[VerbosityTier2["Debug"] = 3] = "Debug";
-  VerbosityTier2[VerbosityTier2["Internal"] = 99] = "Internal";
-  return VerbosityTier2;
-})(VerbosityTier || {});
-var verbosityLevelValues = {
-  quiet: 0,
-  normal: 1,
-  debug: 3
-};
-function shouldShow(tier, verbosity) {
-  if (tier === 99 /* Internal */) {
-    return false;
-  }
-  const level = verbosityLevelValues[verbosity] ?? 1;
-  return tier <= level;
-}
-function isValidVerbosityLevel(s) {
-  return s in verbosityLevelValues;
-}
-
-// src/index.ts
+// src/session.ts
 init_config();
 init_protocol();
-
-// src/events.ts
-var EventPlanCreated = "soothe.cognition.plan.created";
-var EventExploreStarted = "soothe.subagent.explore.started";
-var EventExploreMilestone = "soothe.subagent.explore.milestone";
-var EventExploreStepCompleted = "soothe.subagent.explore.step.completed";
-var EventExploreCompleted = "soothe.subagent.explore.completed";
-var EventTacitusStarted = "soothe.subagent.tacitus.started";
-var EventTacitusGatherSummary = "soothe.subagent.tacitus.gather.summary";
-var EventTacitusCompleted = "soothe.subagent.tacitus.completed";
-var EventReplayComplete = "replay_complete";
-var EventLoopReattachedWire = "loop_reattached";
-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 EventMessageReceived = "soothe.protocol.message.received";
-var EventMessageSent = "soothe.protocol.message.sent";
-var EventFinalReport = "soothe.output.autonomous.final_report.reported";
-var EventGeneralFailed = "soothe.error.general.failed";
-function parseNamespace(ns) {
-  const parts = splitNamespace(ns);
-  if (parts.length < 4 || parts[0] !== "soothe") {
-    return null;
-  }
-  if (parts[1] === "internal") {
-    return null;
+init_errors();
+async function bootstrapLoopSession(client, resumeLoopId, config, loopNew) {
+  const cfg = config ?? defaultConfig();
+  let loopId = (resumeLoopId ?? "").trim();
+  if (!loopId) {
+    const env = newLoopNewMessage(loopNew);
+    const newResp = await client.requestResponse(
+      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");
+    }
   }
-  return { domain: parts[1], component: parts[2], action: parts[3] };
+  await client.subscribe(
+    "loop_events",
+    { loop_id: loopId, verbosity: cfg.verbosityLevel },
+    cfg.subscriptionTimeout
+  );
+  return loopId;
 }
-function splitNamespace(ns) {
-  const parts = [];
-  let start = 0;
-  for (let i = 0; i < ns.length; i++) {
-    if (ns[i] === ".") {
-      parts.push(ns.slice(start, i));
-      start = i + 1;
+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 === "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")}`);
     }
   }
-  parts.push(ns.slice(start));
-  return parts;
+  throw new Error(`timeout after ${timeout}ms waiting for connection_ack (ready)`);
 }
-function classifyEventVerbosity(eventTypeOrNamespace) {
-  const parsed = parseNamespace(eventTypeOrNamespace);
-  if (!parsed) {
-    return classifyByEventTypeString(eventTypeOrNamespace);
+async function waitLoopStatusWithID(client, timeout) {
+  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 === "error") {
+      const errObj = ev.error ?? {};
+      throw new DaemonError(errObj.code ?? -32603, errObj.message ?? "daemon error");
+    }
+    if (ev.type === "status") {
+      const lid = ev.loop_id;
+      if (lid && lid !== "") {
+        return ev;
+      }
+    }
   }
-  return classifyByDomainAndComponent(parsed.domain, parsed.component, eventTypeOrNamespace);
+  throw new Error(`timeout after ${timeout}ms waiting for status with loop_id`);
 }
-function classifyByDomainAndComponent(domain, _component, full) {
-  switch (domain) {
-    case "cognition":
-      return 1 /* Normal */;
-    case "protocol":
-      return 2 /* Detailed */;
-    case "tool":
-      return 99 /* Internal */;
-    case "subagent":
-      return classifySubagentEvent(full);
-    case "output":
-    case "error":
-      return 0 /* Quiet */;
-    default:
-      return 1 /* Normal */;
+async function waitSubscriptionConfirmed(client, wantLoopID, _wantVerbosity, timeout) {
+  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 === "next") {
+      const payload = ev.payload ?? {};
+      const lid = String(payload.loop_id ?? "");
+      if (lid === wantLoopID && payload.success === true) return;
+      continue;
+    }
+    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 confirmation`);
 }
-function classifySubagentEvent(full) {
-  const parsed = parseNamespace(full);
-  if (!parsed) return 1 /* Normal */;
-  switch (parsed.action) {
-    case "started":
-    case "completed":
-      return 1 /* Normal */;
-    default:
-      return 2 /* Detailed */;
+async function connectWithRetries(client, maxRetries, retryDelay) {
+  const retries = maxRetries && maxRetries > 0 ? maxRetries : 40;
+  const delay = retryDelay && retryDelay > 0 ? retryDelay : 250;
+  let lastErr = null;
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      await client.connect();
+      return;
+    } catch (err) {
+      lastErr = err;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delay));
   }
+  throw new Error(
+    `failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`
+  );
 }
-function classifyByEventTypeString(eventType) {
-  if (eventType === EventFinalReport || eventType === EventGeneralFailed) {
-    return 0 /* Quiet */;
+
+// src/command_client.ts
+var CommandClient = class {
+  url;
+  timeoutMs;
+  config;
+  constructor(url, opts) {
+    this.url = url;
+    this.timeoutMs = opts?.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 3e4;
+    this.config = opts?.config ?? defaultConfig();
   }
-  if (eventType === EventToolStarted) {
-    return 99 /* Internal */;
+  async withClient(fn) {
+    const client = new Client(this.url, this.config);
+    try {
+      await connectWithRetries(client, 5, 250);
+      return await fn(client);
+    } finally {
+      client.close();
+    }
   }
-  return 1 /* Normal */;
-}
-function isCompletionEvent(eventType) {
-  return eventType.endsWith(".completed") || eventType.endsWith(".failed") || eventType === EventGeneralFailed;
-}
-function isSubagentProgressEvent(eventType) {
-  const parsed = parseNamespace(eventType);
-  if (!parsed || parsed.domain !== "subagent") {
-    return false;
+  /** Generic one-shot RPC. */
+  async request(method, params = {}) {
+    return this.withClient(
+      (client) => client.requestResponse(method, params, void 0, this.timeoutMs)
+    );
   }
-  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();
+  async jobCreate(goal, workspace = "") {
+    const params = { goal };
+    if (workspace) params.workspace = workspace;
+    return this.request("job_create", params);
+  }
+  async jobStatus(jobId) {
+    return this.request("job_status", { job_id: jobId });
+  }
+  async jobCancel(jobId) {
+    return this.request("job_cancel", { job_id: jobId });
+  }
+  async cronAdd(text, priority = 0) {
+    const params = { text };
+    if (priority > 0) params.priority = priority;
+    return this.request("cron_add", params);
+  }
+  async cronList(status = "") {
+    const params = {};
+    if (status) params.status = status;
+    return this.request("cron_list", params);
+  }
+};
 
 // 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,134 +2216,1906 @@ 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;
 }
-
-// src/session.ts
-init_config();
-init_protocol();
-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 newResp = await client.requestResponse(
-      newLoopNewMessage(loopNew),
-      "loop_new_response",
-      cfg.loopStatusTimeout
-    );
-    loopId = String(newResp.loop_id ?? "").trim();
-    if (!loopId) {
-      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",
-    cfg.subscriptionTimeout
+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
   );
-  if (subResp.success === false) {
-    throw new Error(String(subResp.message ?? "loop_subscribe failed"));
-  }
-  return loopId;
 }
-async function waitDaemonReady(client, timeout) {
-  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 ?? "")}`
-      );
+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
+  );
+}
+async function fetchLoopCards(client, loopID, timeout) {
+  return client.fetchLoopCards(loopID, timeout);
+}
+async function fetchLoopMessages(client, loopID, opts) {
+  return client.getLoopMessages(
+    loopID,
+    opts?.limit,
+    opts?.offset,
+    opts?.includeEvents,
+    opts?.timeout
+  );
+}
+async function connectedWebsocket(wsUrl, fn, timeoutMs = 3e4) {
+  const { Client: Client2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const client = new Client2(wsUrl, defaultConfig());
+  const deadline = Date.now() + timeoutMs;
+  try {
+    await client.connect();
+    while (!client.isConnected() && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 25));
     }
+    if (!client.isConnected()) {
+      throw new Error("Timed out waiting for daemon handshake");
+    }
+    return await fn(client);
+  } finally {
+    client.close();
   }
-  throw new Error(`timeout after ${timeout}ms waiting for daemon_ready (state=ready)`);
 }
-async function waitLoopStatusWithID(client, timeout) {
-  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 === "error") {
-      const errResp = ev;
-      throw new Error(`daemon error: ${errResp.code}: ${errResp.message}`);
+async function protocol1Rpc(wsUrl, method, params = null, opts = {}) {
+  const mode = opts.mode ?? "request";
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  try {
+    return await connectedWebsocket(
+      wsUrl,
+      async (client) => {
+        if (mode === "notify") {
+          await client.notify(method, params ?? {});
+          return {};
+        }
+        if (mode === "subscribe") {
+          const subId = await client.subscribe(
+            method,
+            params ?? {},
+            timeoutMs
+          );
+          return { subscription_id: subId };
+        }
+        const result = await client.requestResponse(
+          method,
+          params ?? {},
+          method,
+          timeoutMs
+        );
+        return result && typeof result === "object" ? result : { result };
+      },
+      timeoutMs
+    );
+  } catch (exc) {
+    const msg = exc instanceof Error ? exc.message : String(exc);
+    if (msg.toLowerCase().includes("timed out") || msg.toLowerCase().includes("timeout")) {
+      return { error: "Timed out waiting for daemon response" };
     }
-    if (ev.type === "status") {
-      const status = ev;
-      const lid = status.loop_id;
-      if (lid && lid !== "") {
-        return status;
-      }
+    if (msg.toLowerCase().includes("connect") || msg.toLowerCase().includes("dial")) {
+      return { error: `Connection error: ${msg}` };
     }
+    return { error: msg };
   }
-  throw new Error(`timeout after ${timeout}ms waiting for status with loop_id`);
 }
-async function waitSubscriptionConfirmed(client, wantLoopID, _wantVerbosity, timeout) {
-  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 === "loop_subscribe_response" && ev.success === true) {
-      if (String(ev.loop_id ?? "") === wantLoopID) return;
+
+// src/index.ts
+init_stream_terminal();
+
+// 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);
     }
-    if (ev.type === "subscription_confirmed") {
-      const lid = String(ev.loop_id ?? "");
-      if (lid === wantLoopID) return;
+    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);
+      }
     }
   }
-  throw new Error(`timeout after ${timeout}ms waiting for subscription_confirmed`);
-}
-async function connectWithRetries(client, maxRetries, retryDelay) {
-  const retries = maxRetries && maxRetries > 0 ? maxRetries : 40;
-  const delay = retryDelay && retryDelay > 0 ? retryDelay : 250;
-  let lastErr = null;
-  for (let attempt = 0; attempt < retries; attempt++) {
-    try {
-      await client.connect();
-      return;
-    } catch (err) {
-      lastErr = err;
+  /** 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 = [];
     }
-    await new Promise((resolve) => setTimeout(resolve, delay));
+    this.subscribers.delete(sessionID);
   }
-  throw new Error(`failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`);
-}
+  /** 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();
+init_events();
+
+// 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;
+  treatStatusIdleAsComplete;
+  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;
+    this.treatStatusIdleAsComplete = Boolean(cfg.treatStatusIdleAsComplete);
+  }
+  /**
+   * 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;
+    switch (eventType) {
+      case "status.idle":
+      case "idle_timeout":
+      case "query_timeout":
+      case "stream_closed":
+        return true;
+    }
+    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, accumulated);
+    }
+    if (typ === "response" || typ === "complete" || typ === "receipt_response" || typ === "connection_ack") {
+      return { terminal: 0 /* Continue */ };
+    }
+    if (typ === "status") {
+      if (this.treatStatusIdleAsComplete && String(m.state ?? "").trim().toLowerCase() === "idle" && this.isSubstantiveAssistantReply(accumulated)) {
+        return this.deliverableResult(accumulated.trim(), "status.idle");
+      }
+      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, accumulated) {
+    const payload = env.payload ?? {};
+    const innerData = payload.data;
+    if (innerData && typeof innerData === "object") {
+      const innerType = innerData.type ?? "";
+      if (innerType === "status") {
+        return this.processChatEvent(innerData, accumulated);
+      }
+      const innerMode = innerData.mode ?? "";
+      if (innerMode) {
+        return this.classifyEventPayload(
+          innerData.namespace ?? payload.namespace ?? null,
+          innerMode,
+          innerData.data
+        );
+      }
+    }
+    const mode = payload.mode ?? "";
+    if (mode === "status" || mode === "") {
+      if (typeof payload.state === "string" || innerData && "state" in (innerData ?? {})) {
+        return this.processChatEvent({ type: "status", ...innerData ?? payload }, accumulated);
+      }
+    }
+    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 {
+        const idleTooLong = this.cfg.maxIdleTime > 0 && existing.lastUsed > 0 && Date.now() - existing.lastUsed > this.cfg.maxIdleTime;
+        if (idleTooLong) {
+          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/attachments.ts
+function compactDefaults(opts) {
+  return {
+    maxDim: opts?.maxDim && opts.maxDim > 0 ? opts.maxDim : 768,
+    quality: opts?.jpegQuality && opts.jpegQuality > 0 ? opts.jpegQuality : 85
+  };
+}
+var sharpLoader = null;
+async function loadSharp() {
+  if (!sharpLoader) {
+    sharpLoader = (async () => {
+      try {
+        const m = await Function('return import("sharp")')();
+        return m;
+      } catch {
+        return null;
+      }
+    })();
+  }
+  return sharpLoader;
+}
+async function compactImageAttachment(mimeType, dataB64, opts) {
+  if (!dataB64 || !mimeType.startsWith("image/")) {
+    return [mimeType, dataB64];
+  }
+  let raw;
+  try {
+    raw = Buffer.from(dataB64, "base64");
+  } catch {
+    return [mimeType, dataB64];
+  }
+  if (raw.length === 0) return [mimeType, dataB64];
+  const sharpMod = await loadSharp();
+  if (!sharpMod) return [mimeType, dataB64];
+  const { maxDim, quality } = compactDefaults(opts);
+  try {
+    const img = sharpMod.default(raw, { failOn: "none" });
+    const meta = await img.metadata();
+    const w = meta.width ?? 0;
+    const h = meta.height ?? 0;
+    if (w <= 0 || h <= 0 || w <= maxDim && h <= maxDim) {
+      return [mimeType, dataB64];
+    }
+    let nw = w;
+    let nh = h;
+    if (w >= h) {
+      if (w > maxDim) {
+        nw = maxDim;
+        nh = Math.max(1, Math.round(h * maxDim / w));
+      }
+    } else if (h > maxDim) {
+      nh = maxDim;
+      nw = Math.max(1, Math.round(w * maxDim / h));
+    }
+    const resized = img.resize(nw, nh, { fit: "fill" });
+    if (mimeType === "image/png") {
+      const buf2 = await resized.png().toBuffer();
+      return [mimeType, buf2.toString("base64")];
+    }
+    const buf = await resized.jpeg({ quality }).toBuffer();
+    return ["image/jpeg", buf.toString("base64")];
+  } catch {
+    return [mimeType, dataB64];
+  }
+}
+async function compactAttachments(atts, opts) {
+  if (!atts.length) return atts;
+  const out = [];
+  for (const att of atts) {
+    const cp = { ...att };
+    const mime = typeof cp.mime_type === "string" ? cp.mime_type : "";
+    const data = typeof cp.data === "string" ? cp.data : "";
+    if (mime && data) {
+      const [outMime, outData] = await compactImageAttachment(mime, data, opts);
+      cp.mime_type = outMime;
+      cp.data = outData;
+    }
+    out.push(cp);
+  }
+  return out;
+}
+
+// src/appkit/turn_runner.ts
+init_intent_hints();
+var ErrQueryTimeout = class extends Error {
+  constructor() {
+    super("appkit: query timeout");
+    this.name = "ErrQueryTimeout";
+  }
+};
+var ErrIdleTimeout = class extends Error {
+  constructor() {
+    super("appkit: idle timeout");
+    this.name = "ErrIdleTimeout";
+  }
+};
+var TimeoutPolicy = /* @__PURE__ */ ((TimeoutPolicy2) => {
+  TimeoutPolicy2[TimeoutPolicy2["Fail"] = 0] = "Fail";
+  TimeoutPolicy2[TimeoutPolicy2["SoftComplete"] = 1] = "SoftComplete";
+  return TimeoutPolicy2;
+})(TimeoutPolicy || {});
+var StreamCloseFail = 0 /* Fail */;
+var StreamCloseSoftComplete = 1 /* SoftComplete */;
+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;
+}
+function idleTimeoutForTurn(cfg, hasAttachments) {
+  const idle = cfg.idleTimeout ?? 0;
+  if (idle <= 0) return 0;
+  const floor = cfg.minIdleTimeoutWithAttachments ?? 0;
+  if (hasAttachments && floor > 0 && idle < floor) return floor;
+  return idle;
+}
+var TurnRunner = class {
+  pool;
+  gate;
+  classifier;
+  store;
+  broadcaster;
+  cfg;
+  buildInput = inputMessageForLoop;
+  onComplete = null;
+  onError = 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 = {
+      ...cfg,
+      queryTimeout: cfg.queryTimeout > 0 ? cfg.queryTimeout : 30 * 60 * 1e3
+    };
+  }
+  withInputBuilder(f) {
+    if (f) this.buildInput = f;
+    return this;
+  }
+  withOnComplete(f) {
+    this.onComplete = f;
+    return this;
+  }
+  withOnError(f) {
+    this.onError = f;
+    return this;
+  }
+  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;
+    }
+    let idleTimer = null;
+    const clearIdle = () => {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+    };
+    try {
+      let atts = attachments ?? void 0;
+      if (this.cfg.compactAttachmentsBeforeSend && atts && atts.length > 0) {
+        atts = await compactAttachments(atts, this.cfg.compactImageOpts);
+      }
+      const inputMsg = this.buildInput(message, loopID, atts, 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 idleForTurn = idleTimeoutForTurn(this.cfg, (attachments?.length ?? 0) > 0);
+      let idleReject = null;
+      const armIdle = () => {
+        clearIdle();
+        idleReject = null;
+        if (idleForTurn <= 0) {
+          return new Promise(() => {
+          });
+        }
+        return new Promise((resolve) => {
+          idleReject = () => resolve("idle");
+          idleTimer = setTimeout(() => {
+            idleReject?.();
+          }, idleForTurn);
+        });
+      };
+      let idleRace = armIdle();
+      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 })),
+          idleRace.then((tag) => ({ tag }))
+        ]);
+        if ("tag" in raced && raced.tag !== "msg") {
+          if (raced.tag === "caller" || signal?.aborted) {
+            clearIdle();
+            const err = new Error("aborted");
+            await this.persistFailed(sessionID, loopID, err);
+            this.broadcastError(sessionID, err);
+            this.onError?.(sessionID, loopID, err);
+            throw err;
+          }
+          if (raced.tag === "idle") {
+            clearIdle();
+            await this.sendLoopCancel(new AbortController().signal, conn, loopID).catch(() => {
+            });
+            await this.finishTimeout(
+              sessionID,
+              loopID,
+              assistantContent,
+              startedAt,
+              new ErrIdleTimeout(),
+              "idle_timeout",
+              this.cfg.onIdleTimeout ?? 0 /* Fail */
+            );
+            return;
+          }
+          clearIdle();
+          await this.sendLoopCancel(new AbortController().signal, conn, loopID).catch(() => {
+          });
+          await this.finishTimeout(
+            sessionID,
+            loopID,
+            assistantContent,
+            startedAt,
+            new ErrQueryTimeout(),
+            "query_timeout",
+            this.cfg.onQueryTimeout ?? 0 /* Fail */
+          );
+          return;
+        }
+        const res = raced.res;
+        if (res.done) {
+          clearIdle();
+          if ((this.cfg.onStreamClose ?? 0 /* Fail */) === 1 /* SoftComplete */ && assistantContent.trim() !== "") {
+            await this.completeTurn(
+              sessionID,
+              loopID,
+              assistantContent,
+              startedAt,
+              "stream_closed"
+            );
+            return;
+          }
+          const err = new Error("event stream closed");
+          await this.persistFailed(sessionID, loopID, err);
+          this.broadcastError(sessionID, err);
+          this.onError?.(sessionID, loopID, err);
+          throw err;
+        }
+        idleRace = armIdle();
+        const msg = res.value;
+        const eventResult = this.classifier.classify(msg, assistantContent);
+        if (eventResult.err && eventResult.terminal === 2 /* FailedComplete */) {
+          clearIdle();
+          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) {
+          clearIdle();
+          await this.completeTurn(
+            sessionID,
+            loopID,
+            final,
+            startedAt,
+            eventResult.completionEvent ?? ""
+          );
+          return;
+        }
+      }
+    } finally {
+      clearIdle();
+      clearTimeout(timer);
+      this.gate.release(sessionID);
+    }
+  }
+  async finishTimeout(sessionID, loopID, content, startedAt, failErr, completionEvent, policy) {
+    if (policy === 1 /* SoftComplete */ && content.trim() !== "") {
+      await this.completeTurn(sessionID, loopID, content, startedAt, completionEvent);
+      return;
+    }
+    await this.persistFailed(sessionID, loopID, failErr);
+    this.broadcastError(sessionID, failErr);
+    this.onError?.(sessionID, loopID, failErr);
+    throw failErr;
+  }
+  async completeTurn(sessionID, loopID, final, startedAt, completionEvent) {
+    const elapsedMs = Date.now() - startedAt;
+    await this.persistResponse(sessionID, loopID, final, startedAt, completionEvent);
+    this.broadcastComplete(sessionID, final);
+    this.onComplete?.(sessionID, loopID, final, completionEvent, elapsedMs);
+  }
+  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 });
+  }
+};
+
+// src/appkit/daemon_session.ts
+init_client();
+init_config();
+init_errors();
+init_stream_terminal();
+
+// src/appkit/chunk_filter.ts
+var MSG_PAIR_LEN = 2;
+function updatesChunkIsNoop(data) {
+  if (!data || typeof data !== "object") return true;
+  return !("__interrupt__" in data);
+}
+function wireBody(msg) {
+  for (const key of ["kwargs", "data"]) {
+    const nested = msg[key];
+    if (nested && typeof nested === "object") return nested;
+  }
+  return msg;
+}
+function dictHasToolInvocation(msg) {
+  const body = wireBody(msg);
+  if (body.tool_calls || body.tool_call_chunks) return true;
+  for (const key of ["content", "content_blocks"]) {
+    const raw = body[key];
+    if (Array.isArray(raw)) {
+      for (const item of raw) {
+        if (item && typeof item === "object" && ["tool_call", "tool_call_chunk", "tool_use"].includes(
+          String(item.type ?? "")
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function plainText(msg) {
+  const body = wireBody(msg);
+  const content = body.content ?? msg.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (typeof block === "string") parts.push(block);
+      else if (block && typeof block === "object") {
+        const text = block.text;
+        if (typeof text === "string") parts.push(text);
+      }
+    }
+    return parts.join("");
+  }
+  return "";
+}
+function messageChunkIsNonActionable(data) {
+  if (!Array.isArray(data) || data.length !== MSG_PAIR_LEN) return false;
+  const msg = data[0];
+  if (msg === null || msg === void 0) return true;
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  const body = wireBody(m);
+  const raw = String(body.type ?? m.type ?? "");
+  if (raw === "tool" || raw === "ToolMessage" || raw.endsWith("ToolMessage")) return false;
+  if (dictHasToolInvocation(m)) return false;
+  if (body.phase || m.phase) return false;
+  return !plainText(m).trim();
+}
+function shouldDropStreamChunkEarly(_namespace, mode, data) {
+  if (mode === "updates") return updatesChunkIsNoop(data);
+  if (mode === "messages") return messageChunkIsNonActionable(data);
+  return false;
+}
+
+// src/appkit/events.ts
+function unwrapNext(event) {
+  if (!event || typeof event !== "object") return event;
+  if (event.type !== "next") return event;
+  const payload = event.payload;
+  if (!payload || typeof payload !== "object") return event;
+  const data = payload.data;
+  return data && typeof data === "object" ? data : event;
+}
+
+// src/appkit/observability.ts
+var TurnEventStats = class {
+  total = 0;
+  messages = 0;
+  updates = 0;
+  custom = 0;
+  skipped = 0;
+  filteredEarly = 0;
+  toolCalls = 0;
+  toolResults = 0;
+  textChunks = 0;
+  heartbeatsDropped = 0;
+  postIdleDrained = 0;
+  inboundDropped = 0;
+};
+
+// src/appkit/daemon_session.ts
+var DEFAULT_POST_IDLE_DRAIN_MS = 500;
+var DaemonSession = class {
+  wsUrl;
+  workspace;
+  streamDelivery;
+  client;
+  rpcClient;
+  loopId = null;
+  readBusy = false;
+  rpcBusy = false;
+  rpcConnected = false;
+  streaming = false;
+  postIdleDrainDeadlineMs;
+  closed = false;
+  earlyDropFn;
+  statsFactory;
+  config;
+  turnEventStats;
+  lastTurnEndState = null;
+  lastTurnCancellationSeen = false;
+  lastTurnErrorMessage = null;
+  constructor(wsUrl, opts = {}) {
+    this.wsUrl = wsUrl;
+    this.workspace = opts.workspace;
+    this.streamDelivery = opts.streamDelivery ?? "adaptive";
+    this.config = opts.config ?? defaultConfig();
+    this.client = new Client(wsUrl, this.config);
+    this.rpcClient = new Client(wsUrl, this.config);
+    this.postIdleDrainDeadlineMs = opts.postIdleDrainDeadlineMs && opts.postIdleDrainDeadlineMs > 0 ? opts.postIdleDrainDeadlineMs : DEFAULT_POST_IDLE_DRAIN_MS;
+    this.earlyDropFn = opts.earlyDropFn ?? shouldDropStreamChunkEarly;
+    this.statsFactory = opts.statsFactory ?? (() => new TurnEventStats());
+    this.turnEventStats = this.statsFactory();
+  }
+  get streamClient() {
+    return this.client;
+  }
+  get rpcSideClient() {
+    return this.rpcClient;
+  }
+  get activeLoopId() {
+    return this.loopId;
+  }
+  resolveStreamDeliveryMode() {
+    const delivery = this.streamDelivery;
+    if (typeof delivery === "function") return String(delivery() || "adaptive");
+    return String(delivery || "adaptive");
+  }
+  get streamDeliveryMode() {
+    return this.resolveStreamDeliveryMode();
+  }
+  shouldDrop(namespace, mode, data) {
+    return Boolean(this.earlyDropFn(namespace, mode, data));
+  }
+  async connect(resumeLoopId) {
+    await connectWithRetries(this.client);
+    return this.bootstrapLoop(resumeLoopId ?? null);
+  }
+  async bootstrapLoop(resumeLoopId) {
+    const loopNew = this.workspace ? { client_workspace: this.workspace, workspace: this.workspace } : void 0;
+    const loopId = await bootstrapLoopSession(this.client, resumeLoopId, this.config, loopNew);
+    this.loopId = loopId;
+    return { type: "status", loop_id: loopId, state: "ready" };
+  }
+  async newLoop() {
+    return this.bootstrapLoop(null);
+  }
+  async switchLoop(loopId) {
+    return this.bootstrapLoop(loopId);
+  }
+  async ensureConnected() {
+    if (this.client.isConnected() && !this.client.isDisconnected()) return;
+    let resumeLoopId = this.loopId;
+    if (this.rpcConnected) {
+      this.rpcClient.close();
+      this.rpcConnected = false;
+    }
+    try {
+      await this.client.reconnect();
+    } catch {
+      this.client.close();
+      await connectWithRetries(this.client);
+    }
+    if (resumeLoopId) {
+      try {
+        await this.client.reattachAndProbe(resumeLoopId);
+        this.loopId = resumeLoopId;
+        return;
+      } catch (err) {
+        if (!(err instanceof StaleLoopError)) throw err;
+        resumeLoopId = null;
+      }
+    }
+    await this.bootstrapLoop(resumeLoopId);
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.client.close();
+    this.rpcClient.close();
+    this.rpcConnected = false;
+  }
+  async detach() {
+    if (!this.client.isConnected()) return;
+    try {
+      await this.client.notify("disconnect", {});
+    } catch {
+    }
+  }
+  async sendTurn(text, options) {
+    if (!this.loopId) throw new Error("No active loop session");
+    await this.client.sendInput(text, {
+      loopID: this.loopId,
+      autonomous: options?.autonomous,
+      maxIterations: options?.maxIterations,
+      subagent: options?.preferredSubagent,
+      model: options?.model,
+      modelParams: options?.modelParams,
+      attachments: options?.attachments,
+      clarificationMode: options?.clarificationMode,
+      clarificationAnswer: options?.clarificationAnswer,
+      intentHint: options?.intentHint
+    });
+  }
+  async cancelActiveTurn() {
+    await this.client.notify("slash_command", { cmd: "/cancel" });
+  }
+  async *drainStreamEventsAfterIdle(expectedLoopId) {
+    const deadline = Date.now() + this.postIdleDrainDeadlineMs;
+    let exp = expectedLoopId;
+    while (Date.now() < deadline) {
+      const event = await this.client.readEventWithTimeout(250);
+      if (!event) break;
+      let frame = event;
+      let eventType = String(frame.type ?? "");
+      if (eventType === "next") {
+        frame = unwrapNext(frame) ?? frame;
+        eventType = String(frame.type ?? "");
+      }
+      const eventLoopId = frame.loop_id;
+      if (exp && typeof eventLoopId === "string" && eventLoopId && eventLoopId !== exp) {
+        continue;
+      }
+      if (eventType === "error") {
+        const errObj = frame.error ?? {};
+        throw new Error(String(errObj.message || frame.message || "daemon error"));
+      }
+      if (eventType === "status") {
+        const loopEv = frame.loop_id;
+        if (typeof loopEv === "string" && loopEv) {
+          this.loopId = loopEv;
+          exp = loopEv;
+        }
+        continue;
+      }
+      if (eventType !== "event") continue;
+      const data = frame.data;
+      const namespace = Array.isArray(frame.namespace) ? frame.namespace : [];
+      const mode = String(frame.mode ?? "");
+      if (this.shouldDrop(namespace, mode, data)) {
+        this.turnEventStats.filteredEarly += 1;
+        continue;
+      }
+      this.turnEventStats.postIdleDrained += 1;
+      yield [namespace, mode, data];
+    }
+  }
+  async withRpcLock(fn) {
+    while (this.rpcBusy) {
+      await new Promise((r) => setTimeout(r, 5));
+    }
+    this.rpcBusy = true;
+    try {
+      return await fn();
+    } finally {
+      this.rpcBusy = false;
+    }
+  }
+  async ensureRpcConnected() {
+    if (this.rpcConnected && this.rpcClient.isConnected()) return;
+    await connectWithRetries(this.rpcClient);
+    this.rpcConnected = true;
+  }
+  async listLoops(_limit = 20) {
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      return this.rpcClient.listLoops(15e3);
+    });
+  }
+  async fetchLoopCards(loopId) {
+    const lid = String(loopId || "").trim();
+    if (!lid) return { cards: [], seq: 0, contextTokens: 0, success: false };
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      try {
+        const resp = await this.rpcClient.fetchLoopCards(lid, 3e4);
+        const rawCards = resp.cards;
+        return {
+          cards: Array.isArray(rawCards) ? rawCards : [],
+          seq: Number(resp.seq ?? 0),
+          contextTokens: typeof resp.context_tokens === "number" && resp.context_tokens >= 0 ? resp.context_tokens : 0,
+          success: true
+        };
+      } catch {
+        return { cards: [], seq: 0, contextTokens: 0, success: false };
+      }
+    });
+  }
+  async fetchLoopHistory(loopId) {
+    const lid = String(loopId || "").trim();
+    if (!lid) {
+      return { goals: [], liveCards: [], liveGoalIndex: null, contextTokens: 0, success: false };
+    }
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      try {
+        const resp = await this.rpcClient.fetchLoopHistory(lid, 3e4);
+        const liveGoalIndex = resp.live_goal_index;
+        return {
+          goals: Array.isArray(resp.goals) ? resp.goals : [],
+          liveCards: Array.isArray(resp.live_cards) ? resp.live_cards : [],
+          liveGoalIndex: typeof liveGoalIndex === "number" ? liveGoalIndex : null,
+          contextTokens: typeof resp.context_tokens === "number" && resp.context_tokens >= 0 ? resp.context_tokens : 0,
+          success: Boolean(resp.success ?? true)
+        };
+      } catch {
+        return {
+          goals: [],
+          liveCards: [],
+          liveGoalIndex: null,
+          contextTokens: 0,
+          success: false
+        };
+      }
+    });
+  }
+  async fetchConversationLog(loopId, opts = {}) {
+    const lid = String(loopId || "").trim();
+    if (!lid) return [];
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      const resp = await this.rpcClient.getLoopMessages(
+        lid,
+        opts.limit ?? 100,
+        opts.offset ?? 0,
+        opts.includeEvents ?? false
+      );
+      const raw = resp.messages;
+      if (!Array.isArray(raw)) return [];
+      return raw.filter((m) => !!m && typeof m === "object");
+    });
+  }
+  async *iterTurnChunks(opts = {}) {
+    this.turnEventStats = this.statsFactory();
+    this.lastTurnEndState = null;
+    this.lastTurnCancellationSeen = false;
+    this.lastTurnErrorMessage = null;
+    let queryStarted = false;
+    let expectedLoopId = this.loopId;
+    let streamPayloadSeen = false;
+    let turnProgressSeen = false;
+    this.streaming = true;
+    const absoluteDeadline = opts.maxWaitMs !== void 0 && opts.maxWaitMs > 0 ? Date.now() + opts.maxWaitMs : null;
+    this.client.peelStalePendingControlEvents();
+    while (this.readBusy) {
+      await new Promise((r) => setTimeout(r, 5));
+    }
+    this.readBusy = true;
+    try {
+      while (true) {
+        if (absoluteDeadline !== null && Date.now() >= absoluteDeadline) {
+          throw new Error(
+            `Turn timed out after ${opts.maxWaitMs}ms (loop=${expectedLoopId ?? "?"})`
+          );
+        }
+        const event = await this.client.readEvent();
+        if (!event) {
+          if (queryStarted && !this.client.isConnectionAlive()) {
+            this.lastTurnEndState = "connection_lost";
+            throw new Error("Daemon connection lost");
+          }
+          break;
+        }
+        let frame = event;
+        let eventType = String(frame.type ?? "");
+        if (eventType === "next") {
+          frame = unwrapNext(frame) ?? frame;
+          eventType = String(frame.type ?? "");
+        }
+        const eventLoopId = frame.loop_id;
+        if (expectedLoopId && typeof eventLoopId === "string" && eventLoopId && eventLoopId !== expectedLoopId) {
+          continue;
+        }
+        if (eventType === "error") {
+          const errObj = frame.error ?? {};
+          throw new Error(String(errObj.message || frame.message || "daemon error"));
+        }
+        if (eventType === "status") {
+          const loopEv = frame.loop_id;
+          if (typeof loopEv === "string" && loopEv) {
+            this.loopId = loopEv;
+            expectedLoopId = loopEv;
+          }
+          const state = String(frame.state ?? "");
+          if (state === "running") {
+            queryStarted = true;
+          } else if (queryStarted && state === "stopped") {
+            this.lastTurnEndState = state;
+            yield* this.drainStreamEventsAfterIdle(expectedLoopId);
+            break;
+          } else if (queryStarted && state === "idle") {
+            if (!streamPayloadSeen && !this.lastTurnCancellationSeen) continue;
+            this.lastTurnEndState = state;
+            yield* this.drainStreamEventsAfterIdle(expectedLoopId);
+            break;
+          }
+          continue;
+        }
+        if (eventType === "command_response") {
+          const content = String(frame.content ?? "");
+          if (content.includes("Cancellation requested")) {
+            this.lastTurnCancellationSeen = true;
+          }
+          continue;
+        }
+        if (eventType !== "event") continue;
+        const data = frame.data;
+        const namespace = Array.isArray(frame.namespace) ? frame.namespace : [];
+        const mode = String(frame.mode ?? "");
+        if (this.shouldDrop(namespace, mode, data)) {
+          this.turnEventStats.filteredEarly += 1;
+          continue;
+        }
+        if (mode === "custom" && isTurnEndCustomData(data)) {
+          if (!queryStarted || !turnProgressSeen) continue;
+        }
+        streamPayloadSeen = true;
+        if (isTurnProgressChunk(mode, data)) turnProgressSeen = true;
+        yield [namespace, mode, data];
+        if (mode === "custom" && isTurnEndCustomData(data)) {
+          const customType = String(data.type ?? "").trim();
+          this.lastTurnEndState = customType === STREAM_END ? "stream_end" : "completed";
+          yield* this.drainStreamEventsAfterIdle(expectedLoopId);
+          break;
+        }
+      }
+    } catch (exc) {
+      this.lastTurnErrorMessage = String(exc);
+      throw exc;
+    } finally {
+      this.streaming = false;
+      this.readBusy = false;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CLIENT_VERSION,
+  ChatEventTerminal,
   Client,
+  CommandClient,
   ConnectionError,
+  ConnectionPool,
+  DEFAULT_CLIENT_CAPABILITIES,
+  DEFAULT_DELIVERABLE_PHASES,
+  DEFAULT_POST_IDLE_DRAIN_MS,
+  DEFAULT_THINKING_STEP_EVENTS,
   DaemonError,
-  ESSENTIAL_EVENT_TYPES,
-  EventAgentLoopCompleted,
-  EventAgentLoopIterated,
-  EventAgentLoopReasoned,
-  EventAgentLoopStarted,
+  DaemonSession,
+  DisconnectCause,
+  ErrIdleTimeout,
+  ErrPoolExhausted,
+  ErrQueryBusy,
+  ErrQueryTimeout,
+  EventAutopilotGoalCompleted,
+  EventAutopilotGoalCreated,
+  EventAutopilotGoalProgress,
+  EventAutopilotGoalStatus,
+  EventAutopilotWorkerAssigned,
+  EventAutopilotWorkerUnassigned,
+  EventCardCreated,
+  EventCardReplayBegin,
+  EventCardReplayEnd,
+  EventClassifier,
   EventExploreCompleted,
   EventExploreMilestone,
   EventExploreStarted,
@@ -1087,6 +4127,14 @@ async function connectWithRetries(client, maxRetries, retryDelay) {
   EventMessageSent,
   EventPlanCreated,
   EventReplayComplete,
+  EventStrangeLoopCompleted,
+  EventStrangeLoopContextCompacted,
+  EventStrangeLoopPlanDecision,
+  EventStrangeLoopReasoned,
+  EventStrangeLoopStarted,
+  EventStrangeLoopStepCompleted,
+  EventStrangeLoopStepQueued,
+  EventStrangeLoopStepStarted,
   EventStreamToolCallUpdate,
   EventTacitusCompleted,
   EventTacitusGatherSummary,
@@ -1095,31 +4143,76 @@ 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,
+  PROTO_VERSION,
+  PooledConn,
+  QueryGate,
+  REMOVED_INTENT_HINTS,
+  ReconnectError,
+  SSEBroadcaster,
+  STREAM_END,
+  StaleLoopError,
+  StreamCloseFail,
+  StreamCloseSoftComplete,
   TimeoutError,
+  TimeoutPolicy,
+  TurnEventStats,
+  TurnRunner,
   VerbosityTier,
+  authenticate,
   bootstrapLoopSession,
   checkDaemonStatus,
   classifyEventVerbosity,
+  compactAttachments,
+  compactImageAttachment,
   connectWithRetries,
+  connectedWebsocket,
+  connectionInitEnvelope,
   decodeMessage,
   defaultConfig,
+  defaultPoolConfig,
+  disconnectCauseName,
+  disconnectEnvelope,
   encodeMessage,
   extractSootheLoopID,
+  extractThinkingStep,
   fetchConfigSection,
+  fetchLoopCards,
+  fetchLoopHistory,
+  fetchLoopMessages,
   fetchSkillsCatalog,
+  idleTimeoutForTurn,
+  inboundNeedsDeliveryAck,
+  inputMessageForLoop,
   isCompletionEvent,
   isDaemonLive,
   isSubagentProgressEvent,
+  isTurnEndCustomData,
+  isTurnProgressChunk,
   isValidVerbosityLevel,
   loadConfigFromEnv,
   newLoopInputMessage,
   newLoopNewMessage,
   newLoopSubscribeMessage,
   newRequestID,
+  notificationEnvelope,
   parseNamespace,
+  pingEnvelope,
+  pongEnvelope,
+  protocol1Rpc,
+  refreshAuthToken,
+  requestDaemonConfigReload,
   requestDaemonShutdown,
+  requestEnvelope,
   shouldShow,
   splitWirePayload,
+  subscribeEnvelope,
+  unsubscribeEnvelope,
+  validateLoopInputIntentHint,
   waitDaemonReady,
   waitLoopStatusWithID,
   waitSubscriptionConfirmed