@mirasoth/soothe-client 0.1.0 → 0.4.0

package/dist/index.js

@@ -1,195 +1,243 @@
 import {
+  CLIENT_VERSION,
   Client,
+  ConnectionError,
+  DEFAULT_CLIENT_CAPABILITIES,
+  DEFAULT_DELIVERABLE_PHASES,
+  DaemonError,
+  DisconnectCause,
+  EventAutopilotGoalCompleted,
+  EventAutopilotGoalCreated,
+  EventAutopilotGoalProgress,
+  EventAutopilotGoalStatus,
+  EventAutopilotWorkerAssigned,
+  EventAutopilotWorkerUnassigned,
+  EventCardCreated,
+  EventCardReplayBegin,
+  EventCardReplayEnd,
+  EventExploreCompleted,
+  EventExploreMilestone,
+  EventExploreStarted,
+  EventExploreStepCompleted,
+  EventFinalReport,
+  EventGeneralFailed,
+  EventLoopReattachedWire,
+  EventMessageReceived,
+  EventMessageSent,
+  EventPlanCreated,
+  EventReplayComplete,
+  EventStrangeLoopCompleted,
+  EventStrangeLoopContextCompacted,
+  EventStrangeLoopPlanDecision,
+  EventStrangeLoopReasoned,
+  EventStrangeLoopStarted,
+  EventStrangeLoopStepCompleted,
+  EventStrangeLoopStepQueued,
+  EventStrangeLoopStepStarted,
+  EventStreamToolCallUpdate,
+  EventTacitusCompleted,
+  EventTacitusGatherSummary,
+  EventTacitusStarted,
+  EventToolCallUpdatesBatch,
+  EventToolCompleted,
+  EventToolError,
+  EventToolStarted,
+  INTENT_HINT_EMBED,
+  INTENT_HINT_IMAGE_TO_TEXT,
+  INTENT_HINT_OCR,
+  INTENT_HINT_TEXT_COMPLETION,
+  LOOP_ASSISTANT_OUTPUT_PHASES,
+  PROTO_VERSION,
+  REMOVED_INTENT_HINTS,
+  ReconnectError,
+  STREAM_END,
+  StaleLoopError,
+  TimeoutError,
+  VerbosityTier,
+  classifyEventVerbosity,
+  connectionInitEnvelope,
   decodeMessage,
   defaultConfig,
+  disconnectCauseName,
+  disconnectEnvelope,
   encodeMessage,
   extractSootheLoopID,
+  inboundNeedsDeliveryAck,
+  isCompletionEvent,
+  isSubagentProgressEvent,
+  isTurnEndCustomData,
+  isTurnProgressChunk,
+  isValidVerbosityLevel,
   loadConfigFromEnv,
   newLoopInputMessage,
   newLoopNewMessage,
   newLoopSubscribeMessage,
   newRequestID,
-  splitWirePayload
-} from "./chunk-OMAC7LA7.js";
+  notificationEnvelope,
+  parseNamespace,
+  pingEnvelope,
+  pongEnvelope,
+  requestEnvelope,
+  shouldShow,
+  splitWirePayload,
+  subscribeEnvelope,
+  unsubscribeEnvelope,
+  validateLoopInputIntentHint
+} from "./chunk-U6RMINYV.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;
+// src/session.ts
+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");
+    }
   }
-};
-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;
+  await client.subscribe(
+    "loop_events",
+    { loop_id: loopId, verbosity: cfg.verbosityLevel },
+    cfg.subscriptionTimeout
+  );
+  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 === "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")}`);
+    }
   }
-};
-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;
+  throw new Error(`timeout after ${timeout}ms waiting for connection_ack (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 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;
+      }
+    }
   }
-};
-
-// 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;
+  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 === "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"}`);
+    }
   }
-  const level = verbosityLevelValues[verbosity] ?? 1;
-  return tier <= level;
+  throw new Error(`timeout after ${timeout}ms waiting for subscription confirmation`);
 }
-function isValidVerbosityLevel(s) {
-  return s in verbosityLevelValues;
+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"}`
+  );
 }
 
-// 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;
+// 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 (parts[1] === "internal") {
-    return null;
+  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 { 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 "output":
-    case "error":
-      return 0 /* Quiet */;
-    default:
-      return 1 /* Normal */;
+  /** Generic one-shot RPC. */
+  async request(method, params = {}) {
+    return this.withClient(
+      (client) => client.requestResponse(method, params, void 0, this.timeoutMs)
+    );
   }
-}
-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 jobCreate(goal, workspace = "") {
+    const params = { goal };
+    if (workspace) params.workspace = workspace;
+    return this.request("job_create", params);
   }
-}
-function classifyByEventTypeString(eventType) {
-  if (eventType === EventFinalReport || eventType === EventGeneralFailed) {
-    return 0 /* Quiet */;
+  async jobStatus(jobId) {
+    return this.request("job_status", { job_id: jobId });
   }
-  if (eventType === EventToolStarted) {
-    return 99 /* Internal */;
+  async jobCancel(jobId) {
+    return this.request("job_cancel", { job_id: jobId });
   }
-  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;
+  async cronAdd(text, priority = 0) {
+    const params = { text };
+    if (priority > 0) params.priority = priority;
+    return this.request("cron_add", params);
   }
-  return parsed.action === "started" || parsed.action === "completed";
-}
-var ESSENTIAL_EVENT_TYPES = /* @__PURE__ */ new Set([
-  EventAgentLoopStarted,
-  EventAgentLoopCompleted,
-  EventAgentLoopReasoned,
-  EventPlanCreated,
-  EventExploreStarted,
-  EventExploreCompleted,
-  EventTacitusStarted,
-  EventTacitusCompleted,
-  EventGeneralFailed
-]);
+  async cronList(status = "") {
+    const params = {};
+    if (status) params.status = status;
+    return this.request("cron_list", params);
+  }
+};
 
 // 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-UNPC32NQ.js");
   const t = timeout ?? 5e3;
   const client = new Client2(wsURL, defaultConfig());
   try {
@@ -207,131 +255,1885 @@ 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
-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
+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
+  );
+}
+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 import("./client-UNPC32NQ.js");
+  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();
+  }
+}
+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
     );
-    loopId = String(newResp.loop_id ?? "").trim();
-    if (!loopId) {
-      throw new Error("loop_new_response missing loop_id");
+  } 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 (msg.toLowerCase().includes("connect") || msg.toLowerCase().includes("dial")) {
+      return { error: `Connection error: ${msg}` };
+    }
+    return { error: msg };
   }
-  const subResp = await client.requestResponse(
-    { type: "loop_subscribe", loop_id: loopId, verbosity: cfg.verbosityLevel },
-    "loop_subscribe_response",
-    cfg.subscriptionTimeout
-  );
-  if (subResp.success === false) {
-    throw new Error(String(subResp.message ?? "loop_subscribe failed"));
+}
+
+// src/appkit/broadcaster.ts
+var SUBSCRIBER_QUEUE_CAP = 100;
+var SSEBroadcaster = class {
+  subscribers = /* @__PURE__ */ new Map();
+  nextSubID = 0;
+  /** Creates an empty broadcaster. */
+  constructor() {
   }
-  return loopId;
+  /**
+   * 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];
 }
-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 ?? "")}`
+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 */ };
   }
-  throw new Error(`timeout after ${timeout}ms waiting for daemon_ready (state=ready)`);
+  /** 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";
 }
-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}`);
+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;
+      }
     }
-    if (ev.type === "status") {
-      const status = ev;
-      const lid = status.loop_id;
-      if (lid && lid !== "") {
-        return status;
+    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;
   }
-  throw new Error(`timeout after ${timeout}ms waiting for status with loop_id`);
+  return "";
 }
-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;
+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];
     }
-    if (ev.type === "subscription_confirmed") {
-      const lid = String(ev.loop_id ?? "");
-      if (lid === wantLoopID) return;
+  }
+  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;
     }
   }
-  throw new Error(`timeout after ${timeout}ms waiting for subscription_confirmed`);
+  return null;
 }
-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++) {
+
+// 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 {
+        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 {
-      await client.connect();
-      return;
+      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) {
-      lastErr = err;
+      await this.release(sessionID);
+      throw err;
     }
-    await new Promise((resolve) => setTimeout(resolve, delay));
+    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);
   }
-  throw new Error(`failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`);
+  /** 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
+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/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;
+    }
+  }
+};
 export {
+  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,
@@ -343,6 +2145,14 @@ export {
   EventMessageSent,
   EventPlanCreated,
   EventReplayComplete,
+  EventStrangeLoopCompleted,
+  EventStrangeLoopContextCompacted,
+  EventStrangeLoopPlanDecision,
+  EventStrangeLoopReasoned,
+  EventStrangeLoopStarted,
+  EventStrangeLoopStepCompleted,
+  EventStrangeLoopStepQueued,
+  EventStrangeLoopStepStarted,
   EventStreamToolCallUpdate,
   EventTacitusCompleted,
   EventTacitusGatherSummary,
@@ -351,31 +2161,76 @@ export {
   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