@mirasoth/soothe-client 0.2.1 → 0.4.0

package/dist/index.js

@@ -6,17 +6,55 @@ import {
   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,
-  Multiplexer,
   PROTO_VERSION,
   REMOVED_INTENT_HINTS,
   ReconnectError,
+  STREAM_END,
   StaleLoopError,
   TimeoutError,
+  VerbosityTier,
+  classifyEventVerbosity,
   connectionInitEnvelope,
   decodeMessage,
   defaultConfig,
@@ -24,168 +62,182 @@ import {
   disconnectEnvelope,
   encodeMessage,
   extractSootheLoopID,
+  inboundNeedsDeliveryAck,
+  isCompletionEvent,
+  isSubagentProgressEvent,
+  isTurnEndCustomData,
+  isTurnProgressChunk,
+  isValidVerbosityLevel,
   loadConfigFromEnv,
   newLoopInputMessage,
   newLoopNewMessage,
   newLoopSubscribeMessage,
   newRequestID,
   notificationEnvelope,
+  parseNamespace,
   pingEnvelope,
   pongEnvelope,
   requestEnvelope,
+  shouldShow,
   splitWirePayload,
   subscribeEnvelope,
   unsubscribeEnvelope,
   validateLoopInputIntentHint
-} from "./chunk-AQZACDIC.js";
+} from "./chunk-U6RMINYV.js";
 
-// 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;
+// 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");
+    }
   }
-  const level = verbosityLevelValues[verbosity] ?? 1;
-  return tier <= level;
-}
-function isValidVerbosityLevel(s) {
-  return s in verbosityLevelValues;
+  await client.subscribe(
+    "loop_events",
+    { loop_id: loopId, verbosity: cfg.verbosityLevel },
+    cfg.subscriptionTimeout
+  );
+  return loopId;
 }
-
-// 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 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 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);
-  if (parts.length < 4 || parts[0] !== "soothe") {
-    return null;
-  }
-  if (parts[1] === "internal") {
-    return null;
+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")}`);
+    }
   }
-  return { domain: parts[1], component: parts[2], action: parts[3] };
+  throw new Error(`timeout after ${timeout}ms waiting for connection_ack (ready)`);
 }
-function splitNamespace(ns) {
-  const parts = [];
-  let start = 0;
-  for (let i = 0; i < ns.length; i++) {
-    if (ns[i] === ".") {
-      parts.push(ns.slice(start, i));
-      start = i + 1;
+async function 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;
+      }
     }
   }
-  parts.push(ns.slice(start));
-  return parts;
+  throw new Error(`timeout after ${timeout}ms waiting for status with loop_id`);
 }
-function classifyEventVerbosity(eventTypeOrNamespace) {
-  const parsed = parseNamespace(eventTypeOrNamespace);
-  if (!parsed) {
-    return classifyByEventTypeString(eventTypeOrNamespace);
+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"}`);
+    }
   }
-  return classifyByDomainAndComponent(parsed.domain, parsed.component, eventTypeOrNamespace);
+  throw new Error(`timeout after ${timeout}ms waiting for subscription confirmation`);
 }
-function classifyByDomainAndComponent(domain, _component, full) {
-  switch (domain) {
-    case "cognition":
-      return 1 /* Normal */;
-    case "protocol":
-      return 2 /* Detailed */;
-    case "tool":
-      return 99 /* Internal */;
-    case "subagent":
-      return classifySubagentEvent(full);
-    case "autopilot":
-      return 1 /* Normal */;
-    case "output":
-    case "error":
-      return 0 /* Quiet */;
-    default:
-      return 1 /* Normal */;
+async function connectWithRetries(client, maxRetries, retryDelay) {
+  const retries = maxRetries && maxRetries > 0 ? maxRetries : 40;
+  const delay = retryDelay && retryDelay > 0 ? retryDelay : 250;
+  let lastErr = null;
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      await client.connect();
+      return;
+    } catch (err) {
+      lastErr = err;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delay));
   }
+  throw new Error(
+    `failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`
+  );
 }
-function 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 */;
+
+// 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();
   }
-}
-function classifyByEventTypeString(eventType) {
-  if (eventType === EventFinalReport || eventType === EventGeneralFailed) {
-    return 0 /* Quiet */;
+  async withClient(fn) {
+    const client = new Client(this.url, this.config);
+    try {
+      await connectWithRetries(client, 5, 250);
+      return await fn(client);
+    } finally {
+      client.close();
+    }
   }
-  if (eventType === EventToolStarted) {
-    return 99 /* Internal */;
+  /** Generic one-shot RPC. */
+  async request(method, params = {}) {
+    return this.withClient(
+      (client) => client.requestResponse(method, params, void 0, this.timeoutMs)
+    );
   }
-  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 jobCreate(goal, workspace = "") {
+    const params = { goal };
+    if (workspace) params.workspace = workspace;
+    return this.request("job_create", params);
   }
-  return parsed.action === "started" || parsed.action === "completed";
-}
+  async jobStatus(jobId) {
+    return this.request("job_status", { job_id: jobId });
+  }
+  async jobCancel(jobId) {
+    return this.request("job_cancel", { job_id: jobId });
+  }
+  async cronAdd(text, priority = 0) {
+    const params = { text };
+    if (priority > 0) params.priority = priority;
+    return this.request("cron_add", params);
+  }
+  async cronList(status = "") {
+    const params = {};
+    if (status) params.status = status;
+    return this.request("cron_list", params);
+  }
+};
 
 // src/helpers.ts
 async function checkDaemonStatus(client, timeout) {
   return client.requestResponse("daemon_status", {}, "daemon_status", timeout ?? 5e3);
 }
 async function isDaemonLive(wsURL, timeout) {
-  const { Client: Client2 } = await import("./client-CB6WKQYW.js");
+  const { Client: Client2 } = await import("./client-UNPC32NQ.js");
   const t = timeout ?? 5e3;
   const client = new Client2(wsURL, defaultConfig());
   try {
@@ -259,104 +311,74 @@ async function refreshAuthToken(client, refreshToken, timeout) {
     timeout ?? 15e3
   );
 }
-
-// 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");
-    }
-  }
-  await client.subscribe(
-    "loop_events",
-    { loop_id: loopId, verbosity: cfg.verbosityLevel },
-    cfg.subscriptionTimeout
+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
   );
-  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")}`);
+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));
     }
-  }
-  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;
-      }
+    if (!client.isConnected()) {
+      throw new Error("Timed out waiting for daemon handshake");
     }
+    return await fn(client);
+  } finally {
+    client.close();
   }
-  throw new Error(`timeout after ${timeout}ms waiting for 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"}`);
+async function protocol1Rpc(wsUrl, method, params = null, opts = {}) {
+  const mode = opts.mode ?? "request";
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  try {
+    return await connectedWebsocket(
+      wsUrl,
+      async (client) => {
+        if (mode === "notify") {
+          await client.notify(method, params ?? {});
+          return {};
+        }
+        if (mode === "subscribe") {
+          const subId = await client.subscribe(
+            method,
+            params ?? {},
+            timeoutMs
+          );
+          return { subscription_id: subId };
+        }
+        const result = await client.requestResponse(
+          method,
+          params ?? {},
+          method,
+          timeoutMs
+        );
+        return result && typeof result === "object" ? result : { result };
+      },
+      timeoutMs
+    );
+  } catch (exc) {
+    const msg = exc instanceof Error ? exc.message : String(exc);
+    if (msg.toLowerCase().includes("timed out") || msg.toLowerCase().includes("timeout")) {
+      return { error: "Timed out waiting for daemon response" };
     }
-  }
-  throw new Error(`timeout after ${timeout}ms waiting for subscription confirmation`);
-}
-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;
+    if (msg.toLowerCase().includes("connect") || msg.toLowerCase().includes("dial")) {
+      return { error: `Connection error: ${msg}` };
     }
-    await new Promise((resolve) => setTimeout(resolve, delay));
+    return { error: msg };
   }
-  throw new Error(
-    `failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`
-  );
 }
 
 // src/appkit/broadcaster.ts
@@ -578,6 +600,7 @@ var EventClassifier = class {
   deliverablePhases;
   minDeliverableRunes;
   thinkingStepEvents;
+  treatStatusIdleAsComplete;
   constructor(cfg) {
     if (!cfg.deliverablePhases) {
       throw new Error("appkit: ClassifierConfig.deliverablePhases must not be nil");
@@ -585,6 +608,7 @@ var EventClassifier = class {
     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
@@ -601,6 +625,13 @@ var EventClassifier = class {
    */
   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);
@@ -636,16 +667,22 @@ var EventClassifier = class {
     return ["", false];
   }
   /** The event→outcome mapper, ported from triarch's ProcessChatEvent. */
-  processChatEvent(msg, _accumulated) {
+  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);
+      return this.classifyNextEnvelope(m, accumulated);
     }
-    if (typ === "response" || typ === "complete" || typ === "receipt_response" || typ === "connection_ack" || typ === "status") {
+    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") {
@@ -665,10 +702,14 @@ var EventClassifier = class {
     return { terminal: 0 /* Continue */ };
   }
   /** Classifies a `next` envelope by projecting its payload. */
-  classifyNextEnvelope(env) {
+  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(
@@ -679,6 +720,11 @@ var EventClassifier = class {
       }
     }
     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);
     }
@@ -1090,10 +1136,15 @@ var ConnectionPool = class {
       if (existing.isDisconnected() || !existing.isConnected()) {
         await this.release(sessionID);
       } else {
-        existing.lastUsed = Date.now();
-        await this.store.updateLastUsed(sessionID).catch(() => {
-        });
-        return existing;
+        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();
@@ -1196,6 +1247,88 @@ var ConnectionPool = class {
   }
 };
 
+// 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() {
@@ -1203,6 +1336,19 @@ var ErrQueryTimeout = class extends Error {
     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;
@@ -1225,6 +1371,13 @@ function inputMessageForLoop(text, loopID, attachments, opts) {
   }
   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;
@@ -1235,39 +1388,29 @@ var TurnRunner = class {
   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 };
+    this.cfg = {
+      ...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 {
@@ -1295,13 +1438,19 @@ var TurnRunner = class {
       this.onError?.(sessionID, loopID, err);
       throw err;
     }
+    let idleTimer = null;
+    const clearIdle = () => {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+    };
     try {
-      const inputMsg = this.buildInput(
-        message,
-        loopID,
-        attachments ?? void 0,
-        opts ?? void 0
-      );
+      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) {
@@ -1320,6 +1469,23 @@ var TurnRunner = class {
       }
       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 });
@@ -1333,34 +1499,71 @@ var TurnRunner = class {
         const next = iterator.next();
         const raced = await Promise.race([
           next.then((res2) => ({ tag: "msg", res: res2 })),
-          abortRace.then((tag) => ({ tag }))
+          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.persistFailed(sessionID, loopID, new ErrQueryTimeout());
-          this.broadcastError(sessionID, new ErrQueryTimeout());
-          this.onError?.(sessionID, loopID, new ErrQueryTimeout());
-          throw new ErrQueryTimeout();
+          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);
@@ -1380,25 +1583,39 @@ var TurnRunner = class {
           assistantContent
         );
         if (deliverable) {
-          const elapsedMs = Date.now() - startedAt;
-          await this.persistResponse(
+          clearIdle();
+          await this.completeTurn(
             sessionID,
             loopID,
             final,
             startedAt,
             eventResult.completionEvent ?? ""
           );
-          this.broadcastComplete(sessionID, final);
-          this.onComplete?.(sessionID, loopID, final, eventResult.completionEvent ?? "", elapsedMs);
           return;
         }
       }
     } finally {
+      clearIdle();
       clearTimeout(timer);
       this.gate.release(sessionID);
     }
   }
-  /** Asks the daemon to cooperatively stop the loop runner on a detached signal. */
+  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;
@@ -1441,17 +1658,469 @@ var TurnRunner = class {
     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,
+  DaemonSession,
   DisconnectCause,
+  ErrIdleTimeout,
   ErrPoolExhausted,
   ErrQueryBusy,
   ErrQueryTimeout,
@@ -1497,26 +2166,31 @@ export {
   INTENT_HINT_OCR,
   INTENT_HINT_TEXT_COMPLETION,
   LOOP_ASSISTANT_OUTPUT_PHASES,
-  Multiplexer,
   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,
-  defaultBootstrapFunc,
-  defaultClientFactory,
   defaultConfig,
   defaultPoolConfig,
   disconnectCauseName,
@@ -1525,12 +2199,18 @@ export {
   extractSootheLoopID,
   extractThinkingStep,
   fetchConfigSection,
+  fetchLoopCards,
   fetchLoopHistory,
+  fetchLoopMessages,
   fetchSkillsCatalog,
+  idleTimeoutForTurn,
+  inboundNeedsDeliveryAck,
   inputMessageForLoop,
   isCompletionEvent,
   isDaemonLive,
   isSubagentProgressEvent,
+  isTurnEndCustomData,
+  isTurnProgressChunk,
   isValidVerbosityLevel,
   loadConfigFromEnv,
   newLoopInputMessage,
@@ -1541,6 +2221,7 @@ export {
   parseNamespace,
   pingEnvelope,
   pongEnvelope,
+  protocol1Rpc,
   refreshAuthToken,
   requestDaemonConfigReload,
   requestDaemonShutdown,