happy-imou-cloud 2.1.7 → 2.1.9

package/dist/{api-CdGT5hsH.cjs → api-CfmTDha2.cjs}

@@ -18,7 +18,7 @@ var node_child_process = require('node:child_process');
 var expoServerSdk = require('expo-server-sdk');
 
 var name = "happy-imou-cloud";
-var version = "2.1.7";
+var version = "2.1.9";
 var description = "hicloud - Imou 企业定制版。关键是 happy！移动端远程 AI 编程工具，支持 Claude Code、Codex 和 Gemini CLI";
 var author = "long.zhu";
 var license = "MIT";
@@ -433,7 +433,7 @@ async function listDaemonLogFiles(limit = 50) {
       return { file, path: fullPath, modified: stats.mtime };
     }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
     try {
-      const { readDaemonState } = await Promise.resolve().then(function () { return require('./persistence-CMvrZ4SA.cjs'); });
+      const { readDaemonState } = await Promise.resolve().then(function () { return require('./persistence-Db4p7gsX.cjs'); });
       const state = await readDaemonState();
       if (!state) {
         return logs;
@@ -1734,8 +1734,8 @@ function buildSocketAuth(opts) {
   return auth;
 }
 
-const MAX_PENDING_RELIABLE_CODEX_MESSAGES = 200;
-const MAX_PENDING_RELIABLE_CODEX_MESSAGE_BYTES = 512 * 1024;
+const MAX_PENDING_RELIABLE_SESSION_MESSAGES = 200;
+const MAX_PENDING_RELIABLE_SESSION_MESSAGE_BYTES = 512 * 1024;
 const PROTOCOL_V3_INITIAL_SNAPSHOT_LIMIT = 150;
 const PROTOCOL_V3_CHANGES_PAGE_LIMIT = 200;
 const PROTOCOL_V3_CAPABILITIES_WAIT_MS = 250;
@@ -1754,8 +1754,8 @@ class ApiSessionClient extends node_events.EventEmitter {
   metadataLock = new AsyncLock();
   encryptionKey;
   encryptionVariant;
-  pendingReliableCodexMessages = [];
-  pendingReliableCodexMessageBytes = 0;
+  pendingReliableSessionMessages = [];
+  pendingReliableSessionMessageBytes = 0;
   reconnectAfterServerDisconnectTimer = null;
   lastSocketServerError = null;
   protocolV3SessionSync = null;
@@ -1784,7 +1784,14 @@ class ApiSessionClient extends node_events.EventEmitter {
       encryptionVariant: this.encryptionVariant,
       logger: (msg, data) => logger.debug(msg, data)
     });
-    registerCommonHandlers(this.rpcHandlerManager, this.metadata.path);
+    const workingDirectory = this.metadata?.path ?? process.cwd();
+    if (!this.metadata?.path) {
+      logger.debug("[API] Session metadata missing path during client initialization, falling back to process.cwd()", {
+        sessionId: this.sessionId,
+        workingDirectory
+      });
+    }
+    registerCommonHandlers(this.rpcHandlerManager, workingDirectory);
     this.socket = socket_ioClient.io(configuration.serverUrl, {
       auth: (cb) => cb(buildSocketAuth({
         credentials: this.credentials,
@@ -1805,7 +1812,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       this.clearReconnectAfterServerDisconnectTimer();
       this.lastSocketServerError = null;
       this.rpcHandlerManager.onSocketConnect(this.socket);
-      this.flushReliableCodexMessages();
+      this.flushReliableSessionMessages();
       this.protocolV3Descriptor = null;
       this.protocolV3SocketCapabilities = null;
       this.scheduleProtocolV3SessionSync();
@@ -1988,9 +1995,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     if (!this.socket.connected) {
       if (this.shouldBufferReliableCodexMessage(body)) {
         logger.debug("[API] Socket not connected, buffering reliable Codex message:", { type: eventType });
-        this.pendingReliableCodexMessages.push({ encrypted, type: eventType });
-        this.pendingReliableCodexMessageBytes += encrypted.length;
-        this.trimPendingReliableCodexMessages();
+        this.bufferReliableSessionMessage({ encrypted, type: `codex:${eventType}` });
       } else {
         logger.debug("[API] Socket not connected, dropping non-critical Codex message:", { type: eventType });
       }
@@ -2019,10 +2024,23 @@ class ApiSessionClient extends node_events.EventEmitter {
     };
     logger.debug(`[SOCKET] Sending ACP message from ${provider}:`, { type: body.type, hasMessage: "message" in body });
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
-    this.socket.emit("message", {
-      sid: this.sessionId,
-      message: encrypted
-    });
+    const eventType = typeof body?.type === "string" ? body.type : "unknown";
+    if (!this.socket.connected) {
+      if (this.shouldBufferReliableAcpMessage(body)) {
+        logger.debug("[API] Socket not connected, buffering reliable ACP message:", {
+          provider,
+          type: eventType
+        });
+        this.bufferReliableSessionMessage({ encrypted, type: `acp:${provider}:${eventType}` });
+      } else {
+        logger.debug("[API] Socket not connected, dropping non-critical ACP message:", {
+          provider,
+          type: eventType
+        });
+      }
+      return;
+    }
+    this.emitEncryptedSessionMessage(encrypted);
   }
   sendSessionEvent(event, id) {
     let content = {
@@ -2034,10 +2052,16 @@ class ApiSessionClient extends node_events.EventEmitter {
       }
     };
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
-    this.socket.emit("message", {
-      sid: this.sessionId,
-      message: encrypted
-    });
+    if (!this.socket.connected) {
+      if (this.shouldBufferReliableSessionEvent(event)) {
+        logger.debug("[API] Socket not connected, buffering session event:", { type: event.type });
+        this.bufferReliableSessionMessage({ encrypted, type: `event:${event.type}` });
+      } else {
+        logger.debug("[API] Socket not connected, dropping session event:", { type: event.type });
+      }
+      return;
+    }
+    this.emitEncryptedSessionMessage(encrypted);
   }
   /**
    * Send a ping message to keep the connection alive
@@ -2091,7 +2115,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    * @param handler - Handler function that returns the updated metadata
    */
   updateMetadata(handler) {
-    this.metadataLock.inLock(async () => {
+    void this.metadataLock.inLock(async () => {
       await backoff(async () => {
         let updated = handler(this.metadata);
         const sessionIndex = buildSessionRuntimeIndex(updated);
@@ -2114,6 +2138,8 @@ class ApiSessionClient extends node_events.EventEmitter {
           throw new Error("Metadata version mismatch");
         } else if (answer.result === "error") ;
       });
+    }).catch((error) => {
+      logger.debug("[API] Metadata update failed unexpectedly", error);
     });
   }
   /**
@@ -2122,7 +2148,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    */
   updateAgentState(handler) {
     logger.debugLargeJson("Updating agent state", this.agentState);
-    this.agentStateLock.inLock(async () => {
+    void this.agentStateLock.inLock(async () => {
       await backoff(async () => {
         let updated = handler(this.agentState || {});
         const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, updated)) : null });
@@ -2140,6 +2166,8 @@ class ApiSessionClient extends node_events.EventEmitter {
           throw new Error("Agent state version mismatch");
         } else if (answer.result === "error") ;
       });
+    }).catch((error) => {
+      logger.debug("[API] Agent state update failed unexpectedly", error);
     });
   }
   /**
@@ -2441,13 +2469,18 @@ class ApiSessionClient extends node_events.EventEmitter {
       message: encrypted
     });
   }
-  flushReliableCodexMessages() {
-    if (!this.socket.connected || this.pendingReliableCodexMessages.length === 0) {
+  bufferReliableSessionMessage(message) {
+    this.pendingReliableSessionMessages.push(message);
+    this.pendingReliableSessionMessageBytes += message.encrypted.length;
+    this.trimPendingReliableSessionMessages();
+  }
+  flushReliableSessionMessages() {
+    if (!this.socket.connected || this.pendingReliableSessionMessages.length === 0) {
       return;
     }
-    const buffered = this.pendingReliableCodexMessages.splice(0, this.pendingReliableCodexMessages.length);
-    this.pendingReliableCodexMessageBytes = 0;
-    logger.debug("[API] Flushing buffered Codex messages after reconnect", {
+    const buffered = this.pendingReliableSessionMessages.splice(0, this.pendingReliableSessionMessages.length);
+    this.pendingReliableSessionMessageBytes = 0;
+    logger.debug("[API] Flushing buffered session messages after reconnect", {
       count: buffered.length,
       types: buffered.map((message) => message.type)
     });
@@ -2471,21 +2504,49 @@ class ApiSessionClient extends node_events.EventEmitter {
         return false;
     }
   }
-  trimPendingReliableCodexMessages() {
+  shouldBufferReliableAcpMessage(body) {
+    switch (body?.type) {
+      case "message":
+      case "tool-call":
+      case "tool-result":
+      case "file-edit":
+      case "terminal-output":
+      case "task_started":
+      case "task_complete":
+      case "turn_aborted":
+      case "turn-report":
+      case "permission-request":
+        return true;
+      default:
+        return false;
+    }
+  }
+  shouldBufferReliableSessionEvent(event) {
+    switch (event.type) {
+      case "switch":
+      case "message":
+      case "permission-mode-changed":
+      case "ready":
+        return true;
+      default:
+        return false;
+    }
+  }
+  trimPendingReliableSessionMessages() {
     let dropped = 0;
-    while (this.pendingReliableCodexMessages.length > MAX_PENDING_RELIABLE_CODEX_MESSAGES || this.pendingReliableCodexMessageBytes > MAX_PENDING_RELIABLE_CODEX_MESSAGE_BYTES) {
-      const removed = this.pendingReliableCodexMessages.shift();
+    while (this.pendingReliableSessionMessages.length > MAX_PENDING_RELIABLE_SESSION_MESSAGES || this.pendingReliableSessionMessageBytes > MAX_PENDING_RELIABLE_SESSION_MESSAGE_BYTES) {
+      const removed = this.pendingReliableSessionMessages.shift();
       if (!removed) {
         break;
       }
-      this.pendingReliableCodexMessageBytes -= removed.encrypted.length;
+      this.pendingReliableSessionMessageBytes -= removed.encrypted.length;
       dropped += 1;
     }
     if (dropped > 0) {
-      logger.debug("[API] Dropped oldest buffered Codex messages to cap reconnect memory usage", {
+      logger.debug("[API] Dropped oldest buffered session messages to cap reconnect memory usage", {
         dropped,
-        remaining: this.pendingReliableCodexMessages.length,
-        bytes: this.pendingReliableCodexMessageBytes
+        remaining: this.pendingReliableSessionMessages.length,
+        bytes: this.pendingReliableSessionMessageBytes
       });
     }
   }
@@ -3205,6 +3266,39 @@ class OfflineState {
 }
 const connectionState = new OfflineState();
 
+async function hmac_sha512(key, data) {
+  const hmac = node_crypto.createHmac("sha512", key);
+  hmac.update(data);
+  return new Uint8Array(hmac.digest());
+}
+
+async function deriveSecretKeyTreeRoot(seed, usage) {
+  const I = await hmac_sha512(new TextEncoder().encode(usage + " Master Seed"), seed);
+  return {
+    key: I.slice(0, 32),
+    chainCode: I.slice(32)
+  };
+}
+async function deriveSecretKeyTreeChild(chainCode, index) {
+  const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+  const I = await hmac_sha512(chainCode, data);
+  return {
+    key: I.subarray(0, 32),
+    chainCode: I.subarray(32)
+  };
+}
+async function deriveKey(master, usage, path) {
+  let state = await deriveSecretKeyTreeRoot(master, usage);
+  let remaining = [...path];
+  while (remaining.length > 0) {
+    let index = remaining[0];
+    remaining = remaining.slice(1);
+    state = await deriveSecretKeyTreeChild(state.chainCode, index);
+  }
+  return state.key;
+}
+
+const SESSION_DATA_KEY_USAGE = "Happy Session Data Key";
 class ApiClient {
   static async create(credential) {
     return new ApiClient(credential);
@@ -3346,7 +3440,15 @@ class ApiClient {
     let encryptionKey;
     let encryptionVariant;
     if (this.credential.encryption.type === "dataKey") {
-      encryptionKey = getRandomBytes(32);
+      if (opts.stableDataKeyPath && opts.stableDataKeyPath.length > 0) {
+        encryptionKey = await deriveKey(
+          this.credential.encryption.machineKey,
+          SESSION_DATA_KEY_USAGE,
+          opts.stableDataKeyPath
+        );
+      } else {
+        encryptionKey = getRandomBytes(32);
+      }
       encryptionVariant = "dataKey";
       let encryptedDataKey = libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
       dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
@@ -3372,10 +3474,14 @@ class ApiClient {
       });
       logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
       let raw = response.data.session;
+      const metadata = decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata));
+      if (metadata === null) {
+        throw new Error(`Failed to decrypt session metadata for tag ${opts.tag}`);
+      }
       let session = {
         id: raw.id,
         seq: raw.seq,
-        metadata: decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata)),
+        metadata,
         metadataVersion: raw.metadataVersion,
         agentState: raw.agentState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.agentState)) : null,
         agentStateVersion: raw.agentStateVersion,

package/dist/{command-C1cKqmsa.mjs → command-B0HfYWYW.mjs}

@@ -1,6 +1,6 @@
-import { c as createDefaultRuntimeShell } from './index-BAhlFq45.mjs';
+import { c as createDefaultRuntimeShell } from './index-BKjWLXkN.mjs';
 import 'chalk';
-import './api-BYKV7vX6.mjs';
+import './api-CfHYTLZX.mjs';
 import 'axios';
 import 'fs';
 import 'node:fs';
@@ -16,7 +16,7 @@ import 'crypto';
 import 'path';
 import 'node:child_process';
 import 'expo-server-sdk';
-import './persistence-B8Wgn6aN.mjs';
+import './persistence-Nun5c360.mjs';
 import 'node:fs/promises';
 import 'os';
 import 'tmp';

package/dist/{command-uyA8cYmL.cjs → command-Bw2XKjA9.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var index = require('./index-D_S_7bqK.cjs');
+var index = require('./index-C3bSe5_d.cjs');
 require('chalk');
-require('./api-CdGT5hsH.cjs');
+require('./api-CfmTDha2.cjs');
 require('axios');
 require('fs');
 require('node:fs');
@@ -18,7 +18,7 @@ require('crypto');
 require('path');
 require('node:child_process');
 require('expo-server-sdk');
-require('./persistence-CMvrZ4SA.cjs');
+require('./persistence-Db4p7gsX.cjs');
 require('node:fs/promises');
 require('os');
 require('tmp');

package/dist/{index-BAhlFq45.mjs → index-BKjWLXkN.mjs}

@@ -1,6 +1,6 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, p as decodeBase64, q as HAPPY_CLOUD_DAEMON_PORT, r as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-BYKV7vX6.mjs';
-import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-B8Wgn6aN.mjs';
+import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, p as decodeBase64, q as HAPPY_CLOUD_DAEMON_PORT, r as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-CfHYTLZX.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-Nun5c360.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os$1, { homedir } from 'os';
@@ -2447,6 +2447,20 @@ function buildDaemonChildEnv(baseEnv, extraEnv) {
 }
 
 const DIFFERENT_DAEMON_RUNNING_MESSAGE = "A different daemon was started without killing us. We should kill ourselves.";
+function pruneStaleTrackedSessions({
+  trackedSessionPids,
+  removeTrackedSession,
+  kill = process.kill
+}) {
+  for (const pid of trackedSessionPids) {
+    try {
+      kill(pid, 0);
+    } catch {
+      logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
+      removeTrackedSession(pid);
+    }
+  }
+}
 function readProjectCliVersionFromDisk() {
   const packageJsonPath = join(projectPath(), "package.json");
   try {
@@ -2477,14 +2491,10 @@ async function runDaemonHealthCheck({
   requestShutdown,
   writeHeartbeat
 }) {
-  for (const pid of trackedSessionPids) {
-    try {
-      process.kill(pid, 0);
-    } catch {
-      logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
-      removeTrackedSession(pid);
-    }
-  }
+  pruneStaleTrackedSessions({
+    trackedSessionPids,
+    removeTrackedSession
+  });
   const projectVersion = readProjectCliVersion();
   if (projectVersion && projectVersion !== currentCliVersion) {
     await onDaemonOutdated();
@@ -2594,7 +2604,8 @@ async function precreateDaemonManagedSession(opts) {
     return await opts.api.getOrCreateSession({
       tag: opts.sessionTag,
       metadata,
-      state
+      state,
+      stableDataKeyPath: ["managed-session-tag", opts.sessionTag]
     });
   } catch (error) {
     logger.debug(`[DAEMON RUN] Failed to precreate ${opts.flavor} session for tag ${opts.sessionTag}`, error);
@@ -2956,7 +2967,42 @@ function resolveManagedSessionTag(env = process.env) {
   return readManagedSessionTag(env) ?? randomUUID();
 }
 
+const DEFAULT_MAX_LINES = 40;
+const DEFAULT_MAX_LINE_LENGTH = 300;
+function truncateLine(line, maxLineLength) {
+  if (line.length <= maxLineLength) {
+    return line;
+  }
+  return `${line.slice(0, Math.max(0, maxLineLength - 3))}...`;
+}
+function createChildProcessOutputBuffer(options) {
+  const maxLines = Math.max(1, DEFAULT_MAX_LINES);
+  const maxLineLength = Math.max(4, DEFAULT_MAX_LINE_LENGTH);
+  const lines = [];
+  return {
+    push(text) {
+      for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line) {
+          continue;
+        }
+        lines.push(truncateLine(line, maxLineLength));
+        while (lines.length > maxLines) {
+          lines.shift();
+        }
+      }
+    },
+    snapshot() {
+      return lines.join("\n");
+    },
+    hasContent() {
+      return lines.length > 0;
+    }
+  };
+}
+
 const DEFAULT_SESSION_WEBHOOK_TIMEOUT_MS = 45e3;
+const DEFAULT_TRACKED_SESSION_SWEEP_INTERVAL_MS = 5e3;
 function resolveSessionWebhookTimeoutMs() {
   const parsed = Number.parseInt(process.env.HAPPY_DAEMON_SESSION_WEBHOOK_TIMEOUT || "", 10);
   if (Number.isFinite(parsed) && parsed > 0) {
@@ -2964,6 +3010,13 @@ function resolveSessionWebhookTimeoutMs() {
   }
   return DEFAULT_SESSION_WEBHOOK_TIMEOUT_MS;
 }
+function resolveTrackedSessionSweepIntervalMs() {
+  const parsed = Number.parseInt(process.env.HAPPY_DAEMON_TRACKED_SESSION_SWEEP_INTERVAL || "", 10);
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return DEFAULT_TRACKED_SESSION_SWEEP_INTERVAL_MS;
+}
 const initialMachineMetadata = {
   host: os$1.hostname(),
   platform: os$1.platform(),
@@ -2994,6 +3047,7 @@ async function getProfileEnvironmentVariablesForAgent(profileId, agentType) {
 }
 async function startDaemon() {
   const sessionWebhookTimeoutMs = resolveSessionWebhookTimeoutMs();
+  const trackedSessionSweepIntervalMs = resolveTrackedSessionSweepIntervalMs();
   const shutdownCoordinator = createShutdownCoordinator(async () => {
     logger.debug("[DAEMON RUN] Startup malfunctioned, forcing exit with code 1");
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -3328,14 +3382,39 @@ async function startDaemon() {
             // Capture stdout/stderr for debugging
             env: buildDaemonChildEnv(process.env, extraEnv)
           });
-          if (process.env.DEBUG) {
-            happyProcess.stdout?.on("data", (data) => {
-              logger.debug(`[DAEMON RUN] Child stdout: ${data.toString()}`);
-            });
-            happyProcess.stderr?.on("data", (data) => {
-              logger.debug(`[DAEMON RUN] Child stderr: ${data.toString()}`);
-            });
-          }
+          const stdoutBuffer = createChildProcessOutputBuffer();
+          const stderrBuffer = createChildProcessOutputBuffer();
+          let childOutputSnapshotLogged = false;
+          const logChildOutputSnapshot = (reason) => {
+            if (childOutputSnapshotLogged) {
+              return;
+            }
+            childOutputSnapshotLogged = true;
+            const stdoutSnapshot = stdoutBuffer.snapshot();
+            const stderrSnapshot = stderrBuffer.snapshot();
+            if (stdoutSnapshot) {
+              logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} recent stdout before ${reason}:
+${stdoutSnapshot}`);
+            }
+            if (stderrSnapshot) {
+              logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} recent stderr before ${reason}:
+${stderrSnapshot}`);
+            }
+          };
+          happyProcess.stdout?.on("data", (data) => {
+            const text = data.toString();
+            stdoutBuffer.push(text);
+            if (process.env.DEBUG) {
+              logger.debug(`[DAEMON RUN] Child stdout: ${text}`);
+            }
+          });
+          happyProcess.stderr?.on("data", (data) => {
+            const text = data.toString();
+            stderrBuffer.push(text);
+            if (process.env.DEBUG) {
+              logger.debug(`[DAEMON RUN] Child stderr: ${text}`);
+            }
+          });
           if (!happyProcess.pid) {
             logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
             if (precreatedCodexSession && api) {
@@ -3366,12 +3445,14 @@ async function startDaemon() {
           };
           pidToTrackedSession.set(happyProcess.pid, trackedSession);
           happyProcess.on("exit", (code, signal) => {
+            logChildOutputSnapshot(`exit (code=${code}, signal=${signal})`);
             logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
             if (happyProcess.pid) {
               onChildExited(happyProcess.pid);
             }
           });
           happyProcess.on("error", (error) => {
+            logChildOutputSnapshot("process error");
             logger.debug(`[DAEMON RUN] Child process error:`, error);
             if (happyProcess.pid) {
               onChildExited(happyProcess.pid);
@@ -3388,6 +3469,7 @@ async function startDaemon() {
           return new Promise((resolve) => {
             const timeout = setTimeout(() => {
               pidToAwaiter.delete(happyProcess.pid);
+              logChildOutputSnapshot("session webhook timeout");
               logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
               const spawnError = createSpawnSessionError(
                 SPAWN_SESSION_ERROR_CODES.SESSION_WEBHOOK_TIMEOUT,
@@ -3572,6 +3654,25 @@ async function startDaemon() {
       logger.debug("[DAEMON RUN] Remote session index startup recovery failed", error);
     });
     const heartbeatIntervalMs = parseInt(process.env.HAPPY_DAEMON_HEARTBEAT_INTERVAL || "60000");
+    let trackedSessionSweepRunning = false;
+    const trackedSessionSweepInterval = setInterval(() => {
+      if (trackedSessionSweepRunning) {
+        return;
+      }
+      trackedSessionSweepRunning = true;
+      try {
+        pruneStaleTrackedSessions({
+          trackedSessionPids: pidToTrackedSession.keys(),
+          removeTrackedSession: (pid) => {
+            removeTrackedSession(pid, `fast stale-session sweep removed tracked PID ${pid}`);
+          }
+        });
+      } catch (error) {
+        logger.debug("[DAEMON RUN] Fast tracked-session sweep failed", error);
+      } finally {
+        trackedSessionSweepRunning = false;
+      }
+    }, trackedSessionSweepIntervalMs);
     let heartbeatRunning = false;
     const restartOnStaleVersionAndHeartbeat = setInterval(async () => {
       if (heartbeatRunning) {
@@ -3643,6 +3744,7 @@ async function startDaemon() {
         clearInterval(restartOnStaleVersionAndHeartbeat);
         logger.debug("[DAEMON RUN] Health check interval cleared");
       }
+      clearInterval(trackedSessionSweepInterval);
       if (remoteSessionIndexRefreshTimer) {
         clearTimeout(remoteSessionIndexRefreshTimer);
         remoteSessionIndexRefreshTimer = null;
@@ -7567,7 +7669,14 @@ ${recentStderrExcerpt}`);
         prompt: [contentBlock]
       };
       logger.debug(`[AcpBackend] Prompt request:`, JSON.stringify(promptRequest, null, 2));
-      await this.connection.prompt(promptRequest);
+      await raceWithProcessExit(
+        this.process,
+        this.connection.prompt(promptRequest),
+        {
+          agentName: this.transport.agentName,
+          operationName: "prompt"
+        }
+      );
       logger.debug("[AcpBackend] Prompt request sent to ACP connection");
       if (this.waitingForResponse && this.activeToolCalls.size === 0 && this.sawSessionUpdateSincePrompt === false) {
         const noUpdatesTimeoutMs = this.getPostPromptNoUpdatesTimeoutMs();
@@ -9730,11 +9839,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await import('./runClaude-WB884iOO.mjs');
+    const { runClaude } = await import('./runClaude-ClXU2LZA.mjs');
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-MJar-238.mjs');
+    const { runCodex } = await import('./runCodex-CXu7_Wgk.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -9743,7 +9852,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-BPGpwljp.mjs');
+    const { runGemini } = await import('./runGemini-BlJjRWN1.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -9756,13 +9865,17 @@ const unifiedProviderExecutors = {
     });
   }
 };
-async function ensureUnifiedRuntimePrerequisites(credentials) {
+async function ensureUnifiedRuntimePrerequisites(credentials, opts) {
   if (credentials) {
-    await ensureUnifiedDaemonStarted();
+    if (!opts?.skipDaemonBootstrap) {
+      await ensureUnifiedDaemonStarted();
+    }
     return credentials;
   }
   const auth = await authAndSetupMachineIfNeeded();
-  await ensureUnifiedDaemonStarted();
+  if (!opts?.skipDaemonBootstrap) {
+    await ensureUnifiedDaemonStarted();
+  }
   return auth.credentials;
 }
 async function ensureUnifiedDaemonStarted() {
@@ -9783,7 +9896,10 @@ async function ensureUnifiedDaemonStarted() {
   throw new Error("Failed to start Happy background service.");
 }
 async function executeUnifiedProvider(opts) {
-  const credentials = await ensureUnifiedRuntimePrerequisites(opts.credentials);
+  const skipDaemonBootstrap = "startedBy" in opts && opts.startedBy === "daemon" || opts.provider === "claude" && opts.claudeOptions?.startedBy === "daemon";
+  const credentials = await ensureUnifiedRuntimePrerequisites(opts.credentials, {
+    skipDaemonBootstrap
+  });
   await unifiedProviderExecutors[opts.provider]({
     ...opts,
     credentials
@@ -9819,7 +9935,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-C1cKqmsa.mjs');
+      const { renderRuntimeProviders } = await import('./command-B0HfYWYW.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -9997,8 +10113,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-B8Wgn6aN.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-BYKV7vX6.mjs').then(function (n) { return n.v; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-Nun5c360.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-CfHYTLZX.mjs').then(function (n) { return n.v; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();