@mirasoth/soothe-client 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,7 +1,27 @@
 import {
+  CLIENT_VERSION,
   Client,
+  ConnectionError,
+  DEFAULT_CLIENT_CAPABILITIES,
+  DEFAULT_DELIVERABLE_PHASES,
+  DaemonError,
+  DisconnectCause,
+  INTENT_HINT_EMBED,
+  INTENT_HINT_IMAGE_TO_TEXT,
+  INTENT_HINT_OCR,
+  INTENT_HINT_TEXT_COMPLETION,
+  LOOP_ASSISTANT_OUTPUT_PHASES,
+  Multiplexer,
+  PROTO_VERSION,
+  REMOVED_INTENT_HINTS,
+  ReconnectError,
+  StaleLoopError,
+  TimeoutError,
+  connectionInitEnvelope,
   decodeMessage,
   defaultConfig,
+  disconnectCauseName,
+  disconnectEnvelope,
   encodeMessage,
   extractSootheLoopID,
   loadConfigFromEnv,
@@ -9,43 +29,15 @@ import {
   newLoopNewMessage,
   newLoopSubscribeMessage,
   newRequestID,
-  splitWirePayload
-} from "./chunk-OMAC7LA7.js";
-
-// 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;
-  }
-};
+  notificationEnvelope,
+  pingEnvelope,
+  pongEnvelope,
+  requestEnvelope,
+  splitWirePayload,
+  subscribeEnvelope,
+  unsubscribeEnvelope,
+  validateLoopInputIntentHint
+} from "./chunk-AQZACDIC.js";
 
 // src/verbosity.ts
 var VerbosityTier = /* @__PURE__ */ ((VerbosityTier2) => {
@@ -83,18 +75,31 @@ var EventTacitusGatherSummary = "soothe.subagent.tacitus.gather.summary";
 var EventTacitusCompleted = "soothe.subagent.tacitus.completed";
 var EventReplayComplete = "replay_complete";
 var EventLoopReattachedWire = "loop_reattached";
+var EventCardReplayBegin = "card.replay_begin";
+var EventCardCreated = "card.created";
+var EventCardReplayEnd = "card.replay_end";
 var EventToolStarted = "soothe.tool.execution.started";
 var EventToolCompleted = "soothe.tool.execution.completed";
 var EventToolError = "soothe.tool.execution.error";
 var EventStreamToolCallUpdate = "soothe.stream.tool_call.update";
 var EventToolCallUpdatesBatch = "tool_call_updates_batch";
-var EventAgentLoopStarted = "soothe.cognition.agent_loop.started";
-var EventAgentLoopIterated = "soothe.cognition.agent_loop.iterated";
-var EventAgentLoopCompleted = "soothe.cognition.agent_loop.completed";
-var EventAgentLoopReasoned = "soothe.cognition.agent_loop.reasoned";
+var EventStrangeLoopStarted = "soothe.cognition.strange_loop.started";
+var EventStrangeLoopCompleted = "soothe.cognition.strange_loop.completed";
+var EventStrangeLoopPlanDecision = "soothe.cognition.strange_loop.plan.decision";
+var EventStrangeLoopReasoned = "soothe.cognition.strange_loop.reasoned";
+var EventStrangeLoopStepStarted = "soothe.cognition.strange_loop.step.started";
+var EventStrangeLoopStepQueued = "soothe.cognition.strange_loop.step.queued";
+var EventStrangeLoopStepCompleted = "soothe.cognition.strange_loop.step.completed";
+var EventStrangeLoopContextCompacted = "soothe.cognition.strange_loop.context.compacted";
 var EventMessageReceived = "soothe.protocol.message.received";
 var EventMessageSent = "soothe.protocol.message.sent";
 var EventFinalReport = "soothe.output.autonomous.final_report.reported";
+var EventAutopilotGoalStatus = "soothe.autopilot.goal.status";
+var EventAutopilotGoalProgress = "soothe.autopilot.goal.progress";
+var EventAutopilotGoalCreated = "soothe.autopilot.goal.created";
+var EventAutopilotGoalCompleted = "soothe.autopilot.goal.completed";
+var EventAutopilotWorkerAssigned = "soothe.autopilot.worker.assigned";
+var EventAutopilotWorkerUnassigned = "soothe.autopilot.worker.unassigned";
 var EventGeneralFailed = "soothe.error.general.failed";
 function parseNamespace(ns) {
   const parts = splitNamespace(ns);
@@ -135,6 +140,8 @@ function classifyByDomainAndComponent(domain, _component, full) {
       return 99 /* Internal */;
     case "subagent":
       return classifySubagentEvent(full);
+    case "autopilot":
+      return 1 /* Normal */;
     case "output":
     case "error":
       return 0 /* Quiet */;
@@ -172,24 +179,13 @@ function isSubagentProgressEvent(eventType) {
   }
   return parsed.action === "started" || parsed.action === "completed";
 }
-var ESSENTIAL_EVENT_TYPES = /* @__PURE__ */ new Set([
-  EventAgentLoopStarted,
-  EventAgentLoopCompleted,
-  EventAgentLoopReasoned,
-  EventPlanCreated,
-  EventExploreStarted,
-  EventExploreCompleted,
-  EventTacitusStarted,
-  EventTacitusCompleted,
-  EventGeneralFailed
-]);
 
 // src/helpers.ts
 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 import("./client-QS23U6WX.js");
+  const { Client: Client2 } = await import("./client-CB6WKQYW.js");
   const t = timeout ?? 5e3;
   const client = new Client2(wsURL, defaultConfig());
   try {
@@ -207,68 +203,103 @@ async function isDaemonLive(wsURL, timeout) {
   }
 }
 async function requestDaemonShutdown(client, timeout) {
-  const resp = await client.requestResponse({ type: "daemon_shutdown" }, "shutdown_ack", timeout ?? 1e4);
+  const resp = await client.requestResponse(
+    "daemon_shutdown",
+    {},
+    "daemon_shutdown",
+    timeout ?? 1e4
+  );
   if (resp.status !== "acknowledged") {
     throw new Error(`shutdown not acknowledged: ${JSON.stringify(resp)}`);
   }
 }
 async function fetchSkillsCatalog(client, timeout) {
-  const resp = await client.requestResponse({ type: "skills_list" }, "skills_list_response", timeout ?? 15e3);
+  const resp = await client.requestResponse("skills_list", {}, "skills_list", timeout ?? 15e3);
   const skillsRaw = resp.skills;
   if (!skillsRaw || !Array.isArray(skillsRaw)) return [];
   return skillsRaw.filter((s) => typeof s === "object" && s !== null);
 }
 async function fetchConfigSection(client, section, timeout) {
-  const resp = await client.requestResponse({ type: "config_get", section }, "config_get_response", timeout ?? 5e3);
+  const resp = await client.requestResponse(
+    "config_get",
+    { section },
+    "config_get",
+    timeout ?? 5e3
+  );
   const sec = resp[section];
   if (sec && typeof sec === "object") {
     return sec;
   }
   return resp;
 }
+async function requestDaemonConfigReload(client, timeout) {
+  return client.requestResponse("config_reload", {}, "config_reload", timeout ?? 15e3);
+}
+async function fetchLoopHistory(client, loopID, timeout) {
+  return client.requestResponse(
+    "loop_history_fetch",
+    { loop_id: loopID },
+    "loop_history_fetch",
+    timeout ?? 15e3
+  );
+}
+async function authenticate(client, accessKey, secretKey, timeout) {
+  return client.requestResponse(
+    "auth",
+    { access_key: accessKey, secret_key: secretKey },
+    "auth",
+    timeout ?? 15e3
+  );
+}
+async function refreshAuthToken(client, refreshToken, timeout) {
+  return client.requestResponse(
+    "auth_refresh",
+    { refresh_token: refreshToken },
+    "auth_refresh",
+    timeout ?? 15e3
+  );
+}
 
 // src/session.ts
 async function bootstrapLoopSession(client, resumeLoopId, config, loopNew) {
   const cfg = config ?? defaultConfig();
-  await client.sendMessage({ type: "daemon_ready" });
-  await waitDaemonReady(client, cfg.daemonReadyTimeout);
   let loopId = (resumeLoopId ?? "").trim();
   if (!loopId) {
+    const env = newLoopNewMessage(loopNew);
     const newResp = await client.requestResponse(
-      newLoopNewMessage(loopNew),
-      "loop_new_response",
+      env.method,
+      env.params ?? {},
+      "loop_new",
       cfg.loopStatusTimeout
     );
     loopId = String(newResp.loop_id ?? "").trim();
     if (!loopId) {
-      throw new Error("loop_new_response missing loop_id");
+      throw new Error("loop_new response missing loop_id");
     }
   }
-  const subResp = await client.requestResponse(
-    { type: "loop_subscribe", loop_id: loopId, verbosity: cfg.verbosityLevel },
-    "loop_subscribe_response",
+  await client.subscribe(
+    "loop_events",
+    { loop_id: loopId, verbosity: cfg.verbosityLevel },
     cfg.subscriptionTimeout
   );
-  if (subResp.success === false) {
-    throw new Error(String(subResp.message ?? "loop_subscribe failed"));
-  }
   return loopId;
 }
 async function waitDaemonReady(client, timeout) {
+  if (client.isConnected()) return;
   const deadline = Date.now() + timeout;
   while (Date.now() < deadline) {
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
     const ev = await client.readEventWithTimeout(remaining);
     if (ev === null) break;
-    if (ev.type === "daemon_ready") {
-      if (ev.state === "ready") return;
-      throw new Error(
-        `daemon not ready: state=${JSON.stringify(ev.state)} message=${JSON.stringify(ev.message ?? "")}`
-      );
+    if (ev.type === "connection_ack") {
+      const result = ev.result ?? {};
+      const state = result.readiness_state;
+      if (state === "ready") return;
+      throw new Error(`daemon not ready: state=${JSON.stringify(state ?? "unknown")}`);
     }
   }
-  throw new Error(`timeout after ${timeout}ms waiting for daemon_ready (state=ready)`);
+  throw new Error(`timeout after ${timeout}ms waiting for connection_ack (ready)`);
 }
 async function waitLoopStatusWithID(client, timeout) {
   const deadline = Date.now() + timeout;
@@ -278,14 +309,13 @@ async function waitLoopStatusWithID(client, timeout) {
     const ev = await client.readEventWithTimeout(remaining);
     if (ev === null) break;
     if (ev.type === "error") {
-      const errResp = ev;
-      throw new Error(`daemon error: ${errResp.code}: ${errResp.message}`);
+      const errObj = ev.error ?? {};
+      throw new DaemonError(errObj.code ?? -32603, errObj.message ?? "daemon error");
     }
     if (ev.type === "status") {
-      const status = ev;
-      const lid = status.loop_id;
+      const lid = ev.loop_id;
       if (lid && lid !== "") {
-        return status;
+        return ev;
       }
     }
   }
@@ -298,15 +328,18 @@ async function waitSubscriptionConfirmed(client, wantLoopID, _wantVerbosity, tim
     if (remaining <= 0) break;
     const ev = await client.readEventWithTimeout(remaining);
     if (ev === null) break;
-    if (ev.type === "loop_subscribe_response" && ev.success === true) {
-      if (String(ev.loop_id ?? "") === wantLoopID) return;
+    if (ev.type === "next") {
+      const payload = ev.payload ?? {};
+      const lid = String(payload.loop_id ?? "");
+      if (lid === wantLoopID && payload.success === true) return;
+      continue;
     }
-    if (ev.type === "subscription_confirmed") {
-      const lid = String(ev.loop_id ?? "");
-      if (lid === wantLoopID) return;
+    if (ev.type === "error") {
+      const errObj = ev.error ?? {};
+      throw new Error(`daemon error: ${errObj.message ?? "subscription failed"}`);
     }
   }
-  throw new Error(`timeout after ${timeout}ms waiting for subscription_confirmed`);
+  throw new Error(`timeout after ${timeout}ms waiting for subscription confirmation`);
 }
 async function connectWithRetries(client, maxRetries, retryDelay) {
   const retries = maxRetries && maxRetries > 0 ? maxRetries : 40;
@@ -321,17 +354,1117 @@ async function connectWithRetries(client, maxRetries, retryDelay) {
     }
     await new Promise((resolve) => setTimeout(resolve, delay));
   }
-  throw new Error(`failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`);
+  throw new Error(
+    `failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`
+  );
+}
+
+// src/appkit/broadcaster.ts
+var SUBSCRIBER_QUEUE_CAP = 100;
+var SSEBroadcaster = class {
+  subscribers = /* @__PURE__ */ new Map();
+  nextSubID = 0;
+  /** Creates an empty broadcaster. */
+  constructor() {
+  }
+  /**
+   * Registers a new subscriber channel for a session id. Returns an async
+   * iterable the subscriber reads events from. Unsubscribe via
+   * `unsubscribe()` or `close()`.
+   */
+  subscribe(sessionID) {
+    const subID = String(this.nextSubID++);
+    const sub = { queue: [], waiters: [], closed: false };
+    let subs = this.subscribers.get(sessionID);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Map();
+      this.subscribers.set(sessionID, subs);
+    }
+    subs.set(subID, sub);
+    const iterable = {
+      [Symbol.asyncIterator]() {
+        return {
+          next() {
+            if (sub.queue.length > 0) {
+              return Promise.resolve({ value: sub.queue.shift(), done: false });
+            }
+            if (sub.closed) {
+              return Promise.resolve({ value: void 0, done: true });
+            }
+            return new Promise((resolve) => {
+              sub.waiters.push((ev) => {
+                if (ev === null) {
+                  resolve({ value: void 0, done: true });
+                } else {
+                  resolve({ value: ev, done: false });
+                }
+              });
+            });
+          }
+        };
+      }
+    };
+    return { iterable, id: subID };
+  }
+  /** Removes a subscriber by id and closes its iterable. Safe if unknown. */
+  unsubscribe(sessionID, subID) {
+    const subs = this.subscribers.get(sessionID);
+    if (!subs) return;
+    const sub = subs.get(subID);
+    if (!sub) return;
+    sub.closed = true;
+    for (const w of sub.waiters) w(null);
+    sub.waiters = [];
+    subs.delete(subID);
+    if (subs.size === 0) this.subscribers.delete(sessionID);
+  }
+  /**
+   * Sends an event to all subscribers for a session id. Non-blocking: a full
+   * subscriber queue is skipped (drop-on-full) so one slow consumer cannot
+   * block the others.
+   */
+  broadcast(sessionID, event) {
+    const subs = this.subscribers.get(sessionID);
+    if (!subs) return;
+    for (const sub of subs.values()) {
+      if (sub.closed) continue;
+      if (sub.waiters.length > 0) {
+        const w = sub.waiters.shift();
+        w(event);
+      } else if (sub.queue.length < SUBSCRIBER_QUEUE_CAP) {
+        sub.queue.push(event);
+      }
+    }
+  }
+  /** Closes all subscribers for a session id and removes the entry. */
+  close(sessionID) {
+    const subs = this.subscribers.get(sessionID);
+    if (!subs) return;
+    for (const sub of subs.values()) {
+      sub.closed = true;
+      for (const w of sub.waiters) w(null);
+      sub.waiters = [];
+    }
+    this.subscribers.delete(sessionID);
+  }
+  /** Closes every subscriber channel across all sessions. */
+  closeAll() {
+    for (const [sessionID, subs] of this.subscribers) {
+      for (const sub of subs.values()) {
+        sub.closed = true;
+        for (const w of sub.waiters) w(null);
+        sub.waiters = [];
+      }
+      this.subscribers.delete(sessionID);
+    }
+  }
+};
+
+// src/appkit/thinking_step.ts
+var MAX_THINKING_STEP_RUNES = 280;
+var DEFAULT_THINKING_STEP_EVENTS = /* @__PURE__ */ new Set([
+  "soothe.cognition.plan.step.started",
+  "soothe.cognition.plan.step.completed",
+  "soothe.cognition.plan.step.failed",
+  "soothe.lifecycle.iteration.started",
+  "soothe.agent.loop.step.started",
+  "soothe.agent.loop.started",
+  "soothe.cognition.plan.batch.started",
+  "soothe.cognition.plan.created",
+  "soothe.cognition.goal.created",
+  "soothe.tool.execution.started"
+]);
+function extractThinkingStep(eventType, data, allow) {
+  if (!eventType || !data) return ["", false];
+  const et = eventType.trim();
+  if (!et) return ["", false];
+  const allowlist = allow ?? DEFAULT_THINKING_STEP_EVENTS;
+  if (!allowlist.has(et)) return ["", false];
+  let line = "";
+  switch (et) {
+    case "soothe.cognition.plan.step.started":
+      line = formatPlanStepLine(data, "");
+      break;
+    case "soothe.cognition.plan.step.completed":
+      line = formatPlanStepLine(data, "done");
+      break;
+    case "soothe.cognition.plan.step.failed": {
+      const stepID = strField(data, "step_id");
+      const errMsg = strField(data, "error");
+      if (stepID && errMsg) line = `Step ${stepID} failed: ${errMsg}`;
+      else if (stepID) line = `Step ${stepID} failed`;
+      else if (errMsg) line = `Step failed: ${errMsg}`;
+      break;
+    }
+    case "soothe.agent.loop.step.started":
+      line = formatAgentStepLine(data, "");
+      break;
+    case "soothe.cognition.plan.batch.started": {
+      const n = data["parallel_count"];
+      if (typeof n === "number" && n > 0) line = `Running ${Math.floor(n)} steps in parallel`;
+      break;
+    }
+    case "soothe.cognition.plan.created":
+    case "soothe.agent.loop.started": {
+      const g = strField(data, "goal");
+      if (g) line = "Goal: " + g;
+      break;
+    }
+    case "soothe.cognition.goal.created": {
+      const g = strField(data, "friendly_message", "description");
+      if (g) line = "Goal: " + g;
+      break;
+    }
+    case "soothe.lifecycle.iteration.started": {
+      const g = strField(data, "goal_description");
+      if (g) line = "Iteration: " + g;
+      break;
+    }
+    case "soothe.tool.execution.started": {
+      const name = strField(data, "tool_name", "name");
+      if (name) line = "Tool: " + name;
+      break;
+    }
+    default:
+      return ["", false];
+  }
+  line = line.trim();
+  if (!line) return ["", false];
+  const runes = [...line];
+  if (runes.length > MAX_THINKING_STEP_RUNES) {
+    line = runes.slice(0, MAX_THINKING_STEP_RUNES).join("") + "\u2026";
+  }
+  return [line, true];
+}
+function formatPlanStepLine(data, suffix) {
+  const stepID = strField(data, "step_id");
+  const desc = strField(data, "description");
+  if (stepID && suffix) return `Step ${stepID}: ${suffix}`;
+  if (stepID && desc) return `Step ${stepID}: ${desc}`;
+  if (stepID) return `Step ${stepID}`;
+  if (desc && suffix) return `Step: ${suffix}`;
+  if (desc) return `Step: ${desc}`;
+  if (suffix) return "Step: " + suffix;
+  return "";
+}
+function formatAgentStepLine(data, suffix) {
+  const stepID = strField(data, "step_id");
+  const desc = strField(data, "description");
+  if (stepID && desc) return `Step ${stepID}: ${desc}`;
+  if (desc) return suffix ? `Step: ${suffix}` : `Step: ${desc}`;
+  if (stepID) return `Step ${stepID}`;
+  return "";
+}
+function strField(data, ...keys) {
+  for (const key of keys) {
+    const v = data[key];
+    if (typeof v === "string") {
+      const s = v.trim();
+      if (s) return s;
+    }
+  }
+  return "";
+}
+
+// src/appkit/classifier.ts
+var ChatEventTerminal = /* @__PURE__ */ ((ChatEventTerminal2) => {
+  ChatEventTerminal2[ChatEventTerminal2["Continue"] = 0] = "Continue";
+  ChatEventTerminal2[ChatEventTerminal2["DeliverableComplete"] = 1] = "DeliverableComplete";
+  ChatEventTerminal2[ChatEventTerminal2["FailedComplete"] = 2] = "FailedComplete";
+  return ChatEventTerminal2;
+})(ChatEventTerminal || {});
+var EVENT_LOOP_HISTORY_REPLAYED = "soothe.lifecycle.loop.history.replayed";
+var EventClassifier = class {
+  deliverablePhases;
+  minDeliverableRunes;
+  thinkingStepEvents;
+  constructor(cfg) {
+    if (!cfg.deliverablePhases) {
+      throw new Error("appkit: ClassifierConfig.deliverablePhases must not be nil");
+    }
+    this.deliverablePhases = cfg.deliverablePhases;
+    this.minDeliverableRunes = cfg.minDeliverableRunes && cfg.minDeliverableRunes > 0 ? cfg.minDeliverableRunes : 8;
+    this.thinkingStepEvents = cfg.thinkingStepEvents;
+  }
+  /**
+   * Inspects one decoded event and returns its outcome. `accumulated` is the
+   * running assistant text so far, used to pick the final reply when a
+   * deliverable event arrives.
+   */
+  classify(msg, accumulated) {
+    return this.processChatEvent(msg, accumulated);
+  }
+  /**
+   * Reports whether a persisted completion_event is user-facing. Uses the
+   * configured deliverable phase set; recognizes the protocol output namespace
+   * and final_report component as deliverable.
+   */
+  isDeliverableCompletionEvent(eventType) {
+    if (!eventType) return false;
+    if (eventType === EventFinalReport) return true;
+    if (eventType.startsWith("soothe.protocol.message.")) {
+      const phase = eventType.slice("soothe.protocol.message.".length);
+      return this.isDeliverableLoopPhase(phase);
+    }
+    return eventType.includes("soothe.output") && eventType.includes("responded");
+  }
+  isDeliverableLoopPhase(phase) {
+    return this.deliverablePhases.has(phase);
+  }
+  deliverableResult(content, completionEvent) {
+    return { content, terminal: 1 /* DeliverableComplete */, completionEvent };
+  }
+  continueResult(content) {
+    return { content, terminal: 0 /* Continue */ };
+  }
+  failedResult(err) {
+    return { terminal: 2 /* FailedComplete */, err };
+  }
+  /** Reports whether trimmed assistant text is long enough to persist as final. */
+  isSubstantiveAssistantReply(content) {
+    return [...content.trim()].length >= this.minDeliverableRunes;
+  }
+  /**
+   * Picks the user-visible reply for a completed query. Only a deliverable
+   * terminal result with a recognized completion event yields a final reply.
+   */
+  resolveDeliverableFinalContent(eventResult, _accumulated) {
+    if (eventResult.terminal !== 1 /* DeliverableComplete */) return ["", false];
+    if (!this.isDeliverableCompletionEvent(eventResult.completionEvent ?? "")) return ["", false];
+    const final = (eventResult.content ?? "").trim();
+    if (final) return [final, true];
+    return ["", false];
+  }
+  /** The event→outcome mapper, ported from triarch's ProcessChatEvent. */
+  processChatEvent(msg, _accumulated) {
+    if (!msg || typeof msg !== "object") {
+      return { terminal: 0 /* Continue */ };
+    }
+    const m = msg;
+    const typ = m.type;
+    if (typ === "next") {
+      return this.classifyNextEnvelope(m);
+    }
+    if (typ === "response" || typ === "complete" || typ === "receipt_response" || typ === "connection_ack" || typ === "status") {
+      return { terminal: 0 /* Continue */ };
+    }
+    if (typ === "error") {
+      const errObj = m.error ?? {};
+      const code = typeof errObj.code === "number" ? errObj.code : -32603;
+      return this.failedResult(
+        new DaemonError(code, errObj.message ?? "daemon error", errObj.data)
+      );
+    }
+    if (typ === "event") {
+      return this.classifyEventPayload(
+        m.namespace ?? null,
+        m.mode ?? "",
+        m.data
+      );
+    }
+    return { terminal: 0 /* Continue */ };
+  }
+  /** Classifies a `next` envelope by projecting its payload. */
+  classifyNextEnvelope(env) {
+    const payload = env.payload ?? {};
+    const innerData = payload.data;
+    if (innerData && typeof innerData === "object") {
+      const innerMode = innerData.mode ?? "";
+      if (innerMode) {
+        return this.classifyEventPayload(
+          innerData.namespace ?? payload.namespace ?? null,
+          innerMode,
+          innerData.data
+        );
+      }
+    }
+    const mode = payload.mode ?? "";
+    if (mode) {
+      return this.classifyEventPayload(payload.namespace ?? null, mode, payload.data);
+    }
+    return { terminal: 0 /* Continue */ };
+  }
+  /**
+   * Classifies an event payload by (namespace, mode, phase). `data` may be a
+   * map or an array of messages (mode="messages").
+   */
+  classifyEventPayload(namespace, mode, data) {
+    const ns = namespaceToString(namespace);
+    const dataMap = normalizeEventData(data);
+    if (dataMap) {
+      let dataType2 = ns;
+      const dt2 = dataMap["type"];
+      if (typeof dt2 === "string" && dt2) dataType2 = dt2;
+      if (dataType2 === EVENT_LOOP_HISTORY_REPLAYED) {
+        return { terminal: 0 /* Continue */ };
+      }
+      const [step, ok] = extractThinkingStep(dataType2, dataMap, this.thinkingStepEvents);
+      if (ok) {
+        return { thinkingStep: step, terminal: 0 /* Continue */ };
+      }
+    }
+    if (mode === "messages") {
+      const result = this.classifyMessagesMode(data, ns);
+      if (result) return result;
+    }
+    if (!dataMap) {
+      return { terminal: 0 /* Continue */ };
+    }
+    let dataType = ns;
+    const dt = dataMap["type"];
+    if (typeof dt === "string" && dt) dataType = dt;
+    let completionEvent = dataType;
+    if (!completionEvent) completionEvent = ns;
+    if (isNamespaceMatch(ns, dataType, "soothe.output") || isNamespaceMatch(ns, dataType, "responded")) {
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) {
+        if (this.isFinalOutputEvent(dataType, ns)) {
+          return this.deliverableResult(content, completionEvent);
+        }
+        return this.continueResult(content);
+      }
+    }
+    if (isNamespaceMatch(ns, dataType, "agent_loop.completed") || isNamespaceMatch(ns, dataType, "agent_loop.reasoned") || isNamespaceMatch(ns, dataType, "loop.completed")) {
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) return this.continueResult(content);
+    }
+    if (isNamespaceMatch(ns, dataType, "final_report")) {
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) return this.deliverableResult(content, completionEvent);
+    }
+    if (dataType.includes("soothe.error.") || ns.includes("soothe.error.")) {
+      const errType = dataType || ns;
+      const msg = dataMap["message"];
+      if (typeof msg === "string" && msg) {
+        return this.failedResult(new Error(`${errType}: ${msg}`));
+      }
+      const [content, ok] = extractContentFromData(dataMap);
+      if (ok) return this.failedResult(new Error(`${errType}: ${content}`));
+      return this.failedResult(new Error(errType));
+    }
+    if (isNamespaceMatch(ns, dataType, "stream") || isNamespaceMatch(ns, dataType, "progress") || isNamespaceMatch(ns, dataType, "tool_call_updates_batch") || isNamespaceMatch(ns, dataType, "soothe.stream.tool_call.update")) {
+      const delta = dataMap["delta"];
+      if (typeof delta === "string") return this.continueResult(delta);
+    }
+    if (isNamespaceMatch(ns, dataType, "heartbeat") || isNamespaceMatch(ns, dataType, "system.daemon") || isNamespaceMatch(ns, dataType, "agent_loop.started") || isNamespaceMatch(ns, dataType, "intent.classified")) {
+      return { terminal: 0 /* Continue */ };
+    }
+    return { terminal: 0 /* Continue */ };
+  }
+  /** Classifies a mode="messages" payload (array of message objects). */
+  classifyMessagesMode(data, _ns) {
+    const items = Array.isArray(data) ? data : null;
+    if (!items || items.length === 0) return null;
+    const first = items[0];
+    if (!first || typeof first !== "object") return null;
+    const [msgType, rawContent, phase, hasPayload] = firstMessagePayload(data);
+    if (hasPayload && rawContent && isStreamingMessageType(msgType)) {
+      return this.continueResult(rawContent);
+    }
+    const loopMsg = loopAIMessage(data);
+    if (loopMsg) {
+      const content = loopMsg.content;
+      if (content) {
+        if (isStreamingMessageType(loopMsg.type)) {
+          return this.continueResult(content);
+        }
+        if (this.isDeliverableLoopPhase(loopMsg.phase) && this.isSubstantiveAssistantReply(content)) {
+          return this.deliverableResult(content, "soothe.protocol.message." + loopMsg.phase);
+        }
+        return this.continueResult(content);
+      }
+    }
+    const [directContent, directOk] = this.messagesModeAssistantContent(data);
+    if (directOk && this.isSubstantiveAssistantReply(directContent)) {
+      return this.deliverableResult(directContent, "soothe.protocol.message.direct_model");
+    }
+    if (hasPayload && rawContent) {
+      if (isTerminalMessageType(msgType) || msgType === "") {
+        if (this.isDeliverableLoopPhase(phase) && this.isSubstantiveAssistantReply(rawContent)) {
+          return this.deliverableResult(rawContent, "soothe.protocol.message." + phase);
+        }
+        return this.continueResult(rawContent);
+      }
+      return this.continueResult(rawContent);
+    }
+    return null;
+  }
+  /**
+   * Extracts plain assistant text from mode="messages" events that carry a
+   * terminal AIMessage without loop-tagged phase metadata (legacy direct_llm turns
+   * before phase tagging; prefer deliverablePhases including text_completion).
+   */
+  messagesModeAssistantContent(data) {
+    if (!Array.isArray(data) || data.length === 0) return ["", false];
+    const msgMap = data[0];
+    if (!msgMap || typeof msgMap !== "object") return ["", false];
+    const phase = typeof msgMap.phase === "string" ? msgMap.phase.trim() : "";
+    if (phase) return ["", false];
+    const msgType = typeof msgMap.type === "string" ? msgMap.type : "";
+    if (msgType && !isTerminalMessageType(msgType)) return ["", false];
+    const content = extractContentFromMessage(msgMap).trim();
+    if (!content) return ["", false];
+    return [content, true];
+  }
+  /** soothe output/responded events that carry user-facing final text. */
+  isFinalOutputEvent(dataType, ns) {
+    const combined = dataType + " " + ns;
+    if (combined.includes("final_report")) return true;
+    for (const phase of this.deliverablePhases) {
+      if (combined.includes(phase)) return true;
+    }
+    return false;
+  }
+};
+function isStreamingMessageType(msgType) {
+  return msgType === "AIMessageChunk" || msgType === "ai_chunk" || msgType === "message_chunk";
+}
+function isTerminalMessageType(msgType) {
+  return msgType === "AIMessage" || msgType === "ai" || msgType === "assistant";
+}
+function firstMessagePayload(data) {
+  if (!Array.isArray(data) || data.length === 0) return ["", "", "", false];
+  const msgMap = data[0];
+  if (!msgMap || typeof msgMap !== "object") return ["", "", "", false];
+  const msgType = typeof msgMap.type === "string" ? msgMap.type : "";
+  const phase = typeof msgMap.phase === "string" ? msgMap.phase : "";
+  const content = extractContentFromMessage(msgMap);
+  return [msgType, content, phase, true];
+}
+function loopAIMessage(data) {
+  if (!Array.isArray(data) || data.length === 0) return null;
+  const msgMap = data[0];
+  if (!msgMap || typeof msgMap !== "object") return null;
+  const phase = typeof msgMap.phase === "string" ? msgMap.phase.trim() : "";
+  if (!phase) return null;
+  const type = typeof msgMap.type === "string" ? msgMap.type : "";
+  const content = extractContentFromMessage(msgMap);
+  return { type, content, phase };
+}
+function extractContentFromMessage(msgMap) {
+  const c = msgMap.content;
+  if (typeof c === "string" && c) return c;
+  if (Array.isArray(c) && c.length > 0) {
+    let b = "";
+    for (const item of c) {
+      if (typeof item === "string") {
+        b += item;
+        continue;
+      }
+      if (item && typeof item === "object") {
+        const blk = item;
+        const t = blk.text;
+        if (typeof t === "string") b += t;
+      }
+    }
+    return b;
+  }
+  const blocks = msgMap.content_blocks;
+  if (Array.isArray(blocks) && blocks.length > 0) {
+    let b = "";
+    for (const blk of blocks) {
+      if (blk && typeof blk === "object") {
+        const m = blk;
+        const t = m.text;
+        if (typeof t === "string") b += t;
+      }
+    }
+    return b;
+  }
+  return "";
+}
+function extractContentFromData(data) {
+  for (const key of [
+    "final_stdout_message",
+    "completion_summary",
+    "content",
+    "text",
+    "response",
+    "output",
+    "message",
+    "report"
+  ]) {
+    const val = data[key];
+    if (typeof val === "string" && val) return [val, true];
+  }
+  const nested = data.data;
+  if (nested && typeof nested === "object") {
+    const nm = nested;
+    for (const key of [
+      "final_stdout_message",
+      "completion_summary",
+      "content",
+      "text",
+      "response",
+      "output",
+      "message",
+      "report"
+    ]) {
+      const val = nm[key];
+      if (typeof val === "string" && val) return [val, true];
+    }
+  }
+  return ["", false];
+}
+function isNamespaceMatch(ns, dataType, pattern) {
+  return dataType.includes(pattern) || ns.includes(pattern);
+}
+function namespaceToString(namespace) {
+  if (typeof namespace === "string") return namespace;
+  if (Array.isArray(namespace)) return namespace.filter((s) => typeof s === "string").join(".");
+  return "";
+}
+function normalizeEventData(data) {
+  if (data == null) return null;
+  if (typeof data === "object" && !Array.isArray(data)) {
+    return data;
+  }
+  if (typeof data === "string") {
+    try {
+      const m = JSON.parse(data);
+      if (m && typeof m === "object" && !Array.isArray(m)) return m;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/appkit/query_gate.ts
+var ErrQueryBusy = class extends Error {
+  constructor() {
+    super("appkit: query already in progress for session");
+    this.name = "ErrQueryBusy";
+  }
+};
+var QueryGate = class {
+  active = /* @__PURE__ */ new Map();
+  /** Constructs an empty gate. */
+  constructor() {
+  }
+  /**
+   * Reserves sessionID for one agent turn. Returns ErrQueryBusy if a query is
+   * already in flight. `abort` is the AbortController for the query's timeout
+   * context. `sendCancel` is the daemon-cancel sender; it is invoked from
+   * `cancel()` on a detached 10s timeout.
+   */
+  acquire(sessionID, abort, sendCancel) {
+    if (this.active.has(sessionID)) {
+      throw new ErrQueryBusy();
+    }
+    this.active.set(sessionID, { abort, sendCancel });
+  }
+  /**
+   * Cooperatively stops a running query for sessionID. Sends the daemon cancel
+   * (on a detached 10s-timeout abort so caller cancellation cannot block the
+   * wire send) BEFORE aborting the local context. Returns silently if no query
+   * is in flight (intent already satisfied).
+   */
+  async cancel(sessionID) {
+    const state = this.active.get(sessionID);
+    if (!state) return;
+    this.active.delete(sessionID);
+    if (state.sendCancel) {
+      const detached = new AbortController();
+      const timer = setTimeout(() => detached.abort(), 1e4);
+      try {
+        await state.sendCancel(detached.signal);
+      } catch {
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    state.abort.abort();
+  }
+  /**
+   * Clears the gate for sessionID without sending a daemon cancel. Call when a
+   * query completes normally (success or local failure) so the next turn can
+   * acquire.
+   */
+  release(sessionID) {
+    this.active.delete(sessionID);
+  }
+  /** Reports whether a query is in flight for sessionID. */
+  isActive(sessionID) {
+    return this.active.has(sessionID);
+  }
+};
+
+// src/appkit/client.ts
+function defaultClientFactory() {
+  return (url, config) => {
+    return new Client(url, config ?? defaultConfig());
+  };
+}
+function defaultBootstrapFunc() {
+  return async (client, workspaceID, userID, config) => {
+    const c = client;
+    const opts = {
+      client_workspace: workspaceID,
+      user_id: userID,
+      client_workspace_id: workspaceID
+    };
+    return bootstrapLoopSession(c, "", config, opts);
+  };
+}
+
+// src/appkit/pool.ts
+var ErrPoolExhausted = class extends Error {
+  constructor() {
+    super("appkit: connection pool exhausted");
+    this.name = "ErrPoolExhausted";
+  }
+};
+function defaultPoolConfig() {
+  return {
+    poolSize: 1e3,
+    queryTimeout: 30 * 60 * 1e3,
+    connectionTimeout: 3e4,
+    maxIdleTime: 10 * 60 * 1e3,
+    healthCheckInterval: 3e4
+  };
+}
+var PooledConn = class {
+  slotID;
+  client;
+  eventStream = null;
+  streamController = null;
+  sessionID = "";
+  loopID = "";
+  workspaceID = "";
+  lastUsed = 0;
+  constructor(slotID, client) {
+    this.slotID = slotID;
+    this.client = client;
+  }
+  /** Reports whether the underlying client signalled a drop. */
+  isDisconnected() {
+    return this.client.isDisconnected();
+  }
+  isConnected() {
+    return this.client.isConnected() && !this.isDisconnected();
+  }
+  getLoopID() {
+    return this.loopID;
+  }
+};
+var ConnectionPool = class {
+  cfg;
+  scfg;
+  factory;
+  bootstrap;
+  store;
+  pool = [];
+  activeSlots = /* @__PURE__ */ new Map();
+  nextSlotID = 1;
+  url;
+  /**
+   * Constructs a pool. `url` is the daemon WebSocket URL. If cfg is null,
+   * defaultPoolConfig is used; if scfg is null, defaultConfig is used; nil
+   * factory/bootstrap fall back to the defaults.
+   */
+  constructor(url, store, cfg, scfg, factory) {
+    this.cfg = cfg ?? defaultPoolConfig();
+    this.scfg = scfg ?? defaultConfig();
+    this.factory = factory ?? defaultClientFactory();
+    this.bootstrap = defaultBootstrapFunc();
+    this.store = store;
+    this.url = url;
+    for (let i = 0; i < this.cfg.poolSize; i++) {
+      this.pool.push(new PooledConn(this.nextSlotID++, this.factory(url, this.scfg)));
+    }
+  }
+  /** Overrides the loop bootstrap function (useful for test fakes). */
+  withBootstrap(f) {
+    if (f) this.bootstrap = f;
+    return this;
+  }
+  /**
+   * Returns a live connection for sessionID, reusing an active slot or
+   * bootstrapping/reattaching as needed. The caller must call `release()`
+   * when done with the connection (a turn completes or the session is reset).
+   */
+  async acquire(sessionID, workspaceID, userID, _signal) {
+    const existing = this.activeSlots.get(sessionID);
+    if (existing) {
+      if (existing.isDisconnected() || !existing.isConnected()) {
+        await this.release(sessionID);
+      } else {
+        existing.lastUsed = Date.now();
+        await this.store.updateLastUsed(sessionID).catch(() => {
+        });
+        return existing;
+      }
+    }
+    const conn = this.pool.pop();
+    if (!conn) throw new ErrPoolExhausted();
+    this.activeSlots.set(sessionID, conn);
+    const { loopID, ok } = await this.store.getLoopIDForSession(sessionID).catch(() => ({ loopID: "", ok: false }));
+    let finalLoopID = "";
+    try {
+      if (!ok || !loopID) {
+        await conn.client.connect();
+        finalLoopID = await this.bootstrapNew(conn, workspaceID, userID);
+        await this.store.createSession(workspaceID, sessionID, finalLoopID, "").catch(() => {
+        });
+      } else {
+        try {
+          await this.resumeAndReattach(conn, loopID);
+          finalLoopID = loopID;
+        } catch {
+          await conn.client.connect();
+          finalLoopID = await this.bootstrapNew(conn, workspaceID, userID);
+          await this.store.createSession(workspaceID, sessionID, finalLoopID, "").catch(() => {
+          });
+        }
+      }
+    } catch (err) {
+      await this.release(sessionID);
+      throw err;
+    }
+    conn.sessionID = sessionID;
+    conn.loopID = finalLoopID;
+    conn.workspaceID = workspaceID;
+    conn.lastUsed = Date.now();
+    await this.store.updateLastUsed(sessionID).catch(() => {
+    });
+    return conn;
+  }
+  /** Tears down the connection for sessionID and returns the slot. */
+  async release(sessionID) {
+    const conn = this.activeSlots.get(sessionID);
+    if (!conn) return;
+    this.activeSlots.delete(sessionID);
+    if (conn.streamController) {
+      conn.streamController.abort();
+      conn.streamController = null;
+    }
+    try {
+      conn.client.close();
+    } catch {
+    }
+    conn.sessionID = "";
+    conn.loopID = "";
+    conn.eventStream = null;
+    this.pool.push(new PooledConn(this.nextSlotID++, this.factory(this.url, this.scfg)));
+  }
+  /**
+   * Tears down the connection for sessionID so the next acquire bootstraps
+   * fresh. The store should archive the loop id so getLoopIDForSession returns
+   * false next time.
+   */
+  async resetSession(sessionID) {
+    await this.release(sessionID);
+  }
+  /** Gracefully shuts down all active connections. */
+  stop() {
+    for (const [sid, conn] of this.activeSlots) {
+      if (conn.streamController) conn.streamController.abort();
+      try {
+        conn.client.close();
+      } catch {
+      }
+      this.activeSlots.delete(sid);
+    }
+  }
+  /** Stats snapshot for observability. */
+  stats() {
+    return { active: this.activeSlots.size, idle: this.pool.length };
+  }
+  /** Bootstrap a fresh loop and start the reader. */
+  async bootstrapNew(conn, workspaceID, userID) {
+    const loopID = await this.bootstrap(conn.client, workspaceID, userID, this.scfg);
+    this.startReader(conn);
+    return loopID;
+  }
+  /** Reconnect + reattach an existing loop, then start the reader. */
+  async resumeAndReattach(conn, loopID) {
+    await conn.client.connect();
+    try {
+      await conn.client.reattachAndProbe(loopID);
+    } catch (err) {
+      if (err instanceof StaleLoopError) throw err;
+      throw err;
+    }
+    this.startReader(conn);
+  }
+  /** Starts a receiveMessages generator and stores the stream + controller. */
+  startReader(conn) {
+    const controller = new AbortController();
+    conn.streamController = controller;
+    conn.eventStream = conn.client.receiveMessages(controller.signal);
+  }
+};
+
+// src/appkit/turn_runner.ts
+var ErrQueryTimeout = class extends Error {
+  constructor() {
+    super("appkit: query timeout");
+    this.name = "ErrQueryTimeout";
+  }
+};
+function inputMessageForLoop(text, loopID, attachments, opts) {
+  const msg = { type: "loop_input", content: text };
+  if (loopID) msg.loop_id = loopID;
+  if (attachments && attachments.length > 0) msg.attachments = attachments;
+  if (opts) {
+    if (opts.intentHint?.trim()) {
+      const hintError = validateLoopInputIntentHint(opts.intentHint);
+      if (hintError) {
+        throw new Error(hintError);
+      }
+      msg.intent_hint = opts.intentHint.trim();
+    }
+    if (opts.preferredSubagent?.trim()) msg.preferred_subagent = opts.preferredSubagent.trim();
+    if (opts.responseSchema && Object.keys(opts.responseSchema).length > 0) {
+      msg.response_schema = opts.responseSchema;
+    }
+    if (opts.responseSchemaName?.trim()) msg.response_schema_name = opts.responseSchemaName.trim();
+    if (opts.responseSchemaStrict !== void 0)
+      msg.response_schema_strict = opts.responseSchemaStrict;
+  }
+  return msg;
 }
+var TurnRunner = class {
+  pool;
+  gate;
+  classifier;
+  store;
+  broadcaster;
+  cfg;
+  buildInput = inputMessageForLoop;
+  onComplete = null;
+  onError = null;
+  /**
+   * Constructs a TurnRunner. pool, gate, classifier, and store are required;
+   * broadcaster may be null.
+   */
+  constructor(pool, gate, classifier, store, broadcaster, cfg) {
+    this.pool = pool;
+    this.gate = gate;
+    this.classifier = classifier;
+    this.store = store;
+    this.broadcaster = broadcaster;
+    this.cfg = { queryTimeout: cfg.queryTimeout > 0 ? cfg.queryTimeout : 30 * 60 * 1e3 };
+  }
+  /** Overrides the loop_input payload builder. */
+  withInputBuilder(f) {
+    if (f) this.buildInput = f;
+    return this;
+  }
+  /** Sets a completion hook (runs inline on success). */
+  withOnComplete(f) {
+    this.onComplete = f;
+    return this;
+  }
+  /** Sets an error hook (runs inline on failure). */
+  withOnError(f) {
+    this.onError = f;
+    return this;
+  }
+  /**
+   * Runs one query turn. The response is broadcast via the SSE broadcaster and
+   * persisted via the SessionStore; it is not returned to the caller (SSE
+   * subscribers receive it). Resolves on success; rejects on failure
+   * (ErrQueryTimeout, AbortError, or a daemon/processing error).
+   */
+  async execute(sessionID, message, userID, workspaceID, attachments, opts, signal) {
+    let conn;
+    try {
+      conn = await this.pool.acquire(sessionID, workspaceID, userID, signal);
+    } catch (err) {
+      await this.persistFailed(sessionID, "", err);
+      this.broadcastError(sessionID, err);
+      this.onError?.(sessionID, "", err);
+      throw err;
+    }
+    const loopID = conn.getLoopID();
+    const timeoutController = new AbortController();
+    const timeoutMs = this.cfg.queryTimeout;
+    const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+    const sendCancel = async (detachedSignal) => {
+      await this.sendLoopCancel(detachedSignal, conn, loopID);
+    };
+    try {
+      this.gate.acquire(sessionID, timeoutController, sendCancel);
+    } catch (err) {
+      clearTimeout(timer);
+      await this.pool.release(sessionID);
+      await this.persistFailed(sessionID, loopID, err);
+      this.broadcastError(sessionID, err);
+      this.onError?.(sessionID, loopID, err);
+      throw err;
+    }
+    try {
+      const inputMsg = this.buildInput(
+        message,
+        loopID,
+        attachments ?? void 0,
+        opts ?? void 0
+      );
+      try {
+        await conn.client.sendMessage(inputMsg);
+      } catch (err) {
+        await this.persistFailed(sessionID, loopID, err);
+        this.broadcastError(sessionID, err);
+        this.onError?.(sessionID, loopID, err);
+        throw err;
+      }
+      const eventStream = conn.eventStream;
+      if (!eventStream) {
+        const err = new Error(`missing event stream for session ${sessionID} (loop ${loopID})`);
+        await this.persistFailed(sessionID, loopID, err);
+        this.broadcastError(sessionID, err);
+        this.onError?.(sessionID, loopID, err);
+        throw err;
+      }
+      let assistantContent = "";
+      const startedAt = Date.now();
+      const abortRace = new Promise((resolve) => {
+        const onTimeout = () => resolve("timeout");
+        timeoutController.signal.addEventListener("abort", onTimeout, { once: true });
+        if (signal) {
+          const onCaller = () => resolve("caller");
+          signal.addEventListener("abort", onCaller, { once: true });
+        }
+      });
+      const iterator = eventStream[Symbol.asyncIterator]();
+      while (true) {
+        const next = iterator.next();
+        const raced = await Promise.race([
+          next.then((res2) => ({ tag: "msg", res: res2 })),
+          abortRace.then((tag) => ({ tag }))
+        ]);
+        if ("tag" in raced && raced.tag !== "msg") {
+          if (raced.tag === "caller" || signal?.aborted) {
+            const err = new Error("aborted");
+            await this.persistFailed(sessionID, loopID, err);
+            this.broadcastError(sessionID, err);
+            this.onError?.(sessionID, loopID, err);
+            throw err;
+          }
+          await this.sendLoopCancel(new AbortController().signal, conn, loopID).catch(() => {
+          });
+          await this.persistFailed(sessionID, loopID, new ErrQueryTimeout());
+          this.broadcastError(sessionID, new ErrQueryTimeout());
+          this.onError?.(sessionID, loopID, new ErrQueryTimeout());
+          throw new ErrQueryTimeout();
+        }
+        const res = raced.res;
+        if (res.done) {
+          const err = new Error("event stream closed");
+          await this.persistFailed(sessionID, loopID, err);
+          this.broadcastError(sessionID, err);
+          this.onError?.(sessionID, loopID, err);
+          throw err;
+        }
+        const msg = res.value;
+        const eventResult = this.classifier.classify(msg, assistantContent);
+        if (eventResult.err && eventResult.terminal === 2 /* FailedComplete */) {
+          await this.persistFailed(sessionID, loopID, eventResult.err);
+          this.broadcastError(sessionID, eventResult.err);
+          this.onError?.(sessionID, loopID, eventResult.err);
+          throw eventResult.err;
+        }
+        const step = (eventResult.thinkingStep ?? "").trim();
+        if (step) this.broadcastThinkingStep(sessionID, step);
+        if (eventResult.content) {
+          if (eventResult.content.startsWith(assistantContent)) {
+            assistantContent = eventResult.content;
+          } else {
+            assistantContent += eventResult.content;
+          }
+        }
+        const [final, deliverable] = this.classifier.resolveDeliverableFinalContent(
+          eventResult,
+          assistantContent
+        );
+        if (deliverable) {
+          const elapsedMs = Date.now() - startedAt;
+          await this.persistResponse(
+            sessionID,
+            loopID,
+            final,
+            startedAt,
+            eventResult.completionEvent ?? ""
+          );
+          this.broadcastComplete(sessionID, final);
+          this.onComplete?.(sessionID, loopID, final, eventResult.completionEvent ?? "", elapsedMs);
+          return;
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+      this.gate.release(sessionID);
+    }
+  }
+  /** Asks the daemon to cooperatively stop the loop runner on a detached signal. */
+  async sendLoopCancel(_signal, conn, loopID) {
+    const lid = (loopID ?? "").trim();
+    if (!conn || !lid) return;
+    const cancelMsg = { type: "command_request", command: "cancel", loop_id: lid };
+    await conn.client.sendMessage(cancelMsg);
+  }
+  async persistResponse(sessionID, loopID, content, startedAt, completionEvent) {
+    const msg = {
+      role: "assistant",
+      content,
+      metadata: {
+        started_at: startedAt,
+        completed_at: Date.now(),
+        duration_ms: Date.now() - startedAt,
+        status: "completed",
+        completion_event: completionEvent,
+        deliverable: true
+      }
+    };
+    await this.store.appendMessage(sessionID, msg).catch(() => {
+    });
+  }
+  async persistFailed(sessionID, _loopID, err) {
+    const msg = {
+      role: "error",
+      content: err.message,
+      metadata: { status: "failed", error_message: err.message }
+    };
+    await this.store.appendMessage(sessionID, msg).catch(() => {
+    });
+  }
+  broadcastThinkingStep(sessionID, step) {
+    if (!this.broadcaster) return;
+    this.broadcaster.broadcast(sessionID, { type: "delta", data: step + "\n" });
+  }
+  broadcastComplete(sessionID, content) {
+    this.broadcaster?.broadcast(sessionID, { type: "complete", data: content });
+  }
+  broadcastError(sessionID, err) {
+    this.broadcaster?.broadcast(sessionID, { type: "query_error", data: err.message });
+  }
+};
 export {
+  CLIENT_VERSION,
+  ChatEventTerminal,
   Client,
   ConnectionError,
+  ConnectionPool,
+  DEFAULT_CLIENT_CAPABILITIES,
+  DEFAULT_DELIVERABLE_PHASES,
+  DEFAULT_THINKING_STEP_EVENTS,
   DaemonError,
-  ESSENTIAL_EVENT_TYPES,
-  EventAgentLoopCompleted,
-  EventAgentLoopIterated,
-  EventAgentLoopReasoned,
-  EventAgentLoopStarted,
+  DisconnectCause,
+  ErrPoolExhausted,
+  ErrQueryBusy,
+  ErrQueryTimeout,
+  EventAutopilotGoalCompleted,
+  EventAutopilotGoalCreated,
+  EventAutopilotGoalProgress,
+  EventAutopilotGoalStatus,
+  EventAutopilotWorkerAssigned,
+  EventAutopilotWorkerUnassigned,
+  EventCardCreated,
+  EventCardReplayBegin,
+  EventCardReplayEnd,
+  EventClassifier,
   EventExploreCompleted,
   EventExploreMilestone,
   EventExploreStarted,
@@ -343,6 +1476,14 @@ export {
   EventMessageSent,
   EventPlanCreated,
   EventReplayComplete,
+  EventStrangeLoopCompleted,
+  EventStrangeLoopContextCompacted,
+  EventStrangeLoopPlanDecision,
+  EventStrangeLoopReasoned,
+  EventStrangeLoopStarted,
+  EventStrangeLoopStepCompleted,
+  EventStrangeLoopStepQueued,
+  EventStrangeLoopStepStarted,
   EventStreamToolCallUpdate,
   EventTacitusCompleted,
   EventTacitusGatherSummary,
@@ -351,18 +1492,42 @@ export {
   EventToolCompleted,
   EventToolError,
   EventToolStarted,
+  INTENT_HINT_EMBED,
+  INTENT_HINT_IMAGE_TO_TEXT,
+  INTENT_HINT_OCR,
+  INTENT_HINT_TEXT_COMPLETION,
+  LOOP_ASSISTANT_OUTPUT_PHASES,
+  Multiplexer,
+  PROTO_VERSION,
+  PooledConn,
+  QueryGate,
+  REMOVED_INTENT_HINTS,
+  ReconnectError,
+  SSEBroadcaster,
+  StaleLoopError,
   TimeoutError,
+  TurnRunner,
   VerbosityTier,
+  authenticate,
   bootstrapLoopSession,
   checkDaemonStatus,
   classifyEventVerbosity,
   connectWithRetries,
+  connectionInitEnvelope,
   decodeMessage,
+  defaultBootstrapFunc,
+  defaultClientFactory,
   defaultConfig,
+  defaultPoolConfig,
+  disconnectCauseName,
+  disconnectEnvelope,
   encodeMessage,
   extractSootheLoopID,
+  extractThinkingStep,
   fetchConfigSection,
+  fetchLoopHistory,
   fetchSkillsCatalog,
+  inputMessageForLoop,
   isCompletionEvent,
   isDaemonLive,
   isSubagentProgressEvent,
@@ -372,10 +1537,19 @@ export {
   newLoopNewMessage,
   newLoopSubscribeMessage,
   newRequestID,
+  notificationEnvelope,
   parseNamespace,
+  pingEnvelope,
+  pongEnvelope,
+  refreshAuthToken,
+  requestDaemonConfigReload,
   requestDaemonShutdown,
+  requestEnvelope,
   shouldShow,
   splitWirePayload,
+  subscribeEnvelope,
+  unsubscribeEnvelope,
+  validateLoopInputIntentHint,
   waitDaemonReady,
   waitLoopStatusWithID,
   waitSubscriptionConfirmed