@mirasoth/soothe-client 0.2.1 → 0.4.1

package/dist/index.cjs

@@ -51,7 +51,7 @@ var init_errors = __esm({
       }
     };
     DaemonError = class extends Error {
-      /** Numeric error code from the RFC-450 §7.3 registry. */
+      /** Numeric error code from the daemon error registry. */
       code;
       /** The daemon's error message text. */
       daemonMessage;
@@ -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.1";
   }
 });
 
@@ -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,14 +883,19 @@ 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)
+      // Protocol-1 handshake state
       handshakeComplete = false;
       negotiatedCapabilities = /* @__PURE__ */ new Set();
       protocolVersion = null;
@@ -547,14 +903,16 @@ var init_client = __esm({
       heartbeatIntervalMs = 0;
       heartbeatTimer = null;
       lastPongMonotonic = 0;
-      // Mid-session drop signal (RFC-450 §8.3). The 'disconnected' event is
+      // Mid-session drop signal. The 'disconnected' event is
       // emitted exactly once when the connection drops, carrying a DisconnectCause
       // that distinguishes clean (peer `disconnect`) from unclean (read/write
       // error or missed pong). `disconnFired` guards the once-only delivery.
       disconnFired = false;
-      // Pending-request/subscription multiplexer (RFC-629 constraint #1). Routes
+      // Pending-request/subscription multiplexer. 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);
             }
@@ -665,7 +1025,7 @@ var init_client = __esm({
         return this.ws !== null && this.ws.readyState === import_ws.default.OPEN && this.handshakeComplete;
       }
       // ---------------------------------------------------------------------------
-      // Mid-session drop signal + reconnect/reattach (RFC-450 §8.3, RFC-629 L0)
+      // Mid-session drop signal + reconnect/reattach
       // ---------------------------------------------------------------------------
       /**
        * Returns whether the connection has dropped (the `'disconnected'` event has
@@ -700,8 +1060,8 @@ var init_client = __esm({
         }
       }
       /**
-       * Re-dials the daemon and re-handshakes after a connection drop (RFC-450
-       * §8.3). Does not re-establish loop subscriptions; follow with
+       * Re-dials the daemon and re-handshakes after a connection drop.
+       * Does not re-establish loop subscriptions; follow with
        * `reattachAndProbe()` to resume a loop session. The caller should invoke
        * this after the `'disconnected'` event fires. Reuses the same Client,
        * resetting the drop signal and multiplexer.
@@ -735,7 +1095,7 @@ var init_client = __esm({
        * Returns a `StaleLoopError` when the probe fails; callers should fall back
        * to a fresh `loop_new` bootstrap.
        *
-       * Per RFC-629: connection-level readiness is the handshake's readiness_state
+       * Note: connection-level readiness is the handshake's readiness_state
        * (+ daemon_status); loop_get is a loop-scoped probe only, not a readiness
        * probe.
        */
@@ -776,7 +1136,7 @@ var init_client = __esm({
         }
       }
       // ---------------------------------------------------------------------------
-      // Protocol-1 handshake (RFC-450 §8.2)
+      // Protocol-1 handshake
       // ---------------------------------------------------------------------------
       /** Send connection_init and wait for connection_ack with readiness "ready". */
       async _performHandshake() {
@@ -825,7 +1185,7 @@ var init_client = __esm({
         throw new Error(`timeout after ${this.config.daemonReadyTimeout}ms waiting for connection_ack`);
       }
       // ---------------------------------------------------------------------------
-      // Heartbeat (RFC-450 §8.3)
+      // Heartbeat
       // ---------------------------------------------------------------------------
       _startHeartbeat() {
         if (!this.negotiatedCapabilities.has("heartbeat")) return;
@@ -941,8 +1301,86 @@ 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)
+      // Protocol-1 RPC primitives
       // ---------------------------------------------------------------------------
       /**
        * Reads the next frame directly from the live socket (via a resolver),
@@ -968,16 +1406,16 @@ var init_client = __esm({
         });
       }
       /**
-       * Sends a `request` envelope and waits for the matching `response` (or
-       * `error`) correlated by `id` (RFC-450 §5/§9). Returns the `result` object.
-       *
-       * Multiplexer-aware (RFC-629 constraint #1): registers a pending RPC wait
-       * keyed by the request id so that, even when a `receiveMessages()` reader
-       * is concurrently active, the matching `response`/`error` is routed to
-       * this caller instead of being discarded or buffered behind a stream.
-       * Non-matching frames are routed to their own waiters by the multiplexer
-       * or flow on to the resolver queue for stream readers.
-       */
+        * Sends a `request` envelope and waits for the matching `response` (or
+      * `error`) correlated by `id`. Returns the `result` object.
+        *
+      * Multiplexer-aware: registers a pending RPC wait
+        * keyed by the request id so that, even when a `receiveMessages()` reader
+        * is concurrently active, the matching `response`/`error` is routed to
+        * this caller instead of being discarded or buffered behind a stream.
+        * Non-matching frames are routed to their own waiters by the multiplexer
+        * or flow on to the resolver queue for stream readers.
+        */
       async requestResponse(method, params, responseType, timeout = 15e3) {
         const req = requestEnvelope(method, params);
         const rid = req.id;
@@ -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;
@@ -1099,7 +1566,7 @@ var init_client = __esm({
         return ev;
       }
       // ---------------------------------------------------------------------------
-      // High-level API methods (Loop-first, RFC-503)
+      // High-level API methods
       // ---------------------------------------------------------------------------
       /** Sends user input to the daemon (loop_input notification; requires loopID). */
       sendInput(text, options) {
@@ -1138,7 +1605,7 @@ var init_client = __esm({
         return this.notify("slash_command", { cmd });
       }
       // ---------------------------------------------------------------------------
-      // Loop lifecycle methods (RFC-503)
+      // Loop lifecycle methods
       // ---------------------------------------------------------------------------
       /** Requests the daemon to create a new StrangeLoop and waits for the response. */
       sendLoopNew(opts) {
@@ -1233,7 +1700,7 @@ var init_client = __esm({
       sendLoopCardsFetch(loopID) {
         return this.sendMessage(requestEnvelope("loop_cards_fetch", { loop_id: loopID }));
       }
-      /** Requests the full loop history (RFC-631). */
+      /** Requests the full loop history. */
       sendLoopHistoryFetch(loopID) {
         return this.sendMessage(requestEnvelope("loop_history_fetch", { loop_id: loopID }));
       }
@@ -1328,7 +1795,7 @@ var init_client = __esm({
         );
       }
       // ---------------------------------------------------------------------------
-      // RFC-228 Job IPC methods
+      // Job IPC methods
       // ---------------------------------------------------------------------------
       /** Creates an autopilot job and waits for the response. */
       createJob(goal, verificationRules, workspace, timeout) {
@@ -1363,6 +1830,98 @@ var init_client = __esm({
         if (goalId) params.goal_id = goalId;
         return this.requestResponse("job_guidance", params, "job_guidance", timeout ?? 3e4);
       }
+      // ---------------------------------------------------------------------------
+      // Autopilot goal RPCs (protocol-1 request methods)
+      // ---------------------------------------------------------------------------
+      /** Return autopilot scheduler status (running / dreaming / pool). */
+      autopilotStatus(timeout) {
+        return this.requestResponse("autopilot_status", {}, "autopilot_status", timeout ?? 15e3);
+      }
+      /** Submit a new autopilot goal (returns goal_id). */
+      autopilotSubmit(description, opts) {
+        const params = {
+          description,
+          priority: opts?.priority ?? 50
+        };
+        if (opts?.workspace) params.workspace = opts.workspace;
+        return this.requestResponse(
+          "autopilot_submit",
+          params,
+          "autopilot_submit",
+          opts?.timeout ?? 15e3
+        );
+      }
+      /** List all goals (including non-root children). */
+      autopilotListGoals(timeout) {
+        return this.requestResponse(
+          "autopilot_list_goals",
+          {},
+          "autopilot_list_goals",
+          timeout ?? 15e3
+        );
+      }
+      /** Fetch one goal by id. */
+      autopilotGetGoal(goalId, timeout) {
+        return this.requestResponse(
+          "autopilot_get_goal",
+          { goal_id: goalId },
+          "autopilot_get_goal",
+          timeout ?? 15e3
+        );
+      }
+      /** Cancel a goal and its non-terminal descendants. */
+      autopilotCancelGoal(goalId, timeout) {
+        return this.requestResponse(
+          "autopilot_cancel_goal",
+          { goal_id: goalId },
+          "autopilot_cancel_goal",
+          timeout ?? 15e3
+        );
+      }
+      /** Cancel every open (non-terminal) goal. */
+      autopilotCancelAll(timeout) {
+        return this.requestResponse(
+          "autopilot_cancel_all",
+          {},
+          "autopilot_cancel_all",
+          timeout ?? 15e3
+        );
+      }
+      /** Exit dreaming mode and resume scheduling. */
+      autopilotWake(timeout) {
+        return this.requestResponse("autopilot_wake", {}, "autopilot_wake", timeout ?? 15e3);
+      }
+      /** Force dreaming mode. */
+      autopilotDream(timeout) {
+        return this.requestResponse("autopilot_dream", {}, "autopilot_dream", timeout ?? 15e3);
+      }
+      /** Resume a suspended or blocked goal. */
+      autopilotResume(goalId, timeout) {
+        return this.requestResponse(
+          "autopilot_resume",
+          { goal_id: goalId },
+          "autopilot_resume",
+          timeout ?? 15e3
+        );
+      }
+      /** List root goals only (jobs). Prefer createJob / getJobStatus for job control. */
+      autopilotListJobs(timeout) {
+        return this.requestResponse(
+          "autopilot_list_jobs",
+          {},
+          "autopilot_list_jobs",
+          timeout ?? 15e3
+        );
+      }
+      /** Get a root job with DAG snapshot. Prefer getJobStatus / getJobDag. */
+      autopilotGetJob(jobId, timeout) {
+        return this.requestResponse(
+          "autopilot_get_job",
+          { job_id: jobId },
+          "autopilot_get_job",
+          timeout ?? 15e3
+        );
+      }
       /** Subscribes to autopilot worker events. */
       autopilotSubscribe(timeout) {
         return this.subscribe("autopilot_events", {}, timeout ?? 15e3);
@@ -1373,7 +1932,7 @@ var init_client = __esm({
         return this._requestResponseForEnvelope(req, "autopilot_unsubscribe", timeout ?? 15e3);
       }
       // ---------------------------------------------------------------------------
-      // RFC-229 Cron IPC methods
+      // Cron IPC methods
       // ---------------------------------------------------------------------------
       /** Creates a scheduled job from natural language. */
       cronAdd(text, priority, timeout) {
@@ -1437,13 +1996,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 +2052,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 +2085,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 +2107,7 @@ __export(index_exports, {
   parseNamespace: () => parseNamespace,
   pingEnvelope: () => pingEnvelope,
   pongEnvelope: () => pongEnvelope,
+  protocol1Rpc: () => protocol1Rpc,
   refreshAuthToken: () => refreshAuthToken,
   requestDaemonConfigReload: () => requestDaemonConfigReload,
   requestDaemonShutdown: () => requestDaemonShutdown,
@@ -1548,237 +2123,16 @@ __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;
-    }
-  }
-  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";
-}
-
-// src/index.ts
+// src/command_client.ts
 init_client();
-init_multiplexer();
-
-// src/helpers.ts
 init_config();
-async function checkDaemonStatus(client, timeout) {
-  return client.requestResponse("daemon_status", {}, "daemon_status", timeout ?? 5e3);
-}
-async function isDaemonLive(wsURL, timeout) {
-  const { Client: Client2 } = await Promise.resolve().then(() => (init_client(), client_exports));
-  const t = timeout ?? 5e3;
-  const client = new Client2(wsURL, defaultConfig());
-  try {
-    await client.connect();
-  } catch {
-    return false;
-  }
-  try {
-    await checkDaemonStatus(client, t);
-    return true;
-  } catch {
-    return false;
-  } finally {
-    client.close();
-  }
-}
-async function requestDaemonShutdown(client, timeout) {
-  const resp = await client.requestResponse(
-    "daemon_shutdown",
-    {},
-    "daemon_shutdown",
-    timeout ?? 1e4
-  );
-  if (resp.status !== "acknowledged") {
-    throw new Error(`shutdown not acknowledged: ${JSON.stringify(resp)}`);
-  }
-}
-async function fetchSkillsCatalog(client, timeout) {
-  const resp = await client.requestResponse("skills_list", {}, "skills_list", timeout ?? 15e3);
-  const skillsRaw = resp.skills;
-  if (!skillsRaw || !Array.isArray(skillsRaw)) return [];
-  return skillsRaw.filter((s) => typeof s === "object" && s !== null);
-}
-async function fetchConfigSection(client, section, timeout) {
-  const resp = await client.requestResponse(
-    "config_get",
-    { section },
-    "config_get",
-    timeout ?? 5e3
-  );
-  const sec = resp[section];
-  if (sec && typeof sec === "object") {
-    return sec;
-  }
-  return resp;
-}
-async function requestDaemonConfigReload(client, timeout) {
-  return client.requestResponse("config_reload", {}, "config_reload", timeout ?? 15e3);
-}
-async function fetchLoopHistory(client, loopID, timeout) {
-  return client.requestResponse(
-    "loop_history_fetch",
-    { loop_id: loopID },
-    "loop_history_fetch",
-    timeout ?? 15e3
-  );
-}
-async function authenticate(client, accessKey, secretKey, timeout) {
-  return client.requestResponse(
-    "auth",
-    { access_key: accessKey, secret_key: secretKey },
-    "auth",
-    timeout ?? 15e3
-  );
-}
-async function refreshAuthToken(client, refreshToken, timeout) {
-  return client.requestResponse(
-    "auth_refresh",
-    { refresh_token: refreshToken },
-    "auth_refresh",
-    timeout ?? 15e3
-  );
-}
 
 // src/session.ts
 init_config();
@@ -1882,6 +2236,256 @@ async function connectWithRetries(client, maxRetries, retryDelay) {
   );
 }
 
+// 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 });
+  }
+  /** Return autopilot scheduler status (running / dreaming / pool). */
+  async autopilotStatus() {
+    return this.request("autopilot_status");
+  }
+  /** Submit a new autopilot goal (returns goal_id). */
+  async autopilotSubmit(description, opts) {
+    const params = {
+      description,
+      priority: opts?.priority ?? 50
+    };
+    if (opts?.workspace) params.workspace = opts.workspace;
+    return this.request("autopilot_submit", params);
+  }
+  /** List all goals (including non-root children). */
+  async autopilotListGoals() {
+    return this.request("autopilot_list_goals");
+  }
+  /** Fetch one goal by id. */
+  async autopilotGetGoal(goalId) {
+    return this.request("autopilot_get_goal", { goal_id: goalId });
+  }
+  /** Cancel a goal and its non-terminal descendants. */
+  async autopilotCancelGoal(goalId) {
+    return this.request("autopilot_cancel_goal", { goal_id: goalId });
+  }
+  /** Cancel every open (non-terminal) goal. */
+  async autopilotCancelAll() {
+    return this.request("autopilot_cancel_all");
+  }
+  /** Exit dreaming mode and resume scheduling. */
+  async autopilotWake() {
+    return this.request("autopilot_wake");
+  }
+  /** Force dreaming mode. */
+  async autopilotDream() {
+    return this.request("autopilot_dream");
+  }
+  /** Resume a suspended or blocked goal. */
+  async autopilotResume(goalId) {
+    return this.request("autopilot_resume", { goal_id: goalId });
+  }
+  /** List root goals only (jobs). Prefer job* for job control. */
+  async autopilotListJobs() {
+    return this.request("autopilot_list_jobs");
+  }
+  /** Get a root job with DAG snapshot. Prefer jobStatus / getJobDag. */
+  async autopilotGetJob(jobId) {
+    return this.request("autopilot_get_job", { job_id: jobId });
+  }
+  async cronAdd(text, priority = 0) {
+    const params = { text };
+    if (priority > 0) params.priority = priority;
+    return this.request("cron_add", params);
+  }
+  async cronList(status = "") {
+    const params = {};
+    if (status) params.status = status;
+    return this.request("cron_list", params);
+  }
+};
+
+// src/helpers.ts
+init_config();
+async function checkDaemonStatus(client, timeout) {
+  return client.requestResponse("daemon_status", {}, "daemon_status", timeout ?? 5e3);
+}
+async function isDaemonLive(wsURL, timeout) {
+  const { Client: Client2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const t = timeout ?? 5e3;
+  const client = new Client2(wsURL, defaultConfig());
+  try {
+    await client.connect();
+  } catch {
+    return false;
+  }
+  try {
+    await checkDaemonStatus(client, t);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    client.close();
+  }
+}
+async function requestDaemonShutdown(client, timeout) {
+  const resp = await client.requestResponse(
+    "daemon_shutdown",
+    {},
+    "daemon_shutdown",
+    timeout ?? 1e4
+  );
+  if (resp.status !== "acknowledged") {
+    throw new Error(`shutdown not acknowledged: ${JSON.stringify(resp)}`);
+  }
+}
+async function fetchSkillsCatalog(client, timeout) {
+  const resp = await client.requestResponse("skills_list", {}, "skills_list", timeout ?? 15e3);
+  const skillsRaw = resp.skills;
+  if (!skillsRaw || !Array.isArray(skillsRaw)) return [];
+  return skillsRaw.filter((s) => typeof s === "object" && s !== null);
+}
+async function fetchConfigSection(client, section, timeout) {
+  const resp = await client.requestResponse(
+    "config_get",
+    { section },
+    "config_get",
+    timeout ?? 5e3
+  );
+  const sec = resp[section];
+  if (sec && typeof sec === "object") {
+    return sec;
+  }
+  return resp;
+}
+async function requestDaemonConfigReload(client, timeout) {
+  return client.requestResponse("config_reload", {}, "config_reload", timeout ?? 15e3);
+}
+async function fetchLoopHistory(client, loopID, timeout) {
+  return client.requestResponse(
+    "loop_history_fetch",
+    { loop_id: loopID },
+    "loop_history_fetch",
+    timeout ?? 15e3
+  );
+}
+async function authenticate(client, accessKey, secretKey, timeout) {
+  return client.requestResponse(
+    "auth",
+    { access_key: accessKey, secret_key: secretKey },
+    "auth",
+    timeout ?? 15e3
+  );
+}
+async function refreshAuthToken(client, refreshToken, timeout) {
+  return client.requestResponse(
+    "auth_refresh",
+    { refresh_token: refreshToken },
+    "auth_refresh",
+    timeout ?? 15e3
+  );
+}
+async function fetchLoopCards(client, loopID, timeout) {
+  return client.fetchLoopCards(loopID, timeout);
+}
+async function fetchLoopMessages(client, loopID, opts) {
+  return client.getLoopMessages(
+    loopID,
+    opts?.limit,
+    opts?.offset,
+    opts?.includeEvents,
+    opts?.timeout
+  );
+}
+async function connectedWebsocket(wsUrl, fn, timeoutMs = 3e4) {
+  const { Client: Client2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const client = new Client2(wsUrl, defaultConfig());
+  const deadline = Date.now() + timeoutMs;
+  try {
+    await client.connect();
+    while (!client.isConnected() && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    if (!client.isConnected()) {
+      throw new Error("Timed out waiting for daemon handshake");
+    }
+    return await fn(client);
+  } finally {
+    client.close();
+  }
+}
+async function protocol1Rpc(wsUrl, method, params = null, opts = {}) {
+  const mode = opts.mode ?? "request";
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  try {
+    return await connectedWebsocket(
+      wsUrl,
+      async (client) => {
+        if (mode === "notify") {
+          await client.notify(method, params ?? {});
+          return {};
+        }
+        if (mode === "subscribe") {
+          const subId = await client.subscribe(
+            method,
+            params ?? {},
+            timeoutMs
+          );
+          return { subscription_id: subId };
+        }
+        const result = await client.requestResponse(
+          method,
+          params ?? {},
+          method,
+          timeoutMs
+        );
+        return result && typeof result === "object" ? result : { result };
+      },
+      timeoutMs
+    );
+  } catch (exc) {
+    const msg = exc instanceof Error ? exc.message : String(exc);
+    if (msg.toLowerCase().includes("timed out") || msg.toLowerCase().includes("timeout")) {
+      return { error: "Timed out waiting for daemon response" };
+    }
+    if (msg.toLowerCase().includes("connect") || msg.toLowerCase().includes("dial")) {
+      return { error: `Connection error: ${msg}` };
+    }
+    return { error: msg };
+  }
+}
+
+// src/index.ts
+init_stream_terminal();
+
 // src/appkit/broadcaster.ts
 var SUBSCRIBER_QUEUE_CAP = 100;
 var SSEBroadcaster = class {
@@ -1985,6 +2589,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 +2709,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 +2717,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 +2734,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 +2776,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") {
@@ -2191,10 +2811,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 +2829,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 +3251,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 +3362,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 +3452,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 +3487,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 +3504,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 +3554,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 +3585,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 +3615,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 +3699,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 +3774,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 +4289,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 +4322,18 @@ var TurnRunner = class {
   extractSootheLoopID,
   extractThinkingStep,
   fetchConfigSection,
+  fetchLoopCards,
   fetchLoopHistory,
+  fetchLoopMessages,
   fetchSkillsCatalog,
+  idleTimeoutForTurn,
+  inboundNeedsDeliveryAck,
   inputMessageForLoop,
   isCompletionEvent,
   isDaemonLive,
   isSubagentProgressEvent,
+  isTurnEndCustomData,
+  isTurnProgressChunk,
   isValidVerbosityLevel,
   loadConfigFromEnv,
   newLoopInputMessage,
@@ -3075,6 +4344,7 @@ var TurnRunner = class {
   parseNamespace,
   pingEnvelope,
   pongEnvelope,
+  protocol1Rpc,
   refreshAuthToken,
   requestDaemonConfigReload,
   requestDaemonShutdown,