very-happy-cli 0.2.158 → 0.2.159

package/dist/{teams-CqSwtw2O.mjs → teams-CEahj4cm.mjs}

@@ -2,9 +2,9 @@ import { homedir } from 'node:os';
 import { readFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { randomUUID } from 'node:crypto';
-import { I as teamRequest, J as createTeamsClient } from './agentGuidance-CrR9l62U.mjs';
-import { h as readCredentialsForConfiguredRelay } from './limits-D2uN090G.mjs';
-import { a as installTeamSkill, i as installAutomationSkill } from './install-DarS_Wco.mjs';
+import { I as teamRequest, J as createTeamsClient } from './agentGuidance-KgvYuF3R.mjs';
+import { h as readCredentialsForConfiguredRelay } from './limits-CjRj8IX5.mjs';
+import { a as installTeamSkill, i as installAutomationSkill } from './install-BPhJppvd.mjs';
 import 'node:fs';
 import 'node:path';
 import 'axios';
@@ -13,8 +13,8 @@ import '@paralleldrive/cuid2';
 import 'tweetnacl';
 import 'chalk';
 import 'node:util';
-import './index-CVCt3kSt.mjs';
-import './types-DIBF4U0Y.mjs';
+import './index-BF6WfgV5.mjs';
+import './types-Dh-s4Lqs.mjs';
 import 'node:events';
 import 'child_process';
 import 'util';

package/dist/{todo-BbusB1zM.mjs → todo-Cknp5D4U.mjs}

@@ -1,5 +1,5 @@
-import { h as readCredentialsForConfiguredRelay, j as createBuiltinTodoClient, c as configuration, B as BUILTIN_TODO_SKILL } from './limits-D2uN090G.mjs';
-import { C as readTeamScope, E as teamScopePath } from './agentGuidance-CrR9l62U.mjs';
+import { h as readCredentialsForConfiguredRelay, j as createBuiltinTodoClient, c as configuration, B as BUILTIN_TODO_SKILL } from './limits-CjRj8IX5.mjs';
+import { C as readTeamScope, E as teamScopePath } from './agentGuidance-KgvYuF3R.mjs';
 import 'zod';
 import '@paralleldrive/cuid2';
 import 'node:fs/promises';

package/dist/{todo-BYMg0fR0.cjs → todo-DqyRI4wP.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var persistence = require('./limits-kqFqhfsh.cjs');
-var agentGuidance = require('./agentGuidance-DwOWbX55.cjs');
+var persistence = require('./limits-BH5CV5vR.cjs');
+var agentGuidance = require('./agentGuidance-BRDN1NoZ.cjs');
 require('zod');
 require('@paralleldrive/cuid2');
 require('node:fs/promises');

package/dist/{types-DnrPeN80.cjs → types-BbvK1Tr_.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var axios = require('axios');
-var persistence = require('./limits-kqFqhfsh.cjs');
+var persistence = require('./limits-BH5CV5vR.cjs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
@@ -2252,6 +2252,143 @@ class TurnReporter {
   }
 }
 
+const PROMPT_QUEUE_INFLIGHT_TIMEOUT_MS = 2e4;
+const PROMPT_QUEUE_RETRY_MIN_MS = 1e3;
+const PROMPT_QUEUE_RETRY_MAX_MS = 3e4;
+class PromptQueueDrain {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+    this.log = deps.log ?? (() => {
+    });
+    this.schedule = deps.schedule ?? ((fn, delayMs) => {
+      const timer = setTimeout(fn, delayMs);
+      timer.unref?.();
+    });
+    this.inflightTimeoutMs = deps.inflightTimeoutMs ?? PROMPT_QUEUE_INFLIGHT_TIMEOUT_MS;
+  }
+  inflight = null;
+  /**
+   * localIds routed while a dispatch call was still in flight. The server's
+   * `new-message` echo regularly beats the HTTP response (both come off the
+   * same transaction), so `onInbound` can precede the `dispatched` outcome;
+   * without this the guard armed AFTER the message had arrived and sat
+   * until the timeout — observed in the first isolated e2e run.
+   */
+  arrivedDuringDispatch = /* @__PURE__ */ new Set();
+  /** Items the server still holds, from the last snapshot / dispatch response. */
+  pending = 0;
+  disabled = false;
+  closed = false;
+  busy = false;
+  failures = 0;
+  retryAt = 0;
+  retryScheduled = false;
+  now;
+  log;
+  schedule;
+  inflightTimeoutMs;
+  /** The runner is blocked on an empty input queue. */
+  onIdle() {
+    void this.maybeDispatch("idle");
+  }
+  /** A `prompt-queue` snapshot arrived; only a non-empty queue is worth a call. */
+  onQueueChanged(count) {
+    this.pending = Math.max(0, count);
+    if (count > 0) void this.maybeDispatch("queue-changed");
+  }
+  /**
+   * True while the server still holds queued prompts for this session. The
+   * runners fold it into their "idle, waiting for the user" judgement so a
+   * turn that ends with more queue behind it raises no reply_done /
+   * input_needed notification and no daemon `completed` report per item.
+   */
+  hasPending() {
+    return !this.disabled && !this.closed && this.pending > 0;
+  }
+  /** A user message with this localId was routed into the runner's queue. */
+  onInbound(localId) {
+    if (this.inflight?.localId === localId) {
+      this.inflight = null;
+      return;
+    }
+    if (this.busy) {
+      this.arrivedDuringDispatch.add(localId);
+      if (this.arrivedDuringDispatch.size > 64) {
+        const oldest = this.arrivedDuringDispatch.values().next().value;
+        if (oldest !== void 0) this.arrivedDuringDispatch.delete(oldest);
+      }
+    }
+  }
+  close() {
+    this.closed = true;
+  }
+  state() {
+    return { inflight: this.inflight, disabled: this.disabled, busy: this.busy, failures: this.failures, retryAt: this.retryAt, pending: this.pending };
+  }
+  async maybeDispatch(reason) {
+    if (this.closed || this.disabled || this.busy) return false;
+    const now = this.now();
+    if (this.inflight) {
+      if (now - this.inflight.since < this.inflightTimeoutMs) return false;
+      this.log(`[prompt-queue] inflight ${this.inflight.localId} not routed within ${this.inflightTimeoutMs}ms; releasing`);
+      this.inflight = null;
+    }
+    if (now < this.retryAt) {
+      this.scheduleRetry(this.retryAt - now);
+      return false;
+    }
+    if (!this.deps.isIdle()) return false;
+    this.busy = true;
+    this.arrivedDuringDispatch.clear();
+    try {
+      const outcome = await this.deps.dispatch();
+      switch (outcome.kind) {
+        case "dispatched": {
+          this.failures = 0;
+          if (typeof outcome.remaining === "number") this.pending = Math.max(0, outcome.remaining);
+          const alreadyRouted = this.arrivedDuringDispatch.delete(outcome.localId) || outcome.created === false;
+          if (!alreadyRouted) {
+            this.inflight = { localId: outcome.localId, since: this.now() };
+            this.schedule(() => {
+              void this.maybeDispatch("inflight-timeout");
+            }, this.inflightTimeoutMs + 1);
+          }
+          this.log(`[prompt-queue] dispatched ${outcome.localId} (${reason}${alreadyRouted ? ", already routed" : ""})`);
+          return true;
+        }
+        case "empty":
+          this.failures = 0;
+          this.pending = 0;
+          return false;
+        case "unsupported":
+          this.disabled = true;
+          this.log("[prompt-queue] server has no prompt queue; drain disabled for this process");
+          return false;
+        case "error": {
+          this.failures += 1;
+          const delay = Math.min(PROMPT_QUEUE_RETRY_MAX_MS, PROMPT_QUEUE_RETRY_MIN_MS * 2 ** (this.failures - 1));
+          this.retryAt = this.now() + delay;
+          this.log(`[prompt-queue] dispatch failed (${outcome.message}); retry in ${delay}ms`);
+          this.scheduleRetry(delay);
+          return false;
+        }
+      }
+    } finally {
+      this.busy = false;
+      this.arrivedDuringDispatch.clear();
+    }
+  }
+  scheduleRetry(delayMs) {
+    if (this.retryScheduled || this.closed) return;
+    this.retryScheduled = true;
+    this.schedule(() => {
+      this.retryScheduled = false;
+      void this.maybeDispatch("retry");
+    }, delayMs);
+  }
+}
+
 class ApiSessionClient extends node_events.EventEmitter {
   token;
   sessionId;
@@ -2315,6 +2452,8 @@ class ApiSessionClient extends node_events.EventEmitter {
    *  must wait for the first fetch, otherwise a message that lands between
    *  the seed and the first fetch is routed twice (socket + fetch). */
   awaitingInitialFetch = false;
+  /** B-509: server-side prompt queue drain, attached by the runner. */
+  promptQueueDrain = null;
   constructor(token, session, opts) {
     super();
     this.token = token;
@@ -2349,6 +2488,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       this.rpcHandlerManager.onSocketConnect(controlSocket);
       this.receiveSync.invalidate();
       void this.connectSessionRelay();
+      void this.promptQueueDrain?.maybeDispatch("connect");
     });
     this.socket.on("rpc-request", async (data, callback) => {
       await answerSocketRequest(
@@ -2384,6 +2524,11 @@ class ApiSessionClient extends node_events.EventEmitter {
           persistence.logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
           return;
         }
+        if (data.body.t === "prompt-queue") {
+          const items = data.body.items;
+          this.promptQueueDrain?.onQueueChanged(Array.isArray(items) ? items.length : 0);
+          return;
+        }
         if (data.body.t === "new-message") {
           const messageSeq = data.body.message?.seq;
           if (this.lastSeq === 0 || this.awaitingInitialFetch) {
@@ -2634,7 +2779,51 @@ class ApiSessionClient extends node_events.EventEmitter {
       "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
     };
   }
+  /**
+   * B-509: attach the server-side prompt queue drain. `isIdle` is the
+   * runner's own notion (input queue empty + blocked waiting); dispatching is
+   * `POST /v1/sessions/:id/prompt-queue/dispatch`, whose message then comes
+   * back through the ordinary socket / catch-up path and is routed below.
+   */
+  attachPromptQueueDrain(opts) {
+    this.promptQueueDrain?.close();
+    const drain = new PromptQueueDrain({
+      isIdle: opts.isIdle,
+      dispatch: () => this.dispatchPromptQueueHead(),
+      log: (message) => persistence.logger.debug(`[API] ${message}`)
+    });
+    this.promptQueueDrain = drain;
+    return drain;
+  }
+  /** B-509: the server still holds queued prompts for this session (see PromptQueueDrain.hasPending). */
+  promptQueueHasPending() {
+    return this.promptQueueDrain?.hasPending() === true;
+  }
+  /** B-509: stop draining before the process winds down (cleanup's first line). */
+  closePromptQueueDrain() {
+    this.promptQueueDrain?.close();
+  }
+  async dispatchPromptQueueHead() {
+    try {
+      const response = await axios.post(
+        `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(this.sessionId)}/prompt-queue/dispatch`,
+        {},
+        { headers: this.authHeaders(), timeout: 3e4, validateStatus: () => true }
+      );
+      if (response.status === 404) return { kind: "unsupported" };
+      if (response.status !== 200) return { kind: "error", message: `HTTP ${response.status}` };
+      const dispatched = response.data?.dispatched;
+      const remaining = typeof response.data?.remaining === "number" ? response.data.remaining : void 0;
+      if (dispatched && typeof dispatched.localId === "string") {
+        return { kind: "dispatched", localId: dispatched.localId, remaining, created: dispatched.created !== false };
+      }
+      return { kind: "empty" };
+    } catch (error) {
+      return { kind: "error", message: error instanceof Error ? error.message : String(error) };
+    }
+  }
   routeIncomingMessage(message, sourceLocalId) {
+    if (sourceLocalId) this.promptQueueDrain?.onInbound(sourceLocalId);
     const messageWithSource = sourceLocalId && typeof message === "object" && message !== null ? { ...message, localKey: message.localKey ?? sourceLocalId } : message;
     const userResult = UserMessageSchema.safeParse(messageWithSource);
     if (userResult.success) {
@@ -3320,6 +3509,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async close() {
     persistence.logger.debug("[API] socket.close() called");
+    this.promptQueueDrain?.close();
     this.sendSync.stop();
     this.receiveSync.stop();
     if (this.reconnectInterval) {

package/dist/{types-DIBF4U0Y.mjs → types-Dh-s4Lqs.mjs}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { S as AgentVersionsSchema, l as logger, w as encodeBase64, L as encrypt, N as decrypt, M as decodeBase64, c as configuration, e as createEnvelope, s as streamKeyOf, T as backoff, U as ReleaseDrainNoticeSchema, V as decryptBlob, W as RelayAssignmentResponseSchema, X as notifyDaemonTurnEvent, Y as BackgroundTaskReporter, Z as notifyDaemonBackgroundTasks, _ as prepareClipboardText, $ as prepareClipboardHistoryText, g as delay, r as readSettings, d as readPersistedSessions, a0 as credentialRelayProblem, F as packageJson, a1 as RelayCandidatesResponseSchema, a2 as readTrackedClaudeSessionIds, a3 as readTrackedCodexThreadIds, a4 as isValidTerminalId, a5 as exponentialBackoffDelay, a6 as libsodiumEncryptForPublicKey, a7 as libsodiumPublicKeyFromSecretKey, a8 as getRandomBytes, a9 as redactLogValue } from './limits-D2uN090G.mjs';
+import { T as AgentVersionsSchema, l as logger, w as encodeBase64, L as encrypt, N as decrypt, M as decodeBase64, c as configuration, e as createEnvelope, s as streamKeyOf, U as backoff, V as ReleaseDrainNoticeSchema, W as decryptBlob, X as RelayAssignmentResponseSchema, Y as notifyDaemonTurnEvent, Z as BackgroundTaskReporter, _ as notifyDaemonBackgroundTasks, $ as prepareClipboardText, a0 as prepareClipboardHistoryText, g as delay, r as readSettings, d as readPersistedSessions, a1 as credentialRelayProblem, F as packageJson, a2 as RelayCandidatesResponseSchema, a3 as readTrackedClaudeSessionIds, a4 as readTrackedCodexThreadIds, a5 as isValidTerminalId, a6 as exponentialBackoffDelay, a7 as libsodiumEncryptForPublicKey, a8 as libsodiumPublicKeyFromSecretKey, a9 as getRandomBytes, aa as redactLogValue } from './limits-CjRj8IX5.mjs';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
 import { z } from 'zod';
@@ -2231,6 +2231,143 @@ class TurnReporter {
   }
 }
 
+const PROMPT_QUEUE_INFLIGHT_TIMEOUT_MS = 2e4;
+const PROMPT_QUEUE_RETRY_MIN_MS = 1e3;
+const PROMPT_QUEUE_RETRY_MAX_MS = 3e4;
+class PromptQueueDrain {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+    this.log = deps.log ?? (() => {
+    });
+    this.schedule = deps.schedule ?? ((fn, delayMs) => {
+      const timer = setTimeout(fn, delayMs);
+      timer.unref?.();
+    });
+    this.inflightTimeoutMs = deps.inflightTimeoutMs ?? PROMPT_QUEUE_INFLIGHT_TIMEOUT_MS;
+  }
+  inflight = null;
+  /**
+   * localIds routed while a dispatch call was still in flight. The server's
+   * `new-message` echo regularly beats the HTTP response (both come off the
+   * same transaction), so `onInbound` can precede the `dispatched` outcome;
+   * without this the guard armed AFTER the message had arrived and sat
+   * until the timeout — observed in the first isolated e2e run.
+   */
+  arrivedDuringDispatch = /* @__PURE__ */ new Set();
+  /** Items the server still holds, from the last snapshot / dispatch response. */
+  pending = 0;
+  disabled = false;
+  closed = false;
+  busy = false;
+  failures = 0;
+  retryAt = 0;
+  retryScheduled = false;
+  now;
+  log;
+  schedule;
+  inflightTimeoutMs;
+  /** The runner is blocked on an empty input queue. */
+  onIdle() {
+    void this.maybeDispatch("idle");
+  }
+  /** A `prompt-queue` snapshot arrived; only a non-empty queue is worth a call. */
+  onQueueChanged(count) {
+    this.pending = Math.max(0, count);
+    if (count > 0) void this.maybeDispatch("queue-changed");
+  }
+  /**
+   * True while the server still holds queued prompts for this session. The
+   * runners fold it into their "idle, waiting for the user" judgement so a
+   * turn that ends with more queue behind it raises no reply_done /
+   * input_needed notification and no daemon `completed` report per item.
+   */
+  hasPending() {
+    return !this.disabled && !this.closed && this.pending > 0;
+  }
+  /** A user message with this localId was routed into the runner's queue. */
+  onInbound(localId) {
+    if (this.inflight?.localId === localId) {
+      this.inflight = null;
+      return;
+    }
+    if (this.busy) {
+      this.arrivedDuringDispatch.add(localId);
+      if (this.arrivedDuringDispatch.size > 64) {
+        const oldest = this.arrivedDuringDispatch.values().next().value;
+        if (oldest !== void 0) this.arrivedDuringDispatch.delete(oldest);
+      }
+    }
+  }
+  close() {
+    this.closed = true;
+  }
+  state() {
+    return { inflight: this.inflight, disabled: this.disabled, busy: this.busy, failures: this.failures, retryAt: this.retryAt, pending: this.pending };
+  }
+  async maybeDispatch(reason) {
+    if (this.closed || this.disabled || this.busy) return false;
+    const now = this.now();
+    if (this.inflight) {
+      if (now - this.inflight.since < this.inflightTimeoutMs) return false;
+      this.log(`[prompt-queue] inflight ${this.inflight.localId} not routed within ${this.inflightTimeoutMs}ms; releasing`);
+      this.inflight = null;
+    }
+    if (now < this.retryAt) {
+      this.scheduleRetry(this.retryAt - now);
+      return false;
+    }
+    if (!this.deps.isIdle()) return false;
+    this.busy = true;
+    this.arrivedDuringDispatch.clear();
+    try {
+      const outcome = await this.deps.dispatch();
+      switch (outcome.kind) {
+        case "dispatched": {
+          this.failures = 0;
+          if (typeof outcome.remaining === "number") this.pending = Math.max(0, outcome.remaining);
+          const alreadyRouted = this.arrivedDuringDispatch.delete(outcome.localId) || outcome.created === false;
+          if (!alreadyRouted) {
+            this.inflight = { localId: outcome.localId, since: this.now() };
+            this.schedule(() => {
+              void this.maybeDispatch("inflight-timeout");
+            }, this.inflightTimeoutMs + 1);
+          }
+          this.log(`[prompt-queue] dispatched ${outcome.localId} (${reason}${alreadyRouted ? ", already routed" : ""})`);
+          return true;
+        }
+        case "empty":
+          this.failures = 0;
+          this.pending = 0;
+          return false;
+        case "unsupported":
+          this.disabled = true;
+          this.log("[prompt-queue] server has no prompt queue; drain disabled for this process");
+          return false;
+        case "error": {
+          this.failures += 1;
+          const delay = Math.min(PROMPT_QUEUE_RETRY_MAX_MS, PROMPT_QUEUE_RETRY_MIN_MS * 2 ** (this.failures - 1));
+          this.retryAt = this.now() + delay;
+          this.log(`[prompt-queue] dispatch failed (${outcome.message}); retry in ${delay}ms`);
+          this.scheduleRetry(delay);
+          return false;
+        }
+      }
+    } finally {
+      this.busy = false;
+      this.arrivedDuringDispatch.clear();
+    }
+  }
+  scheduleRetry(delayMs) {
+    if (this.retryScheduled || this.closed) return;
+    this.retryScheduled = true;
+    this.schedule(() => {
+      this.retryScheduled = false;
+      void this.maybeDispatch("retry");
+    }, delayMs);
+  }
+}
+
 class ApiSessionClient extends EventEmitter {
   token;
   sessionId;
@@ -2294,6 +2431,8 @@ class ApiSessionClient extends EventEmitter {
    *  must wait for the first fetch, otherwise a message that lands between
    *  the seed and the first fetch is routed twice (socket + fetch). */
   awaitingInitialFetch = false;
+  /** B-509: server-side prompt queue drain, attached by the runner. */
+  promptQueueDrain = null;
   constructor(token, session, opts) {
     super();
     this.token = token;
@@ -2328,6 +2467,7 @@ class ApiSessionClient extends EventEmitter {
       this.rpcHandlerManager.onSocketConnect(controlSocket);
       this.receiveSync.invalidate();
       void this.connectSessionRelay();
+      void this.promptQueueDrain?.maybeDispatch("connect");
     });
     this.socket.on("rpc-request", async (data, callback) => {
       await answerSocketRequest(
@@ -2363,6 +2503,11 @@ class ApiSessionClient extends EventEmitter {
           logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
           return;
         }
+        if (data.body.t === "prompt-queue") {
+          const items = data.body.items;
+          this.promptQueueDrain?.onQueueChanged(Array.isArray(items) ? items.length : 0);
+          return;
+        }
         if (data.body.t === "new-message") {
           const messageSeq = data.body.message?.seq;
           if (this.lastSeq === 0 || this.awaitingInitialFetch) {
@@ -2613,7 +2758,51 @@ class ApiSessionClient extends EventEmitter {
       "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
     };
   }
+  /**
+   * B-509: attach the server-side prompt queue drain. `isIdle` is the
+   * runner's own notion (input queue empty + blocked waiting); dispatching is
+   * `POST /v1/sessions/:id/prompt-queue/dispatch`, whose message then comes
+   * back through the ordinary socket / catch-up path and is routed below.
+   */
+  attachPromptQueueDrain(opts) {
+    this.promptQueueDrain?.close();
+    const drain = new PromptQueueDrain({
+      isIdle: opts.isIdle,
+      dispatch: () => this.dispatchPromptQueueHead(),
+      log: (message) => logger.debug(`[API] ${message}`)
+    });
+    this.promptQueueDrain = drain;
+    return drain;
+  }
+  /** B-509: the server still holds queued prompts for this session (see PromptQueueDrain.hasPending). */
+  promptQueueHasPending() {
+    return this.promptQueueDrain?.hasPending() === true;
+  }
+  /** B-509: stop draining before the process winds down (cleanup's first line). */
+  closePromptQueueDrain() {
+    this.promptQueueDrain?.close();
+  }
+  async dispatchPromptQueueHead() {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(this.sessionId)}/prompt-queue/dispatch`,
+        {},
+        { headers: this.authHeaders(), timeout: 3e4, validateStatus: () => true }
+      );
+      if (response.status === 404) return { kind: "unsupported" };
+      if (response.status !== 200) return { kind: "error", message: `HTTP ${response.status}` };
+      const dispatched = response.data?.dispatched;
+      const remaining = typeof response.data?.remaining === "number" ? response.data.remaining : void 0;
+      if (dispatched && typeof dispatched.localId === "string") {
+        return { kind: "dispatched", localId: dispatched.localId, remaining, created: dispatched.created !== false };
+      }
+      return { kind: "empty" };
+    } catch (error) {
+      return { kind: "error", message: error instanceof Error ? error.message : String(error) };
+    }
+  }
   routeIncomingMessage(message, sourceLocalId) {
+    if (sourceLocalId) this.promptQueueDrain?.onInbound(sourceLocalId);
     const messageWithSource = sourceLocalId && typeof message === "object" && message !== null ? { ...message, localKey: message.localKey ?? sourceLocalId } : message;
     const userResult = UserMessageSchema.safeParse(messageWithSource);
     if (userResult.success) {
@@ -3299,6 +3488,7 @@ class ApiSessionClient extends EventEmitter {
   }
   async close() {
     logger.debug("[API] socket.close() called");
+    this.promptQueueDrain?.close();
     this.sendSync.stop();
     this.receiveSync.stop();
     if (this.reconnectInterval) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "very-happy-cli",
-  "version": "0.2.158",
+  "version": "0.2.159",
   "description": "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.",
   "author": "Kirill Dubovitskiy",
   "contributors": [
@@ -117,12 +117,12 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "very-happy-tools-arm64-darwin": "0.2.158",
-    "very-happy-tools-x64-darwin": "0.2.158",
-    "very-happy-tools-arm64-linux": "0.2.158",
-    "very-happy-tools-x64-linux": "0.2.158",
-    "very-happy-tools-arm64-win32": "0.2.158",
-    "very-happy-tools-x64-win32": "0.2.158"
+    "very-happy-tools-arm64-darwin": "0.2.159",
+    "very-happy-tools-x64-darwin": "0.2.159",
+    "very-happy-tools-arm64-linux": "0.2.159",
+    "very-happy-tools-x64-linux": "0.2.159",
+    "very-happy-tools-arm64-win32": "0.2.159",
+    "very-happy-tools-x64-win32": "0.2.159"
   },
   "devDependencies": {
     "@slopus/happy-wire": "workspace:*",