very-happy-cli 0.2.110 → 0.2.112

package/dist/{index-BW9kDx5m.mjs → index-inkhalP5.mjs}

@@ -1,7 +1,7 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir, userInfo } from 'node:os';
 import { randomUUID, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { o as readDaemonState, l as logger, c as configuration, q as clearDaemonState, s as getProjectPath, p as projectPath, t as initializeSandbox, u as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, v as AsyncLock, x as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, y as hardenPrivateFile, f as packageJson, j as readSettings, z as readCredentials, B as credentialRelayProblem, C as deriveLocalCliUpdateSummary, k as encodeBase64, D as updateSettings, E as encodeBase64Url, F as decodeBase64, G as writeCredentialsLegacy, H as writeCredentialsDataKey, J as readCredentialsForConfiguredRelay, K as encrypt, r as readPersistedSessions, L as isClaudeSessionId, N as getLocalHappyAgentCredentialPath, O as readLocalHappyAgentCredentials, P as decryptWithDataKey, Q as decryptLegacy, S as extractCompleteLines, T as decideBackfill, U as parseTerminalHookPayload, V as tmuxArgs, W as scrubTmuxClientEnv, X as decideMirrorBinding, Y as MIRROR_BACKFILL_LINES_DEFAULT, Z as persistSession, _ as mirrorLineKey, $ as mirrorLocalId, w as writePrivateFileSync, a0 as detectResumeSupport, a1 as detectCLIAvailability, a2 as acquireDaemonLock, a3 as summarizeSpawnSessionForLog, a4 as deletePersistedSessions, a5 as shellescape, a6 as decrypt, a7 as writeDaemonState, A as ApiClient, a8 as writeSettings, a9 as fetchCliUpdateState, aa as resolveCliUpdateCheckInterval, ab as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, ac as releaseDaemonLock, i as isValidSessionId, ad as listVhTerminals, ae as isValidTerminalId, af as readVhTerminal, ag as sendToVhTerminal, ah as TITLE_PROMPT_PREFIX, ai as BOARD_ANALYZER_PROMPT_PREFIX, h as connectionState, aj as startOfflineReconnection, ak as clearCredentials, al as clearMachineId, m as ensurePrivateDirectorySync, am as SandboxConfigSchema, b as createEnvelope, an as CodexAppServerClient, ao as getLatestDaemonLog } from './types-BdO0jg7G.mjs';
+import { o as readDaemonState, l as logger, c as configuration, q as clearDaemonState, s as getProjectPath, p as projectPath, t as initializeSandbox, u as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, v as AsyncLock, S as STREAM_DELTA_MAX_CHARS, x as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, y as hardenPrivateFile, f as packageJson, j as readSettings, z as readCredentials, B as credentialRelayProblem, C as deriveLocalCliUpdateSummary, k as encodeBase64, D as updateSettings, E as encodeBase64Url, F as decodeBase64, G as writeCredentialsLegacy, H as writeCredentialsDataKey, J as readCredentialsForConfiguredRelay, K as encrypt, r as readPersistedSessions, L as isClaudeSessionId, N as getLocalHappyAgentCredentialPath, O as readLocalHappyAgentCredentials, P as decryptWithDataKey, Q as decryptLegacy, T as extractCompleteLines, U as decideBackfill, V as parseTerminalHookPayload, W as tmuxArgs, X as scrubTmuxClientEnv, Y as decideMirrorBinding, Z as MIRROR_BACKFILL_LINES_DEFAULT, _ as persistSession, $ as mirrorLineKey, a0 as mirrorLocalId, w as writePrivateFileSync, a1 as detectResumeSupport, a2 as detectCLIAvailability, a3 as acquireDaemonLock, a4 as summarizeSpawnSessionForLog, a5 as deletePersistedSessions, a6 as shellescape, a7 as decrypt, a8 as writeDaemonState, A as ApiClient, a9 as writeSettings, aa as fetchCliUpdateState, ab as resolveCliUpdateCheckInterval, ac as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, ad as releaseDaemonLock, i as isValidSessionId, ae as listVhTerminals, af as isValidTerminalId, ag as readVhTerminal, ah as sendToVhTerminal, ai as TITLE_PROMPT_PREFIX, aj as BOARD_ANALYZER_PROMPT_PREFIX, h as connectionState, ak as startOfflineReconnection, al as clearCredentials, am as clearMachineId, m as ensurePrivateDirectorySync, an as SandboxConfigSchema, b as createEnvelope, ao as CodexAppServerClient, ap as getLatestDaemonLog } from './types-C5ewhu1Q.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, delimiter, isAbsolute, normalize, sep, dirname } from 'node:path';
 import { createInterface } from 'node:readline';
@@ -169,7 +169,14 @@ async function stopDaemonSession(sessionId) {
   return result.success || false;
 }
 async function spawnDaemonSession(directory, sessionId, opts) {
-  const result = await daemonPost("/spawn-session", { directory, sessionId, spawnedBy: opts?.spawnedBy });
+  const result = await daemonPost("/spawn-session", {
+    directory,
+    sessionId,
+    spawnedBy: opts?.spawnedBy,
+    permissionMode: opts?.permissionMode,
+    agent: opts?.agent,
+    environmentVariables: opts?.environmentVariables
+  });
   return result;
 }
 async function notifyDaemonSessionEvent(sessionId, event, spawnedBy) {
@@ -1996,7 +2003,14 @@ async function claudeRemote(opts) {
     onUserDialog: opts.onUserDialog,
     supportedDialogKinds: opts.onUserDialog ? ["refusal_fallback_prompt"] : void 0,
     abort: opts.signal,
-    settingsPath: opts.hookSettingsPath
+    settingsPath: opts.hookSettingsPath,
+    // B-309: token-level partials. Without this the SDK emits nothing
+    // between "turn started" and "entire assistant message", which is
+    // exactly why the web used to show a spinner where the terminal shows
+    // the model thinking out loud. The partials do NOT enter the
+    // transcript; they are split off below and relayed on a side channel.
+    // Only pay for them when someone is listening.
+    includePartialMessages: opts.onStreamFrame ? true : void 0
   };
   let thinking = false;
   const updateThinking = (newThinking) => {
@@ -2046,10 +2060,26 @@ async function claudeRemote(opts) {
   try {
     logger.debug(`[claudeRemote] Starting to iterate over response`);
     for await (const message of response) {
+      if (message.type === "stream_event") {
+        if (opts.onStreamFrame && !message.parent_tool_use_id) {
+          opts.onStreamFrame({ type: "stream_event", event: message.event });
+        }
+        continue;
+      }
       logger.debug(`[claudeRemote] Message ${message.type}`, contentLogMetadata(message));
       if (message.type === "assistant" && message.error) {
         lastAssistantError = message.error;
       }
+      if (opts.onStreamFrame && message.type === "system") {
+        const subtype = message.subtype;
+        if (subtype === "thinking_tokens") {
+          const tokens = message;
+          opts.onStreamFrame({ type: "system", subtype: "thinking_tokens", estimated_tokens: tokens.estimated_tokens });
+        } else if (subtype === "status") {
+          const status = message;
+          opts.onStreamFrame({ type: "system", subtype: "status", status: status.status });
+        }
+      }
       const outboundMessage = isCompactCommand && message.type === "assistant" ? { ...message, isCompactSummary: true } : message;
       opts.onMessage(outboundMessage);
       if (message.type === "system" && message.subtype === "init") {
@@ -3249,6 +3279,197 @@ class OutgoingMessageQueue {
   }
 }
 
+const STREAM_FLUSH_MS = 80;
+const PROGRESS_FLUSH_MS = 250;
+const STREAM_FLUSH_MAX_BYTES = 16 * 1024;
+class StreamRelay {
+  send;
+  setTimer;
+  clearTimer;
+  now;
+  /** The block currently accumulating deltas. At most one is open at a time
+   *  in practice; a switch flushes the previous one first, so out-of-order
+   *  SDK frames degrade to "slightly chunkier", never to interleaved text. */
+  pending = null;
+  flushHandle = null;
+  progress = {};
+  progressDirty = false;
+  progressHandle = null;
+  /** Message id of the block currently open, so `content_block_delta` (which
+   *  carries only an index) can be attributed. Reset per assistant message. */
+  currentMid = null;
+  openBlocks = /* @__PURE__ */ new Set();
+  /** True while nothing has been ingested since the last sweep. Both the SDK
+   *  `result` frame and the launcher's `finally` call endTurn (the second is
+   *  the safety net for turns that die before producing a result), so
+   *  without this a normal turn would emit two sweeps. */
+  idleSinceTurnEnd = true;
+  constructor(options) {
+    this.send = options.send;
+    this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+    this.now = options.now ?? (() => Date.now());
+  }
+  /** Feed one SDK frame. Unknown shapes are ignored, never thrown on: this
+   *  channel must not be able to take a turn down. */
+  ingest(message) {
+    this.idleSinceTurnEnd = false;
+    try {
+      if (message.type === "stream_event") {
+        this.ingestStreamEvent(message.event);
+        return;
+      }
+      if (message.type === "system" && message.subtype === "thinking_tokens") {
+        if (typeof message.estimated_tokens === "number") {
+          this.setProgress({ thinkingTokens: message.estimated_tokens });
+        }
+        return;
+      }
+      if (message.type === "system" && message.subtype === "status") {
+        const status = message.status === "requesting" || message.status === "compacting" ? message.status : void 0;
+        this.progress.status = status;
+        this.progressDirty = true;
+        this.scheduleProgress();
+        return;
+      }
+    } catch {
+    }
+  }
+  /** The turn produced its result. Flushes everything and tells the web to
+   *  sweep drafts that no persisted message ever claimed. */
+  endTurn() {
+    if (this.idleSinceTurnEnd) {
+      this.clearTimers();
+      return;
+    }
+    this.idleSinceTurnEnd = true;
+    this.flushPending();
+    this.closeOpenBlocks();
+    this.flushProgress();
+    this.progress = {};
+    this.currentMid = null;
+    this.send({ t: "turn-end" });
+  }
+  /** Release timers without emitting anything (session teardown). */
+  dispose() {
+    this.clearTimers();
+    this.pending = null;
+    this.openBlocks.clear();
+  }
+  clearTimers() {
+    if (this.flushHandle !== null) this.clearTimer(this.flushHandle);
+    if (this.progressHandle !== null) this.clearTimer(this.progressHandle);
+    this.flushHandle = null;
+    this.progressHandle = null;
+  }
+  ingestStreamEvent(event) {
+    const e = event;
+    if (!e || typeof e.type !== "string") return;
+    if (e.type === "message_start") {
+      const mid = e.message?.id;
+      this.flushPending();
+      this.closeOpenBlocks();
+      this.currentMid = typeof mid === "string" && mid.length > 0 ? mid : null;
+      return;
+    }
+    if (e.type === "content_block_start") {
+      const kind = e.content_block?.type === "thinking" ? "thinking" : e.content_block?.type === "text" ? "text" : null;
+      if (!kind || !this.currentMid || typeof e.index !== "number") return;
+      this.flushPending();
+      this.openBlocks.add(e.index);
+      this.send({ t: "block-start", mid: this.currentMid, idx: e.index, kind });
+      return;
+    }
+    if (e.type === "content_block_delta") {
+      const delta = e.delta;
+      const text = delta?.type === "text_delta" ? delta.text : delta?.type === "thinking_delta" ? delta.thinking : null;
+      if (typeof text !== "string" || text.length === 0) return;
+      if (!this.currentMid || typeof e.index !== "number") return;
+      if (!this.openBlocks.has(e.index)) return;
+      this.appendDelta(this.currentMid, e.index, text);
+      return;
+    }
+    if (e.type === "content_block_stop") {
+      if (!this.currentMid || typeof e.index !== "number") return;
+      if (!this.openBlocks.has(e.index)) return;
+      this.flushPending();
+      this.openBlocks.delete(e.index);
+      this.send({ t: "block-end", mid: this.currentMid, idx: e.index });
+      return;
+    }
+    if (e.type === "message_delta") {
+      const outputTokens = e.usage?.output_tokens;
+      if (typeof outputTokens === "number") {
+        this.setProgress({ outputTokens });
+      }
+      return;
+    }
+  }
+  appendDelta(mid, idx, text) {
+    if (this.pending && (this.pending.mid !== mid || this.pending.idx !== idx)) {
+      this.flushPending();
+    }
+    if (!this.pending) {
+      this.pending = { mid, idx, text: "", bytes: 0 };
+    }
+    this.pending.text += text;
+    this.pending.bytes += Buffer.byteLength(text, "utf8");
+    if (this.pending.bytes >= STREAM_FLUSH_MAX_BYTES || this.pending.text.length >= STREAM_DELTA_MAX_CHARS) {
+      this.flushPending();
+      return;
+    }
+    if (this.flushHandle === null) {
+      this.flushHandle = this.setTimer(() => {
+        this.flushHandle = null;
+        this.flushPending();
+      }, STREAM_FLUSH_MS);
+    }
+  }
+  flushPending() {
+    if (this.flushHandle !== null) {
+      this.clearTimer(this.flushHandle);
+      this.flushHandle = null;
+    }
+    const pending = this.pending;
+    this.pending = null;
+    if (!pending || pending.text.length === 0) return;
+    this.send({ t: "block-delta", mid: pending.mid, idx: pending.idx, text: pending.text });
+  }
+  /** Close blocks the SDK never stopped (interrupt, error, message switch) so
+   *  the web's draft does not keep a blinking cursor forever. */
+  closeOpenBlocks() {
+    if (!this.currentMid || this.openBlocks.size === 0) {
+      this.openBlocks.clear();
+      return;
+    }
+    for (const idx of [...this.openBlocks].sort((a, b) => a - b)) {
+      this.send({ t: "block-end", mid: this.currentMid, idx });
+    }
+    this.openBlocks.clear();
+  }
+  setProgress(patch) {
+    this.progress = { ...this.progress, ...patch };
+    this.progressDirty = true;
+    this.scheduleProgress();
+  }
+  scheduleProgress() {
+    if (this.progressHandle !== null) return;
+    this.progressHandle = this.setTimer(() => {
+      this.progressHandle = null;
+      this.flushProgress();
+    }, PROGRESS_FLUSH_MS);
+  }
+  flushProgress() {
+    if (this.progressHandle !== null) {
+      this.clearTimer(this.progressHandle);
+      this.progressHandle = null;
+    }
+    if (!this.progressDirty) return;
+    this.progressDirty = false;
+    this.send({ t: "progress", ...this.progress });
+  }
+}
+
 function getAskUserQuestionToolCallIds(message) {
   if (message.type !== "assistant") {
     return [];
@@ -3629,6 +3850,10 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
     return nextMode;
   };
   permissionHandler.reset("Previous CLI process exited before responding");
+  const streamingEnabled = process.env.HAPPY_SESSION_STREAM_DISABLED !== "1";
+  const streamRelay = new StreamRelay({
+    send: (frame) => session.client.sendStreamFrame(frame)
+  });
   const messageQueue = new OutgoingMessageQueue(
     (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
   );
@@ -3887,6 +4112,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
             };
           },
           onThinkingChange: session.onThinkingChange,
+          onStreamFrame: streamingEnabled ? (frame) => streamRelay.ingest(frame) : void 0,
           claudeEnvVars: session.claudeEnvVars,
           claudeArgs: session.claudeArgs,
           onMessage,
@@ -3966,6 +4192,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
         await messageQueue.flush();
         messageQueue.destroy();
         logger.debug("[remote]: message queue flushed");
+        streamRelay.endTurn();
+        streamRelay.dispose();
         abortController = null;
         abortFuture?.resolve(void 0);
         abortFuture = null;
@@ -10368,7 +10596,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const run = deps.run ?? (async (input) => {
-    const { query } = await import('./index-jYltd-ZW.mjs');
+    const { query } = await import('./index-lQzCAx9I.mjs');
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -15298,7 +15526,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     process.exit(0);
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-CJyoR9jp.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-CQiW7Jn9.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -15315,7 +15543,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await import('./spawn-DcA80_VN.mjs');
+      const { handleSpawnCommand } = await import('./spawn-D0oTo5BT.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15327,7 +15555,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await import('./sessions-DDwCphTQ.mjs');
+      const { handleSessionsCommand } = await import('./sessions-TM8VaCMY.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15339,7 +15567,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await import('./send-Btz1IZ9U.mjs');
+      const { handleSendCommand } = await import('./send-0TYDXiGx.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -15445,9 +15673,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await import('./config-CTyyVXHj.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-BdO0jg7G.mjs').then(function (n) { return n.ap; });
-        const { ApiClient: ApiClient2 } = await import('./types-BdO0jg7G.mjs').then(function (n) { return n.aq; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-B_L5vXXu.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-C5ewhu1Q.mjs').then(function (n) { return n.aq; });
+        const { ApiClient: ApiClient2 } = await import('./types-C5ewhu1Q.mjs').then(function (n) { return n.ar; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -15478,7 +15706,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await import('./config-CTyyVXHj.mjs');
+        const { readGeminiLocalConfig } = await import('./config-B_L5vXXu.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -15518,7 +15746,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-CuzqF6Ys.mjs');
+      const { runGemini } = await import('./runGemini-DHyBDo5P.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -15540,7 +15768,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-Brhvj7p0.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-Cu5FdgTq.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -15580,7 +15808,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await import('./runOpenClaw-B5pkmSTb.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-DX-tgQ2V.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -15631,7 +15859,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && args.length === 1) {
     try {
-      const { handleMcpCommand } = await import('./mcp-BO9-sxMr.mjs');
+      const { handleMcpCommand } = await import('./mcp-DD-0VkiA.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -15989,4 +16217,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { BasePermissionHandler as B, CHANGE_TITLE_INSTRUCTION as C, DEFAULT_RECENT_LIMIT as D, GEMINI_MODEL_ENV as G, MAX_READ_LIMIT as M, sessionWebUrl as a, sendUserMessage as b, checkIfDaemonRunningAndCleanupStaleState as c, stopSession as d, archiveSession as e, DEFAULT_GEMINI_MODEL as f, initialMachineMetadata as g, createSessionMetadata as h, isValidSpawnOrigin as i, setupOfflineReconnection as j, MessageQueue2 as k, listSessions as l, hashObject as m, notifyDaemonSessionStarted as n, startHappyServer as o, pushClipboardViaDaemon as p, query as q, readSessionTranscript as r, spawnDaemonSession as s, tmuxSupportsSessionEnv as t, registerKillSessionHandler as u, GEMINI_API_KEY_ENV as v, waitForSessionKey as w, GOOGLE_API_KEY_ENV as x, BaseReasoningProcessor as y, MessageBuffer as z };
+export { ALLOWED_SPAWN_PERMISSION_MODES as A, BasePermissionHandler as B, MessageBuffer as C, DEFAULT_RECENT_LIMIT as D, CHANGE_TITLE_INSTRUCTION as E, GEMINI_MODEL_ENV as G, MAX_READ_LIMIT as M, sessionWebUrl as a, sanitizeSpawnPermissionMode as b, checkIfDaemonRunningAndCleanupStaleState as c, sendUserMessage as d, stopSession as e, archiveSession as f, DEFAULT_GEMINI_MODEL as g, initialMachineMetadata as h, isValidSpawnOrigin as i, createSessionMetadata as j, setupOfflineReconnection as k, listSessions as l, MessageQueue2 as m, notifyDaemonSessionStarted as n, hashObject as o, pushClipboardViaDaemon as p, query as q, readSessionTranscript as r, spawnDaemonSession as s, tmuxSupportsSessionEnv as t, startHappyServer as u, registerKillSessionHandler as v, waitForSessionKey as w, GEMINI_API_KEY_ENV as x, GOOGLE_API_KEY_ENV as y, BaseReasoningProcessor as z };

package/dist/{index-jYltd-ZW.mjs → index-lQzCAx9I.mjs}

@@ -1,9 +1,9 @@
-import { q as query } from './index-BW9kDx5m.mjs';
+import { q as query } from './index-inkhalP5.mjs';
 export { AbortError } from '@anthropic-ai/claude-agent-sdk';
 import 'chalk';
 import 'node:os';
 import 'node:crypto';
-import './types-BdO0jg7G.mjs';
+import './types-C5ewhu1Q.mjs';
 import 'axios';
 import 'node:util';
 import 'node:fs';

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 require('chalk');
-require('./index-CvnMiYgh.cjs');
-require('./types--t4zLibT.cjs');
+require('./index-BnRQP3PL.cjs');
+require('./types-R11tMGyX.cjs');
 require('zod');
 require('node:child_process');
 require('node:os');

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import 'chalk';
-import './index-BW9kDx5m.mjs';
-import './types-BdO0jg7G.mjs';
+import './index-inkhalP5.mjs';
+import './types-C5ewhu1Q.mjs';
 import 'zod';
 import 'node:child_process';
 import 'node:os';

package/dist/{installTerminalHooks-DhQ6k7YD.cjs → installTerminalHooks-BVk-r0yD.cjs}

@@ -5,8 +5,8 @@ var path = require('node:path');
 var os = require('node:os');
 var node_child_process = require('node:child_process');
 var chalk = require('chalk');
-var persistence = require('./types--t4zLibT.cjs');
-var index = require('./index-CvnMiYgh.cjs');
+var persistence = require('./types-R11tMGyX.cjs');
+var index = require('./index-BnRQP3PL.cjs');
 require('axios');
 require('node:util');
 require('node:fs/promises');

package/dist/{installTerminalHooks-CJyoR9jp.mjs → installTerminalHooks-CQiW7Jn9.mjs}

@@ -3,8 +3,8 @@ import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import chalk from 'chalk';
-import { p as projectPath } from './types-BdO0jg7G.mjs';
-import { t as tmuxSupportsSessionEnv } from './index-BW9kDx5m.mjs';
+import { p as projectPath } from './types-C5ewhu1Q.mjs';
+import { t as tmuxSupportsSessionEnv } from './index-inkhalP5.mjs';
 import 'axios';
 import 'node:util';
 import 'node:fs/promises';

package/dist/lib.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var persistence = require('./types--t4zLibT.cjs');
+var persistence = require('./types-R11tMGyX.cjs');
 require('axios');
 require('chalk');
 require('node:util');

package/dist/lib.d.cts

@@ -44,6 +44,7 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     subagent: z.ZodOptional<z.ZodString>;
     claudeUuid: z.ZodOptional<z.ZodString>;
     codexItemId: z.ZodOptional<z.ZodString>;
+    streamKey: z.ZodOptional<z.ZodString>;
     usage: z.ZodOptional<z.ZodObject<{
         input_tokens: z.ZodNumber;
         output_tokens: z.ZodNumber;
@@ -139,6 +140,35 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     }, z.core.$strip>], "t">;
 }, z.core.$strip>;
 type SessionEnvelope = z.infer<typeof sessionEnvelopeSchema>;
+declare const sessionStreamFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    t: z.ZodLiteral<"block-start">;
+    mid: z.ZodString;
+    idx: z.ZodNumber;
+    kind: z.ZodEnum<{
+        text: "text";
+        thinking: "thinking";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"block-delta">;
+    mid: z.ZodString;
+    idx: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"block-end">;
+    mid: z.ZodString;
+    idx: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"progress">;
+    thinkingTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<{
+        requesting: "requesting";
+        compacting: "compacting";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"turn-end">;
+}, z.core.$strip>], "t">;
+type SessionStreamFrame = z.infer<typeof sessionStreamFrameSchema>;
 
 /**
  * Simplified schema that only validates fields actually used in the codebase
@@ -901,6 +931,20 @@ declare class ApiSessionClient extends EventEmitter {
      * Send a ping message to keep the connection alive
      */
     keepAlive(thinking: boolean, mode: 'local' | 'remote'): void;
+    /**
+     * B-309: push one live stream frame (thinking/text delta or progress) to
+     * this account's web clients.
+     *
+     * Encrypted with the SESSION key and relayed without being stored —
+     * clipboard-push's shape, for clipboard-push's reasons: the relay must not
+     * be able to read thinking text, and the session id is stamped by the
+     * server from the authenticated connection rather than trusted from here.
+     *
+     * `volatile` on purpose. A draft that misses the wire while disconnected
+     * is worth nothing — the persisted message is still coming, and replaying
+     * stale deltas after a reconnect would paint text that has already landed.
+     */
+    sendStreamFrame(frame: SessionStreamFrame): void;
     /**
      * Send session death message
      */

package/dist/lib.d.mts

@@ -44,6 +44,7 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     subagent: z.ZodOptional<z.ZodString>;
     claudeUuid: z.ZodOptional<z.ZodString>;
     codexItemId: z.ZodOptional<z.ZodString>;
+    streamKey: z.ZodOptional<z.ZodString>;
     usage: z.ZodOptional<z.ZodObject<{
         input_tokens: z.ZodNumber;
         output_tokens: z.ZodNumber;
@@ -139,6 +140,35 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     }, z.core.$strip>], "t">;
 }, z.core.$strip>;
 type SessionEnvelope = z.infer<typeof sessionEnvelopeSchema>;
+declare const sessionStreamFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    t: z.ZodLiteral<"block-start">;
+    mid: z.ZodString;
+    idx: z.ZodNumber;
+    kind: z.ZodEnum<{
+        text: "text";
+        thinking: "thinking";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"block-delta">;
+    mid: z.ZodString;
+    idx: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"block-end">;
+    mid: z.ZodString;
+    idx: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"progress">;
+    thinkingTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<{
+        requesting: "requesting";
+        compacting: "compacting";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"turn-end">;
+}, z.core.$strip>], "t">;
+type SessionStreamFrame = z.infer<typeof sessionStreamFrameSchema>;
 
 /**
  * Simplified schema that only validates fields actually used in the codebase
@@ -901,6 +931,20 @@ declare class ApiSessionClient extends EventEmitter {
      * Send a ping message to keep the connection alive
      */
     keepAlive(thinking: boolean, mode: 'local' | 'remote'): void;
+    /**
+     * B-309: push one live stream frame (thinking/text delta or progress) to
+     * this account's web clients.
+     *
+     * Encrypted with the SESSION key and relayed without being stored —
+     * clipboard-push's shape, for clipboard-push's reasons: the relay must not
+     * be able to read thinking text, and the session id is stamped by the
+     * server from the authenticated connection rather than trusted from here.
+     *
+     * `volatile` on purpose. A draft that misses the wire while disconnected
+     * is worth nothing — the persisted message is still coming, and replaying
+     * stale deltas after a reconnect would paint text that has already landed.
+     */
+    sendStreamFrame(frame: SessionStreamFrame): void;
     /**
      * Send session death message
      */

package/dist/lib.mjs

@@ -1,4 +1,4 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-BdO0jg7G.mjs';
+export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-C5ewhu1Q.mjs';
 import 'axios';
 import 'chalk';
 import 'node:util';

package/dist/{mcp-Dr1PegOw.cjs → mcp-D0DIU8Q2.cjs}

@@ -3,9 +3,9 @@
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var z = require('zod');
-var index = require('./index-CvnMiYgh.cjs');
+var index = require('./index-BnRQP3PL.cjs');
 var limits = require('./limits-KdWKmwtH.cjs');
-var persistence = require('./types--t4zLibT.cjs');
+var persistence = require('./types-R11tMGyX.cjs');
 require('chalk');
 require('node:os');
 require('node:crypto');

package/dist/{mcp-BO9-sxMr.mjs → mcp-DD-0VkiA.mjs}

@@ -1,9 +1,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { p as pushClipboardViaDaemon } from './index-BW9kDx5m.mjs';
+import { p as pushClipboardViaDaemon } from './index-inkhalP5.mjs';
 import { C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, c as CLIPBOARD_MAX_BYTES } from './limits-CwFb5S2b.mjs';
-import { l as logger } from './types-BdO0jg7G.mjs';
+import { l as logger } from './types-C5ewhu1Q.mjs';
 import 'chalk';
 import 'node:os';
 import 'node:crypto';

package/dist/{runGemini-CuzqF6Ys.mjs → runGemini-DHyBDo5P.mjs}

@@ -2,10 +2,10 @@ import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
-import { l as logger, h as connectionState, A as ApiClient, j as readSettings, e as errorLogMetadata, k as encodeBase64, p as projectPath, d as contentLogMetadata } from './types-BdO0jg7G.mjs';
-import { v as GEMINI_API_KEY_ENV, x as GOOGLE_API_KEY_ENV, G as GEMINI_MODEL_ENV, B as BasePermissionHandler, y as BaseReasoningProcessor, g as initialMachineMetadata, h as createSessionMetadata, j as setupOfflineReconnection, n as notifyDaemonSessionStarted, k as MessageQueue2, m as hashObject, z as MessageBuffer, C as CHANGE_TITLE_INSTRUCTION, u as registerKillSessionHandler, o as startHappyServer } from './index-BW9kDx5m.mjs';
-import { A as AcpBackend } from './AcpBackend-DzZR7TEv.mjs';
-import { readGeminiLocalConfig, determineGeminiModel, getGeminiModelSource, getInitialGeminiModel, saveGeminiModelToConfig } from './config-CTyyVXHj.mjs';
+import { l as logger, h as connectionState, A as ApiClient, j as readSettings, e as errorLogMetadata, k as encodeBase64, p as projectPath, d as contentLogMetadata } from './types-C5ewhu1Q.mjs';
+import { x as GEMINI_API_KEY_ENV, y as GOOGLE_API_KEY_ENV, G as GEMINI_MODEL_ENV, B as BasePermissionHandler, z as BaseReasoningProcessor, h as initialMachineMetadata, j as createSessionMetadata, k as setupOfflineReconnection, n as notifyDaemonSessionStarted, m as MessageQueue2, o as hashObject, C as MessageBuffer, E as CHANGE_TITLE_INSTRUCTION, v as registerKillSessionHandler, u as startHappyServer } from './index-inkhalP5.mjs';
+import { A as AcpBackend } from './AcpBackend-DDEdYVW2.mjs';
+import { readGeminiLocalConfig, determineGeminiModel, getGeminiModelSource, getInitialGeminiModel, saveGeminiModelToConfig } from './config-B_L5vXXu.mjs';
 import 'axios';
 import 'chalk';
 import 'node:util';