@mirasoth/soothe-client 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -106,6 +106,37 @@ var init_errors = __esm({
   }
 });
 
+// src/verbosity.ts
+function shouldShow(tier, verbosity) {
+  if (tier === 99 /* Internal */) {
+    return false;
+  }
+  const level = verbosityLevelValues[verbosity] ?? 1;
+  return tier <= level;
+}
+function isValidVerbosityLevel(s) {
+  return s in verbosityLevelValues;
+}
+var VerbosityTier, verbosityLevelValues;
+var init_verbosity = __esm({
+  "src/verbosity.ts"() {
+    "use strict";
+    VerbosityTier = /* @__PURE__ */ ((VerbosityTier2) => {
+      VerbosityTier2[VerbosityTier2["Quiet"] = 0] = "Quiet";
+      VerbosityTier2[VerbosityTier2["Normal"] = 1] = "Normal";
+      VerbosityTier2[VerbosityTier2["Detailed"] = 2] = "Detailed";
+      VerbosityTier2[VerbosityTier2["Debug"] = 3] = "Debug";
+      VerbosityTier2[VerbosityTier2["Internal"] = 99] = "Internal";
+      return VerbosityTier2;
+    })(VerbosityTier || {});
+    verbosityLevelValues = {
+      quiet: 0,
+      normal: 1,
+      debug: 3
+    };
+  }
+});
+
 // src/config.ts
 function defaultConfig() {
   return {
@@ -326,7 +357,7 @@ var init_protocol = __esm({
     import_node_crypto = require("crypto");
     PROTO_VERSION = "1";
     DEFAULT_CLIENT_CAPABILITIES = ["streaming", "batch", "heartbeat", "receipts"];
-    CLIENT_VERSION = "0.1.0";
+    CLIENT_VERSION = "0.4.0";
   }
 });
 
@@ -374,6 +405,129 @@ var init_intent_hints = __esm({
   }
 });
 
+// src/events.ts
+function parseNamespace(ns) {
+  const parts = splitNamespace(ns);
+  if (parts.length < 4 || parts[0] !== "soothe") {
+    return null;
+  }
+  if (parts[1] === "internal") {
+    return null;
+  }
+  return { domain: parts[1], component: parts[2], action: parts[3] };
+}
+function splitNamespace(ns) {
+  const parts = [];
+  let start = 0;
+  for (let i = 0; i < ns.length; i++) {
+    if (ns[i] === ".") {
+      parts.push(ns.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(ns.slice(start));
+  return parts;
+}
+function classifyEventVerbosity(eventTypeOrNamespace) {
+  const parsed = parseNamespace(eventTypeOrNamespace);
+  if (!parsed) {
+    return classifyByEventTypeString(eventTypeOrNamespace);
+  }
+  return classifyByDomainAndComponent(parsed.domain, parsed.component, eventTypeOrNamespace);
+}
+function classifyByDomainAndComponent(domain, _component, full) {
+  switch (domain) {
+    case "cognition":
+      return 1 /* Normal */;
+    case "protocol":
+      return 2 /* Detailed */;
+    case "tool":
+      return 99 /* Internal */;
+    case "subagent":
+      return classifySubagentEvent(full);
+    case "autopilot":
+      return 1 /* Normal */;
+    case "output":
+    case "error":
+      return 0 /* Quiet */;
+    default:
+      return 1 /* Normal */;
+  }
+}
+function classifySubagentEvent(full) {
+  const parsed = parseNamespace(full);
+  if (!parsed) return 1 /* Normal */;
+  switch (parsed.action) {
+    case "started":
+    case "completed":
+      return 1 /* Normal */;
+    default:
+      return 2 /* Detailed */;
+  }
+}
+function classifyByEventTypeString(eventType) {
+  if (eventType === EventFinalReport || eventType === EventGeneralFailed) {
+    return 0 /* Quiet */;
+  }
+  if (eventType === EventToolStarted) {
+    return 99 /* Internal */;
+  }
+  return 1 /* Normal */;
+}
+function isCompletionEvent(eventType) {
+  return eventType.endsWith(".completed") || eventType.endsWith(".failed") || eventType === EventGeneralFailed;
+}
+function isSubagentProgressEvent(eventType) {
+  const parsed = parseNamespace(eventType);
+  if (!parsed || parsed.domain !== "subagent") {
+    return false;
+  }
+  return parsed.action === "started" || parsed.action === "completed";
+}
+var EventPlanCreated, EventExploreStarted, EventExploreMilestone, EventExploreStepCompleted, EventExploreCompleted, EventTacitusStarted, EventTacitusGatherSummary, EventTacitusCompleted, EventReplayComplete, EventLoopReattachedWire, EventCardReplayBegin, EventCardCreated, EventCardReplayEnd, EventToolStarted, EventToolCompleted, EventToolError, EventStreamToolCallUpdate, EventToolCallUpdatesBatch, EventStrangeLoopStarted, EventStrangeLoopCompleted, EventStrangeLoopPlanDecision, EventStrangeLoopReasoned, EventStrangeLoopStepStarted, EventStrangeLoopStepQueued, EventStrangeLoopStepCompleted, EventStrangeLoopContextCompacted, EventMessageReceived, EventMessageSent, EventFinalReport, EventAutopilotGoalStatus, EventAutopilotGoalProgress, EventAutopilotGoalCreated, EventAutopilotGoalCompleted, EventAutopilotWorkerAssigned, EventAutopilotWorkerUnassigned, EventGeneralFailed;
+var init_events = __esm({
+  "src/events.ts"() {
+    "use strict";
+    init_verbosity();
+    EventPlanCreated = "soothe.cognition.plan.created";
+    EventExploreStarted = "soothe.subagent.explore.started";
+    EventExploreMilestone = "soothe.subagent.explore.milestone";
+    EventExploreStepCompleted = "soothe.subagent.explore.step.completed";
+    EventExploreCompleted = "soothe.subagent.explore.completed";
+    EventTacitusStarted = "soothe.subagent.tacitus.started";
+    EventTacitusGatherSummary = "soothe.subagent.tacitus.gather.summary";
+    EventTacitusCompleted = "soothe.subagent.tacitus.completed";
+    EventReplayComplete = "replay_complete";
+    EventLoopReattachedWire = "loop_reattached";
+    EventCardReplayBegin = "card.replay_begin";
+    EventCardCreated = "card.created";
+    EventCardReplayEnd = "card.replay_end";
+    EventToolStarted = "soothe.tool.execution.started";
+    EventToolCompleted = "soothe.tool.execution.completed";
+    EventToolError = "soothe.tool.execution.error";
+    EventStreamToolCallUpdate = "soothe.stream.tool_call.update";
+    EventToolCallUpdatesBatch = "tool_call_updates_batch";
+    EventStrangeLoopStarted = "soothe.cognition.strange_loop.started";
+    EventStrangeLoopCompleted = "soothe.cognition.strange_loop.completed";
+    EventStrangeLoopPlanDecision = "soothe.cognition.strange_loop.plan.decision";
+    EventStrangeLoopReasoned = "soothe.cognition.strange_loop.reasoned";
+    EventStrangeLoopStepStarted = "soothe.cognition.strange_loop.step.started";
+    EventStrangeLoopStepQueued = "soothe.cognition.strange_loop.step.queued";
+    EventStrangeLoopStepCompleted = "soothe.cognition.strange_loop.step.completed";
+    EventStrangeLoopContextCompacted = "soothe.cognition.strange_loop.context.compacted";
+    EventMessageReceived = "soothe.protocol.message.received";
+    EventMessageSent = "soothe.protocol.message.sent";
+    EventFinalReport = "soothe.output.autonomous.final_report.reported";
+    EventAutopilotGoalStatus = "soothe.autopilot.goal.status";
+    EventAutopilotGoalProgress = "soothe.autopilot.goal.progress";
+    EventAutopilotGoalCreated = "soothe.autopilot.goal.created";
+    EventAutopilotGoalCompleted = "soothe.autopilot.goal.completed";
+    EventAutopilotWorkerAssigned = "soothe.autopilot.worker.assigned";
+    EventAutopilotWorkerUnassigned = "soothe.autopilot.worker.unassigned";
+    EventGeneralFailed = "soothe.error.general.failed";
+  }
+});
+
 // src/multiplexer.ts
 var Multiplexer;
 var init_multiplexer = __esm({
@@ -517,6 +671,203 @@ var init_multiplexer = __esm({
   }
 });
 
+// src/stream_terminal.ts
+function isTurnEndCustomData(data) {
+  if (!data || typeof data !== "object") return false;
+  const customType = String(data.type ?? "").trim();
+  if (!TURN_END_CUSTOM_TYPES.has(customType)) return false;
+  if (customType === STREAM_END) {
+    const scope = String(data.scope ?? "turn").trim().toLowerCase();
+    return scope === "" || scope === "turn";
+  }
+  return true;
+}
+function isTurnProgressChunk(mode, data) {
+  if (mode === "messages" || mode === "updates") return true;
+  if (mode !== "custom" || !data || typeof data !== "object") return false;
+  if (isTurnEndCustomData(data)) return false;
+  const customType = String(data.type ?? "").trim();
+  if (TURN_PROGRESS_CUSTOM_TYPES.has(customType)) return true;
+  if (customType.startsWith("soothe.cognition.strange_loop.step")) return true;
+  return false;
+}
+function stalePendingFrameLabel(event) {
+  const eventType = String(event.type ?? "");
+  if (STALE_TURN_PENDING_TYPES.has(eventType)) return eventType;
+  if (eventType === "next") {
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object") return null;
+    const p = payload;
+    const staleMode = String(p.mode ?? "");
+    if (STALE_TURN_PENDING_TYPES.has(staleMode)) return staleMode;
+    const inner = p.data;
+    if (inner && typeof inner === "object") {
+      return stalePendingFrameLabel(inner);
+    }
+    return null;
+  }
+  if (eventType === "event") {
+    const mode = String(event.mode ?? "");
+    const data = event.data;
+    if (mode === "custom" && isTurnEndCustomData(data)) {
+      return String(data.type ?? "").trim();
+    }
+  }
+  return null;
+}
+function inboundNeedsDeliveryAck(event) {
+  const eventType = String(event.type ?? "");
+  if (eventType === "complete") return true;
+  if (eventType === "next") {
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object") return false;
+    const p = payload;
+    const inner = p.data;
+    if (!inner || typeof inner !== "object") return false;
+    if (String(p.mode ?? "") === "event") {
+      return inboundNeedsAckFromEventShape(inner);
+    }
+    return false;
+  }
+  if (eventType === "event") return inboundNeedsAckFromEventShape(event);
+  return false;
+}
+function inboundNeedsAckFromEventShape(event) {
+  const mode = String(event.mode ?? "");
+  const data = event.data;
+  if (mode === "custom" && isTurnEndCustomData(data)) return true;
+  if (mode === "messages" && Array.isArray(data) && data.length > 0) {
+    const body = data[0];
+    if (!body || typeof body !== "object") return false;
+    const t = String(body.type ?? "");
+    return t === STREAM_END || t.includes("stream.end");
+  }
+  return false;
+}
+function extractLoopIdFromInbound(event) {
+  const direct = String(event.loop_id ?? "").trim();
+  if (direct) return direct;
+  if (String(event.type ?? "") !== "next") return "";
+  const payload = event.payload;
+  if (!payload || typeof payload !== "object") return "";
+  const p = payload;
+  const fromPayload = String(p.loop_id ?? "").trim();
+  if (fromPayload) return fromPayload;
+  const inner = p.data;
+  if (inner && typeof inner === "object") {
+    return String(inner.loop_id ?? "").trim();
+  }
+  return "";
+}
+var STREAM_END, TURN_END_CUSTOM_TYPES, TURN_PROGRESS_CUSTOM_TYPES, STALE_TURN_PENDING_TYPES;
+var init_stream_terminal = __esm({
+  "src/stream_terminal.ts"() {
+    "use strict";
+    init_events();
+    STREAM_END = "soothe.stream.end";
+    TURN_END_CUSTOM_TYPES = /* @__PURE__ */ new Set([
+      STREAM_END,
+      EventStrangeLoopCompleted
+    ]);
+    TURN_PROGRESS_CUSTOM_TYPES = /* @__PURE__ */ new Set([
+      EventPlanCreated,
+      EventStrangeLoopStepStarted,
+      EventStrangeLoopStepQueued,
+      EventStrangeLoopStepCompleted
+    ]);
+    STALE_TURN_PENDING_TYPES = /* @__PURE__ */ new Set([
+      "connection_ack",
+      EventCardReplayBegin,
+      EventCardReplayEnd,
+      EventCardCreated,
+      "complete"
+    ]);
+  }
+});
+
+// src/inbound_priority.ts
+function inboundFrameDropPriority(event) {
+  if (!event) return DROP_PRIORITY_CRITICAL;
+  let eventType = String(event.type ?? "");
+  if (eventType === "event_batch" || eventType === "tool_call_updates_batch") {
+    return DROP_PRIORITY_HIGH;
+  }
+  if (eventType === "next") {
+    const payload = event.payload;
+    if (payload && typeof payload === "object") {
+      const p = payload;
+      const innerMode = String(p.mode ?? "");
+      const innerData = p.data;
+      if (innerMode === "messages") {
+        if (messagesWireTerminal(innerData)) return DROP_PRIORITY_CRITICAL;
+        if (Array.isArray(innerData) && innerData[0] && typeof innerData[0] === "object") {
+          if (String(innerData[0].phase ?? "") === "goal_completion") {
+            return DROP_PRIORITY_CRITICAL;
+          }
+        }
+      }
+      if (String(p.type ?? "") === "complete") return DROP_PRIORITY_CRITICAL;
+      if (innerData && typeof innerData === "object") {
+        return inboundFrameDropPriority(innerData);
+      }
+      eventType = String(p.type ?? "");
+    }
+  }
+  if (eventType === "complete" || eventType === "error" || eventType === "connection_ack") {
+    return DROP_PRIORITY_CRITICAL;
+  }
+  if (eventType === "status") {
+    const state = String(event.state ?? "");
+    if (["idle", "running", "stopped", "detached"].includes(state)) {
+      return DROP_PRIORITY_CRITICAL;
+    }
+  }
+  if (eventType === "event") {
+    const mode = String(event.mode ?? "");
+    const data = event.data;
+    if (mode === "custom") {
+      if (isTurnEndCustomData(data)) return DROP_PRIORITY_CRITICAL;
+      if (data && typeof data === "object") {
+        const customType = String(data.type ?? "");
+        if (customType.startsWith("soothe.cognition.")) return DROP_PRIORITY_HIGH;
+        if (customType.startsWith("soothe.error.") || customType === "stream_degraded") {
+          return DROP_PRIORITY_CRITICAL;
+        }
+        if (customType === "soothe.ux.stream_tool_wire.tool_call_updates_batch") {
+          return DROP_PRIORITY_HIGH;
+        }
+      }
+    }
+    if (mode === "messages") {
+      if (messagesWireTerminal(data)) return DROP_PRIORITY_CRITICAL;
+      if (Array.isArray(data) && data[0] && typeof data[0] === "object") {
+        if (String(data[0].phase ?? "") === "goal_completion") {
+          return DROP_PRIORITY_CRITICAL;
+        }
+      }
+    }
+  }
+  return DROP_PRIORITY_NORMAL;
+}
+function messagesWireTerminal(data) {
+  if (!Array.isArray(data) || data.length === 0) return false;
+  const body = data[0];
+  if (!body || typeof body !== "object") return false;
+  const t = String(body.type ?? "");
+  return t === STREAM_END || t.includes("stream.end");
+}
+var DROP_PRIORITY_CRITICAL, DROP_PRIORITY_HIGH, DROP_PRIORITY_NORMAL, DEFAULT_INBOUND_MAX_SIZE;
+var init_inbound_priority = __esm({
+  "src/inbound_priority.ts"() {
+    "use strict";
+    init_stream_terminal();
+    DROP_PRIORITY_CRITICAL = 0;
+    DROP_PRIORITY_HIGH = 1;
+    DROP_PRIORITY_NORMAL = 2;
+    DEFAULT_INBOUND_MAX_SIZE = 2e4;
+  }
+});
+
 // src/client.ts
 var client_exports = {};
 __export(client_exports, {
@@ -532,12 +883,17 @@ var init_client = __esm({
     init_errors();
     init_multiplexer();
     init_intent_hints();
+    init_stream_terminal();
+    init_inbound_priority();
     init_protocol();
     Client = class extends import_node_events.EventEmitter {
       url;
       config;
       ws = null;
       messageBuffer = [];
+      inboundMaxSize = DEFAULT_INBOUND_MAX_SIZE;
+      inboundDroppedCount = 0;
+      onStreamDegraded = null;
       resolvers = [];
       // Protocol-1 handshake state (RFC-450 §8.2)
       handshakeComplete = false;
@@ -555,6 +911,8 @@ var init_client = __esm({
       // Pending-request/subscription multiplexer (RFC-629 constraint #1). Routes
       // inbound frames by (type, id) instead of discarding non-matching events.
       mux = new Multiplexer();
+      deliveryRecvSeq = /* @__PURE__ */ new Map();
+      deliveryAckedSeq = /* @__PURE__ */ new Map();
       constructor(url, config) {
         super();
         this.url = url;
@@ -622,13 +980,15 @@ var init_client = __esm({
                 this._signalDisconnect(1 /* Clean */);
               }
               if (this.mux.route(m)) {
+                this._trackInboundDeliveryAck(m);
                 continue;
               }
+              this._trackInboundDeliveryAck(m);
               const resolver = this.resolvers.shift();
               if (resolver) {
                 resolver(msg);
               } else {
-                this.messageBuffer.push(msg);
+                this.enqueueMessageBuffer(msg);
               }
               this.emit("message", msg);
             }
@@ -941,6 +1301,84 @@ var init_client = __esm({
           this.resolvers.push(resolver);
         });
       }
+      /**
+       * Remove stale handshake/terminal frames left in `messageBuffer` before a turn.
+       * Returns labels of removed frames (in order).
+       */
+      peelStalePendingControlEvents() {
+        if (this.messageBuffer.length === 0) return [];
+        const kept = [];
+        const removed = [];
+        while (this.messageBuffer.length > 0) {
+          const event = this.messageBuffer.shift();
+          const label = stalePendingFrameLabel(event);
+          if (label !== null) {
+            removed.push(label);
+            continue;
+          }
+          kept.push(event);
+        }
+        this.messageBuffer = kept;
+        return removed;
+      }
+      /** True when the underlying socket is still open (may not be handshaked). */
+      isConnectionAlive() {
+        return this.ws !== null && this.ws.readyState === import_ws.default.OPEN;
+      }
+      /** Override pending buffer cap (tests / tuning). */
+      setInboundMaxSize(n) {
+        if (n > 0) this.inboundMaxSize = n;
+      }
+      /** How many NORMAL-priority frames were dropped under backpressure. */
+      inboundDropped() {
+        return this.inboundDroppedCount;
+      }
+      /** Hook invoked on the first inbound overflow drop. */
+      setStreamDegradedCallback(fn) {
+        this.onStreamDegraded = fn;
+      }
+      enqueueMessageBuffer(msg) {
+        const max = this.inboundMaxSize > 0 ? this.inboundMaxSize : DEFAULT_INBOUND_MAX_SIZE;
+        if (this.messageBuffer.length < max) {
+          this.messageBuffer.push(msg);
+          return;
+        }
+        const ev = msg;
+        let dropIdx = -1;
+        let dropPri = -1;
+        for (let i = 0; i < this.messageBuffer.length; i++) {
+          const p = inboundFrameDropPriority(this.messageBuffer[i]);
+          if (p > dropPri) {
+            dropPri = p;
+            dropIdx = i;
+          }
+        }
+        const incomingPri = inboundFrameDropPriority(ev);
+        if (dropIdx >= 0 && dropPri >= DROP_PRIORITY_NORMAL) {
+          this.messageBuffer.splice(dropIdx, 1);
+          this.messageBuffer.push(msg);
+          this.noteInboundDrop();
+          return;
+        }
+        if (incomingPri >= DROP_PRIORITY_NORMAL) {
+          this.noteInboundDrop();
+          return;
+        }
+        if (this.messageBuffer.length > 0) {
+          this.messageBuffer.shift();
+          this.noteInboundDrop();
+        }
+        this.messageBuffer.push(msg);
+      }
+      noteInboundDrop() {
+        this.inboundDroppedCount += 1;
+        if (this.onStreamDegraded && this.inboundDroppedCount === 1) {
+          try {
+            this.onStreamDegraded(1, "inbound_queue_overflow");
+          } catch {
+          }
+        }
+      }
       // ---------------------------------------------------------------------------
       // Protocol-1 RPC primitives (RFC-450 §5/§9)
       // ---------------------------------------------------------------------------
@@ -1045,6 +1483,35 @@ var init_client = __esm({
       notify(method, params) {
         return this.sendMessage(notificationEnvelope(method, params));
       }
+      _trackInboundDeliveryAck(event) {
+        if (String(event.type ?? "") === "event_batch") {
+          const events = event.events;
+          if (Array.isArray(events)) {
+            for (const sub of events) {
+              if (sub && typeof sub === "object") {
+                this._trackInboundDeliveryAck(sub);
+              }
+            }
+          }
+          return;
+        }
+        if (!inboundNeedsDeliveryAck(event)) return;
+        const loopId = extractLoopIdFromInbound(event);
+        if (!loopId) return;
+        const next = (this.deliveryRecvSeq.get(loopId) ?? 0) + 1;
+        this.deliveryRecvSeq.set(loopId, next);
+        void this._sendDeliveryAck(loopId, next);
+      }
+      async _sendDeliveryAck(loopId, seq) {
+        const acked = this.deliveryAckedSeq.get(loopId) ?? 0;
+        if (seq <= acked) return;
+        this.deliveryAckedSeq.set(loopId, seq);
+        if (!this.isConnected()) return;
+        try {
+          await this.notify("delivery_ack", { loop_id: loopId, seq });
+        } catch {
+        }
+      }
       /**
        * Starts a subscription stream. Returns the subscription `id` for later
        * correlation and `unsubscribe()`. Stream events arrive as `next` frames
@@ -1062,7 +1529,7 @@ var init_client = __esm({
           if (ev === null) break;
           const evId = ev.id;
           if (evId !== subId) {
-            this.messageBuffer.push(ev);
+            this.enqueueMessageBuffer(ev);
             continue;
           }
           const typ = ev.type;
@@ -1437,13 +1904,17 @@ __export(index_exports, {
   CLIENT_VERSION: () => CLIENT_VERSION,
   ChatEventTerminal: () => ChatEventTerminal,
   Client: () => Client,
+  CommandClient: () => CommandClient,
   ConnectionError: () => ConnectionError,
   ConnectionPool: () => ConnectionPool,
   DEFAULT_CLIENT_CAPABILITIES: () => DEFAULT_CLIENT_CAPABILITIES,
   DEFAULT_DELIVERABLE_PHASES: () => DEFAULT_DELIVERABLE_PHASES,
+  DEFAULT_POST_IDLE_DRAIN_MS: () => DEFAULT_POST_IDLE_DRAIN_MS,
   DEFAULT_THINKING_STEP_EVENTS: () => DEFAULT_THINKING_STEP_EVENTS,
   DaemonError: () => DaemonError,
+  DaemonSession: () => DaemonSession,
   DisconnectCause: () => DisconnectCause,
+  ErrIdleTimeout: () => ErrIdleTimeout,
   ErrPoolExhausted: () => ErrPoolExhausted,
   ErrQueryBusy: () => ErrQueryBusy,
   ErrQueryTimeout: () => ErrQueryTimeout,
@@ -1489,26 +1960,31 @@ __export(index_exports, {
   INTENT_HINT_OCR: () => INTENT_HINT_OCR,
   INTENT_HINT_TEXT_COMPLETION: () => INTENT_HINT_TEXT_COMPLETION,
   LOOP_ASSISTANT_OUTPUT_PHASES: () => LOOP_ASSISTANT_OUTPUT_PHASES,
-  Multiplexer: () => Multiplexer,
   PROTO_VERSION: () => PROTO_VERSION,
   PooledConn: () => PooledConn,
   QueryGate: () => QueryGate,
   REMOVED_INTENT_HINTS: () => REMOVED_INTENT_HINTS,
   ReconnectError: () => ReconnectError,
   SSEBroadcaster: () => SSEBroadcaster,
+  STREAM_END: () => STREAM_END,
   StaleLoopError: () => StaleLoopError,
+  StreamCloseFail: () => StreamCloseFail,
+  StreamCloseSoftComplete: () => StreamCloseSoftComplete,
   TimeoutError: () => TimeoutError,
+  TimeoutPolicy: () => TimeoutPolicy,
+  TurnEventStats: () => TurnEventStats,
   TurnRunner: () => TurnRunner,
   VerbosityTier: () => VerbosityTier,
   authenticate: () => authenticate,
   bootstrapLoopSession: () => bootstrapLoopSession,
   checkDaemonStatus: () => checkDaemonStatus,
   classifyEventVerbosity: () => classifyEventVerbosity,
+  compactAttachments: () => compactAttachments,
+  compactImageAttachment: () => compactImageAttachment,
   connectWithRetries: () => connectWithRetries,
+  connectedWebsocket: () => connectedWebsocket,
   connectionInitEnvelope: () => connectionInitEnvelope,
   decodeMessage: () => decodeMessage,
-  defaultBootstrapFunc: () => defaultBootstrapFunc,
-  defaultClientFactory: () => defaultClientFactory,
   defaultConfig: () => defaultConfig,
   defaultPoolConfig: () => defaultPoolConfig,
   disconnectCauseName: () => disconnectCauseName,
@@ -1517,12 +1993,18 @@ __export(index_exports, {
   extractSootheLoopID: () => extractSootheLoopID,
   extractThinkingStep: () => extractThinkingStep,
   fetchConfigSection: () => fetchConfigSection,
+  fetchLoopCards: () => fetchLoopCards,
   fetchLoopHistory: () => fetchLoopHistory,
+  fetchLoopMessages: () => fetchLoopMessages,
   fetchSkillsCatalog: () => fetchSkillsCatalog,
+  idleTimeoutForTurn: () => idleTimeoutForTurn,
+  inboundNeedsDeliveryAck: () => inboundNeedsDeliveryAck,
   inputMessageForLoop: () => inputMessageForLoop,
   isCompletionEvent: () => isCompletionEvent,
   isDaemonLive: () => isDaemonLive,
   isSubagentProgressEvent: () => isSubagentProgressEvent,
+  isTurnEndCustomData: () => isTurnEndCustomData,
+  isTurnProgressChunk: () => isTurnProgressChunk,
   isValidVerbosityLevel: () => isValidVerbosityLevel,
   loadConfigFromEnv: () => loadConfigFromEnv,
   newLoopInputMessage: () => newLoopInputMessage,
@@ -1533,6 +2015,7 @@ __export(index_exports, {
   parseNamespace: () => parseNamespace,
   pingEnvelope: () => pingEnvelope,
   pongEnvelope: () => pongEnvelope,
+  protocol1Rpc: () => protocol1Rpc,
   refreshAuthToken: () => refreshAuthToken,
   requestDaemonConfigReload: () => requestDaemonConfigReload,
   requestDaemonShutdown: () => requestDaemonShutdown,
@@ -1548,156 +2031,166 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 init_errors();
-
-// src/verbosity.ts
-var VerbosityTier = /* @__PURE__ */ ((VerbosityTier2) => {
-  VerbosityTier2[VerbosityTier2["Quiet"] = 0] = "Quiet";
-  VerbosityTier2[VerbosityTier2["Normal"] = 1] = "Normal";
-  VerbosityTier2[VerbosityTier2["Detailed"] = 2] = "Detailed";
-  VerbosityTier2[VerbosityTier2["Debug"] = 3] = "Debug";
-  VerbosityTier2[VerbosityTier2["Internal"] = 99] = "Internal";
-  return VerbosityTier2;
-})(VerbosityTier || {});
-var verbosityLevelValues = {
-  quiet: 0,
-  normal: 1,
-  debug: 3
-};
-function shouldShow(tier, verbosity) {
-  if (tier === 99 /* Internal */) {
-    return false;
-  }
-  const level = verbosityLevelValues[verbosity] ?? 1;
-  return tier <= level;
-}
-function isValidVerbosityLevel(s) {
-  return s in verbosityLevelValues;
-}
-
-// src/index.ts
+init_verbosity();
 init_config();
 init_protocol();
 init_intent_hints();
+init_events();
+init_client();
 
-// 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;
-  }
-  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;
+// src/command_client.ts
+init_client();
+init_config();
+
+// src/session.ts
+init_config();
+init_protocol();
+init_errors();
+async function bootstrapLoopSession(client, resumeLoopId, config, loopNew) {
+  const cfg = config ?? defaultConfig();
+  let loopId = (resumeLoopId ?? "").trim();
+  if (!loopId) {
+    const env = newLoopNewMessage(loopNew);
+    const newResp = await client.requestResponse(
+      env.method,
+      env.params ?? {},
+      "loop_new",
+      cfg.loopStatusTimeout
+    );
+    loopId = String(newResp.loop_id ?? "").trim();
+    if (!loopId) {
+      throw new Error("loop_new response missing loop_id");
     }
   }
-  parts.push(ns.slice(start));
-  return parts;
+  await client.subscribe(
+    "loop_events",
+    { loop_id: loopId, verbosity: cfg.verbosityLevel },
+    cfg.subscriptionTimeout
+  );
+  return loopId;
 }
-function classifyEventVerbosity(eventTypeOrNamespace) {
-  const parsed = parseNamespace(eventTypeOrNamespace);
-  if (!parsed) {
-    return classifyByEventTypeString(eventTypeOrNamespace);
-  }
-  return classifyByDomainAndComponent(parsed.domain, parsed.component, eventTypeOrNamespace);
-}
-function classifyByDomainAndComponent(domain, _component, full) {
-  switch (domain) {
-    case "cognition":
-      return 1 /* Normal */;
-    case "protocol":
-      return 2 /* Detailed */;
-    case "tool":
-      return 99 /* Internal */;
-    case "subagent":
-      return classifySubagentEvent(full);
-    case "autopilot":
-      return 1 /* Normal */;
-    case "output":
-    case "error":
-      return 0 /* Quiet */;
-    default:
-      return 1 /* Normal */;
+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")}`);
+    }
   }
+  throw new Error(`timeout after ${timeout}ms waiting for connection_ack (ready)`);
 }
-function classifySubagentEvent(full) {
-  const parsed = parseNamespace(full);
-  if (!parsed) return 1 /* Normal */;
-  switch (parsed.action) {
-    case "started":
-    case "completed":
-      return 1 /* Normal */;
-    default:
-      return 2 /* Detailed */;
+async function 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;
+      }
+    }
   }
+  throw new Error(`timeout after ${timeout}ms waiting for status with loop_id`);
 }
-function classifyByEventTypeString(eventType) {
-  if (eventType === EventFinalReport || eventType === EventGeneralFailed) {
-    return 0 /* Quiet */;
-  }
-  if (eventType === EventToolStarted) {
-    return 99 /* Internal */;
+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 1 /* Normal */;
-}
-function isCompletionEvent(eventType) {
-  return eventType.endsWith(".completed") || eventType.endsWith(".failed") || eventType === EventGeneralFailed;
+  throw new Error(`timeout after ${timeout}ms waiting for subscription confirmation`);
 }
-function isSubagentProgressEvent(eventType) {
-  const parsed = parseNamespace(eventType);
-  if (!parsed || parsed.domain !== "subagent") {
-    return false;
+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));
   }
-  return parsed.action === "started" || parsed.action === "completed";
+  throw new Error(
+    `failed to connect after ${retries} attempts: ${lastErr?.message ?? "unknown error"}`
+  );
 }
 
-// src/index.ts
-init_client();
-init_multiplexer();
+// 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();
+  }
+  async withClient(fn) {
+    const client = new Client(this.url, this.config);
+    try {
+      await connectWithRetries(client, 5, 250);
+      return await fn(client);
+    } finally {
+      client.close();
+    }
+  }
+  /** Generic one-shot RPC. */
+  async request(method, params = {}) {
+    return this.withClient(
+      (client) => client.requestResponse(method, params, void 0, this.timeoutMs)
+    );
+  }
+  async jobCreate(goal, workspace = "") {
+    const params = { goal };
+    if (workspace) params.workspace = workspace;
+    return this.request("job_create", params);
+  }
+  async jobStatus(jobId) {
+    return this.request("job_status", { job_id: jobId });
+  }
+  async jobCancel(jobId) {
+    return this.request("job_cancel", { job_id: jobId });
+  }
+  async cronAdd(text, priority = 0) {
+    const params = { text };
+    if (priority > 0) params.priority = priority;
+    return this.request("cron_add", params);
+  }
+  async cronList(status = "") {
+    const params = {};
+    if (status) params.status = status;
+    return this.request("cron_list", params);
+  }
+};
 
 // src/helpers.ts
 init_config();
@@ -1779,109 +2272,79 @@ async function refreshAuthToken(client, refreshToken, timeout) {
     timeout ?? 15e3
   );
 }
-
-// src/session.ts
-init_config();
-init_protocol();
-init_errors();
-async function bootstrapLoopSession(client, resumeLoopId, config, loopNew) {
-  const cfg = config ?? defaultConfig();
-  let loopId = (resumeLoopId ?? "").trim();
-  if (!loopId) {
-    const env = newLoopNewMessage(loopNew);
-    const newResp = await client.requestResponse(
-      env.method,
-      env.params ?? {},
-      "loop_new",
-      cfg.loopStatusTimeout
-    );
-    loopId = String(newResp.loop_id ?? "").trim();
-    if (!loopId) {
-      throw new Error("loop_new response missing loop_id");
-    }
-  }
-  await client.subscribe(
-    "loop_events",
-    { loop_id: loopId, verbosity: cfg.verbosityLevel },
-    cfg.subscriptionTimeout
-  );
-  return loopId;
+async function fetchLoopCards(client, loopID, timeout) {
+  return client.fetchLoopCards(loopID, timeout);
 }
-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")}`);
-    }
-  }
-  throw new Error(`timeout after ${timeout}ms waiting for connection_ack (ready)`);
+async function fetchLoopMessages(client, loopID, opts) {
+  return client.getLoopMessages(
+    loopID,
+    opts?.limit,
+    opts?.offset,
+    opts?.includeEvents,
+    opts?.timeout
+  );
 }
-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");
+async function connectedWebsocket(wsUrl, fn, timeoutMs = 3e4) {
+  const { Client: Client2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const client = new Client2(wsUrl, defaultConfig());
+  const deadline = Date.now() + timeoutMs;
+  try {
+    await client.connect();
+    while (!client.isConnected() && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 25));
     }
-    if (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/index.ts
+init_stream_terminal();
+
 // src/appkit/broadcaster.ts
 var SUBSCRIBER_QUEUE_CAP = 100;
 var SSEBroadcaster = class {
@@ -1985,6 +2448,7 @@ var SSEBroadcaster = class {
 
 // src/appkit/classifier.ts
 init_errors();
+init_events();
 
 // src/appkit/thinking_step.ts
 var MAX_THINKING_STEP_RUNES = 280;
@@ -2104,6 +2568,7 @@ var EventClassifier = class {
   deliverablePhases;
   minDeliverableRunes;
   thinkingStepEvents;
+  treatStatusIdleAsComplete;
   constructor(cfg) {
     if (!cfg.deliverablePhases) {
       throw new Error("appkit: ClassifierConfig.deliverablePhases must not be nil");
@@ -2111,6 +2576,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
@@ -2127,6 +2593,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);
@@ -2162,16 +2635,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") {
+      return { terminal: 0 /* Continue */ };
     }
-    if (typ === "response" || typ === "complete" || typ === "receipt_response" || typ === "connection_ack" || typ === "status") {
+    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") {
@@ -2191,10 +2670,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(
@@ -2205,6 +2688,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);
     }
@@ -2622,10 +3110,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();
@@ -2728,6 +3221,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
 init_intent_hints();
 var ErrQueryTimeout = class extends Error {
@@ -2736,6 +3311,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;
@@ -2758,6 +3346,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;
@@ -2768,39 +3363,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 {
@@ -2828,13 +3413,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) {
@@ -2853,6 +3444,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 });
@@ -2866,34 +3474,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);
@@ -2913,25 +3558,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;
@@ -2974,18 +3633,476 @@ var TurnRunner = class {
     this.broadcaster?.broadcast(sessionID, { type: "query_error", data: err.message });
   }
 };
+
+// src/appkit/daemon_session.ts
+init_client();
+init_config();
+init_errors();
+init_stream_terminal();
+
+// src/appkit/chunk_filter.ts
+var MSG_PAIR_LEN = 2;
+function updatesChunkIsNoop(data) {
+  if (!data || typeof data !== "object") return true;
+  return !("__interrupt__" in data);
+}
+function wireBody(msg) {
+  for (const key of ["kwargs", "data"]) {
+    const nested = msg[key];
+    if (nested && typeof nested === "object") return nested;
+  }
+  return msg;
+}
+function dictHasToolInvocation(msg) {
+  const body = wireBody(msg);
+  if (body.tool_calls || body.tool_call_chunks) return true;
+  for (const key of ["content", "content_blocks"]) {
+    const raw = body[key];
+    if (Array.isArray(raw)) {
+      for (const item of raw) {
+        if (item && typeof item === "object" && ["tool_call", "tool_call_chunk", "tool_use"].includes(
+          String(item.type ?? "")
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function plainText(msg) {
+  const body = wireBody(msg);
+  const content = body.content ?? msg.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (typeof block === "string") parts.push(block);
+      else if (block && typeof block === "object") {
+        const text = block.text;
+        if (typeof text === "string") parts.push(text);
+      }
+    }
+    return parts.join("");
+  }
+  return "";
+}
+function messageChunkIsNonActionable(data) {
+  if (!Array.isArray(data) || data.length !== MSG_PAIR_LEN) return false;
+  const msg = data[0];
+  if (msg === null || msg === void 0) return true;
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  const body = wireBody(m);
+  const raw = String(body.type ?? m.type ?? "");
+  if (raw === "tool" || raw === "ToolMessage" || raw.endsWith("ToolMessage")) return false;
+  if (dictHasToolInvocation(m)) return false;
+  if (body.phase || m.phase) return false;
+  return !plainText(m).trim();
+}
+function shouldDropStreamChunkEarly(_namespace, mode, data) {
+  if (mode === "updates") return updatesChunkIsNoop(data);
+  if (mode === "messages") return messageChunkIsNonActionable(data);
+  return false;
+}
+
+// src/appkit/events.ts
+function unwrapNext(event) {
+  if (!event || typeof event !== "object") return event;
+  if (event.type !== "next") return event;
+  const payload = event.payload;
+  if (!payload || typeof payload !== "object") return event;
+  const data = payload.data;
+  return data && typeof data === "object" ? data : event;
+}
+
+// src/appkit/observability.ts
+var TurnEventStats = class {
+  total = 0;
+  messages = 0;
+  updates = 0;
+  custom = 0;
+  skipped = 0;
+  filteredEarly = 0;
+  toolCalls = 0;
+  toolResults = 0;
+  textChunks = 0;
+  heartbeatsDropped = 0;
+  postIdleDrained = 0;
+  inboundDropped = 0;
+};
+
+// src/appkit/daemon_session.ts
+var DEFAULT_POST_IDLE_DRAIN_MS = 500;
+var DaemonSession = class {
+  wsUrl;
+  workspace;
+  streamDelivery;
+  client;
+  rpcClient;
+  loopId = null;
+  readBusy = false;
+  rpcBusy = false;
+  rpcConnected = false;
+  streaming = false;
+  postIdleDrainDeadlineMs;
+  closed = false;
+  earlyDropFn;
+  statsFactory;
+  config;
+  turnEventStats;
+  lastTurnEndState = null;
+  lastTurnCancellationSeen = false;
+  lastTurnErrorMessage = null;
+  constructor(wsUrl, opts = {}) {
+    this.wsUrl = wsUrl;
+    this.workspace = opts.workspace;
+    this.streamDelivery = opts.streamDelivery ?? "adaptive";
+    this.config = opts.config ?? defaultConfig();
+    this.client = new Client(wsUrl, this.config);
+    this.rpcClient = new Client(wsUrl, this.config);
+    this.postIdleDrainDeadlineMs = opts.postIdleDrainDeadlineMs && opts.postIdleDrainDeadlineMs > 0 ? opts.postIdleDrainDeadlineMs : DEFAULT_POST_IDLE_DRAIN_MS;
+    this.earlyDropFn = opts.earlyDropFn ?? shouldDropStreamChunkEarly;
+    this.statsFactory = opts.statsFactory ?? (() => new TurnEventStats());
+    this.turnEventStats = this.statsFactory();
+  }
+  get streamClient() {
+    return this.client;
+  }
+  get rpcSideClient() {
+    return this.rpcClient;
+  }
+  get activeLoopId() {
+    return this.loopId;
+  }
+  resolveStreamDeliveryMode() {
+    const delivery = this.streamDelivery;
+    if (typeof delivery === "function") return String(delivery() || "adaptive");
+    return String(delivery || "adaptive");
+  }
+  get streamDeliveryMode() {
+    return this.resolveStreamDeliveryMode();
+  }
+  shouldDrop(namespace, mode, data) {
+    return Boolean(this.earlyDropFn(namespace, mode, data));
+  }
+  async connect(resumeLoopId) {
+    await connectWithRetries(this.client);
+    return this.bootstrapLoop(resumeLoopId ?? null);
+  }
+  async bootstrapLoop(resumeLoopId) {
+    const loopNew = this.workspace ? { client_workspace: this.workspace, workspace: this.workspace } : void 0;
+    const loopId = await bootstrapLoopSession(this.client, resumeLoopId, this.config, loopNew);
+    this.loopId = loopId;
+    return { type: "status", loop_id: loopId, state: "ready" };
+  }
+  async newLoop() {
+    return this.bootstrapLoop(null);
+  }
+  async switchLoop(loopId) {
+    return this.bootstrapLoop(loopId);
+  }
+  async ensureConnected() {
+    if (this.client.isConnected() && !this.client.isDisconnected()) return;
+    let resumeLoopId = this.loopId;
+    if (this.rpcConnected) {
+      this.rpcClient.close();
+      this.rpcConnected = false;
+    }
+    try {
+      await this.client.reconnect();
+    } catch {
+      this.client.close();
+      await connectWithRetries(this.client);
+    }
+    if (resumeLoopId) {
+      try {
+        await this.client.reattachAndProbe(resumeLoopId);
+        this.loopId = resumeLoopId;
+        return;
+      } catch (err) {
+        if (!(err instanceof StaleLoopError)) throw err;
+        resumeLoopId = null;
+      }
+    }
+    await this.bootstrapLoop(resumeLoopId);
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.client.close();
+    this.rpcClient.close();
+    this.rpcConnected = false;
+  }
+  async detach() {
+    if (!this.client.isConnected()) return;
+    try {
+      await this.client.notify("disconnect", {});
+    } catch {
+    }
+  }
+  async sendTurn(text, options) {
+    if (!this.loopId) throw new Error("No active loop session");
+    await this.client.sendInput(text, {
+      loopID: this.loopId,
+      autonomous: options?.autonomous,
+      maxIterations: options?.maxIterations,
+      subagent: options?.preferredSubagent,
+      model: options?.model,
+      modelParams: options?.modelParams,
+      attachments: options?.attachments,
+      clarificationMode: options?.clarificationMode,
+      clarificationAnswer: options?.clarificationAnswer,
+      intentHint: options?.intentHint
+    });
+  }
+  async cancelActiveTurn() {
+    await this.client.notify("slash_command", { cmd: "/cancel" });
+  }
+  async *drainStreamEventsAfterIdle(expectedLoopId) {
+    const deadline = Date.now() + this.postIdleDrainDeadlineMs;
+    let exp = expectedLoopId;
+    while (Date.now() < deadline) {
+      const event = await this.client.readEventWithTimeout(250);
+      if (!event) break;
+      let frame = event;
+      let eventType = String(frame.type ?? "");
+      if (eventType === "next") {
+        frame = unwrapNext(frame) ?? frame;
+        eventType = String(frame.type ?? "");
+      }
+      const eventLoopId = frame.loop_id;
+      if (exp && typeof eventLoopId === "string" && eventLoopId && eventLoopId !== exp) {
+        continue;
+      }
+      if (eventType === "error") {
+        const errObj = frame.error ?? {};
+        throw new Error(String(errObj.message || frame.message || "daemon error"));
+      }
+      if (eventType === "status") {
+        const loopEv = frame.loop_id;
+        if (typeof loopEv === "string" && loopEv) {
+          this.loopId = loopEv;
+          exp = loopEv;
+        }
+        continue;
+      }
+      if (eventType !== "event") continue;
+      const data = frame.data;
+      const namespace = Array.isArray(frame.namespace) ? frame.namespace : [];
+      const mode = String(frame.mode ?? "");
+      if (this.shouldDrop(namespace, mode, data)) {
+        this.turnEventStats.filteredEarly += 1;
+        continue;
+      }
+      this.turnEventStats.postIdleDrained += 1;
+      yield [namespace, mode, data];
+    }
+  }
+  async withRpcLock(fn) {
+    while (this.rpcBusy) {
+      await new Promise((r) => setTimeout(r, 5));
+    }
+    this.rpcBusy = true;
+    try {
+      return await fn();
+    } finally {
+      this.rpcBusy = false;
+    }
+  }
+  async ensureRpcConnected() {
+    if (this.rpcConnected && this.rpcClient.isConnected()) return;
+    await connectWithRetries(this.rpcClient);
+    this.rpcConnected = true;
+  }
+  async listLoops(_limit = 20) {
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      return this.rpcClient.listLoops(15e3);
+    });
+  }
+  async fetchLoopCards(loopId) {
+    const lid = String(loopId || "").trim();
+    if (!lid) return { cards: [], seq: 0, contextTokens: 0, success: false };
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      try {
+        const resp = await this.rpcClient.fetchLoopCards(lid, 3e4);
+        const rawCards = resp.cards;
+        return {
+          cards: Array.isArray(rawCards) ? rawCards : [],
+          seq: Number(resp.seq ?? 0),
+          contextTokens: typeof resp.context_tokens === "number" && resp.context_tokens >= 0 ? resp.context_tokens : 0,
+          success: true
+        };
+      } catch {
+        return { cards: [], seq: 0, contextTokens: 0, success: false };
+      }
+    });
+  }
+  async fetchLoopHistory(loopId) {
+    const lid = String(loopId || "").trim();
+    if (!lid) {
+      return { goals: [], liveCards: [], liveGoalIndex: null, contextTokens: 0, success: false };
+    }
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      try {
+        const resp = await this.rpcClient.fetchLoopHistory(lid, 3e4);
+        const liveGoalIndex = resp.live_goal_index;
+        return {
+          goals: Array.isArray(resp.goals) ? resp.goals : [],
+          liveCards: Array.isArray(resp.live_cards) ? resp.live_cards : [],
+          liveGoalIndex: typeof liveGoalIndex === "number" ? liveGoalIndex : null,
+          contextTokens: typeof resp.context_tokens === "number" && resp.context_tokens >= 0 ? resp.context_tokens : 0,
+          success: Boolean(resp.success ?? true)
+        };
+      } catch {
+        return {
+          goals: [],
+          liveCards: [],
+          liveGoalIndex: null,
+          contextTokens: 0,
+          success: false
+        };
+      }
+    });
+  }
+  async fetchConversationLog(loopId, opts = {}) {
+    const lid = String(loopId || "").trim();
+    if (!lid) return [];
+    return this.withRpcLock(async () => {
+      await this.ensureRpcConnected();
+      const resp = await this.rpcClient.getLoopMessages(
+        lid,
+        opts.limit ?? 100,
+        opts.offset ?? 0,
+        opts.includeEvents ?? false
+      );
+      const raw = resp.messages;
+      if (!Array.isArray(raw)) return [];
+      return raw.filter((m) => !!m && typeof m === "object");
+    });
+  }
+  async *iterTurnChunks(opts = {}) {
+    this.turnEventStats = this.statsFactory();
+    this.lastTurnEndState = null;
+    this.lastTurnCancellationSeen = false;
+    this.lastTurnErrorMessage = null;
+    let queryStarted = false;
+    let expectedLoopId = this.loopId;
+    let streamPayloadSeen = false;
+    let turnProgressSeen = false;
+    this.streaming = true;
+    const absoluteDeadline = opts.maxWaitMs !== void 0 && opts.maxWaitMs > 0 ? Date.now() + opts.maxWaitMs : null;
+    this.client.peelStalePendingControlEvents();
+    while (this.readBusy) {
+      await new Promise((r) => setTimeout(r, 5));
+    }
+    this.readBusy = true;
+    try {
+      while (true) {
+        if (absoluteDeadline !== null && Date.now() >= absoluteDeadline) {
+          throw new Error(
+            `Turn timed out after ${opts.maxWaitMs}ms (loop=${expectedLoopId ?? "?"})`
+          );
+        }
+        const event = await this.client.readEvent();
+        if (!event) {
+          if (queryStarted && !this.client.isConnectionAlive()) {
+            this.lastTurnEndState = "connection_lost";
+            throw new Error("Daemon connection lost");
+          }
+          break;
+        }
+        let frame = event;
+        let eventType = String(frame.type ?? "");
+        if (eventType === "next") {
+          frame = unwrapNext(frame) ?? frame;
+          eventType = String(frame.type ?? "");
+        }
+        const eventLoopId = frame.loop_id;
+        if (expectedLoopId && typeof eventLoopId === "string" && eventLoopId && eventLoopId !== expectedLoopId) {
+          continue;
+        }
+        if (eventType === "error") {
+          const errObj = frame.error ?? {};
+          throw new Error(String(errObj.message || frame.message || "daemon error"));
+        }
+        if (eventType === "status") {
+          const loopEv = frame.loop_id;
+          if (typeof loopEv === "string" && loopEv) {
+            this.loopId = loopEv;
+            expectedLoopId = loopEv;
+          }
+          const state = String(frame.state ?? "");
+          if (state === "running") {
+            queryStarted = true;
+          } else if (queryStarted && state === "stopped") {
+            this.lastTurnEndState = state;
+            yield* this.drainStreamEventsAfterIdle(expectedLoopId);
+            break;
+          } else if (queryStarted && state === "idle") {
+            if (!streamPayloadSeen && !this.lastTurnCancellationSeen) continue;
+            this.lastTurnEndState = state;
+            yield* this.drainStreamEventsAfterIdle(expectedLoopId);
+            break;
+          }
+          continue;
+        }
+        if (eventType === "command_response") {
+          const content = String(frame.content ?? "");
+          if (content.includes("Cancellation requested")) {
+            this.lastTurnCancellationSeen = true;
+          }
+          continue;
+        }
+        if (eventType !== "event") continue;
+        const data = frame.data;
+        const namespace = Array.isArray(frame.namespace) ? frame.namespace : [];
+        const mode = String(frame.mode ?? "");
+        if (this.shouldDrop(namespace, mode, data)) {
+          this.turnEventStats.filteredEarly += 1;
+          continue;
+        }
+        if (mode === "custom" && isTurnEndCustomData(data)) {
+          if (!queryStarted || !turnProgressSeen) continue;
+        }
+        streamPayloadSeen = true;
+        if (isTurnProgressChunk(mode, data)) turnProgressSeen = true;
+        yield [namespace, mode, data];
+        if (mode === "custom" && isTurnEndCustomData(data)) {
+          const customType = String(data.type ?? "").trim();
+          this.lastTurnEndState = customType === STREAM_END ? "stream_end" : "completed";
+          yield* this.drainStreamEventsAfterIdle(expectedLoopId);
+          break;
+        }
+      }
+    } catch (exc) {
+      this.lastTurnErrorMessage = String(exc);
+      throw exc;
+    } finally {
+      this.streaming = false;
+      this.readBusy = false;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CLIENT_VERSION,
   ChatEventTerminal,
   Client,
+  CommandClient,
   ConnectionError,
   ConnectionPool,
   DEFAULT_CLIENT_CAPABILITIES,
   DEFAULT_DELIVERABLE_PHASES,
+  DEFAULT_POST_IDLE_DRAIN_MS,
   DEFAULT_THINKING_STEP_EVENTS,
   DaemonError,
+  DaemonSession,
   DisconnectCause,
+  ErrIdleTimeout,
   ErrPoolExhausted,
   ErrQueryBusy,
   ErrQueryTimeout,
@@ -3031,26 +4148,31 @@ var TurnRunner = class {
   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,
@@ -3059,12 +4181,18 @@ var TurnRunner = class {
   extractSootheLoopID,
   extractThinkingStep,
   fetchConfigSection,
+  fetchLoopCards,
   fetchLoopHistory,
+  fetchLoopMessages,
   fetchSkillsCatalog,
+  idleTimeoutForTurn,
+  inboundNeedsDeliveryAck,
   inputMessageForLoop,
   isCompletionEvent,
   isDaemonLive,
   isSubagentProgressEvent,
+  isTurnEndCustomData,
+  isTurnProgressChunk,
   isValidVerbosityLevel,
   loadConfigFromEnv,
   newLoopInputMessage,
@@ -3075,6 +4203,7 @@ var TurnRunner = class {
   parseNamespace,
   pingEnvelope,
   pongEnvelope,
+  protocol1Rpc,
   refreshAuthToken,
   requestDaemonConfigReload,
   requestDaemonShutdown,