happy-imou-cloud 2.1.4 → 2.1.6

package/dist/{index-D1BP-fEm.cjs → index-DA-K28E3.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chalk = require('chalk');
-var api = require('./api-B6ESNpGB.cjs');
-var persistence = require('./persistence-EDmI-c8T.cjs');
+var api = require('./api-CvtU4DI-.cjs');
+var persistence = require('./persistence-CKgPuZRR.cjs');
 var z = require('zod');
 var fs$2 = require('fs/promises');
 var os$1 = require('os');
@@ -72,7 +72,7 @@ async function openBrowser(url) {
   }
 }
 
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D1BP-fEm.cjs', document.baseURI).href)));
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DA-K28E3.cjs', document.baseURI).href)));
 const QRCode = require$1("qrcode-terminal/vendor/QRCode");
 const QRErrorCorrectLevel = require$1("qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel");
 const pendingTempFiles = /* @__PURE__ */ new Set();
@@ -695,7 +695,7 @@ function setupCleanupHandlers() {
   });
 }
 
-const __dirname$2 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D1BP-fEm.cjs', document.baseURI).href))));
+const __dirname$2 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DA-K28E3.cjs', document.baseURI).href))));
 function projectPath() {
   const path = path$1.resolve(__dirname$2, "..");
   return path;
@@ -2521,6 +2521,128 @@ async function runDaemonHealthCheck({
   await writeHeartbeat();
 }
 
+async function closeProviderSession(session, opts = {}) {
+  let firstError;
+  const captureError = (error) => {
+    if (firstError === void 0) {
+      firstError = error;
+    }
+  };
+  if (opts.archiveOnClose || opts.archiveReason) {
+    try {
+      session.updateMetadata((currentMetadata) => {
+        const { archiveReason: _existingArchiveReason, ...metadataWithoutArchiveReason } = currentMetadata;
+        return {
+          ...metadataWithoutArchiveReason,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: opts.archivedBy ?? "cli",
+          ...opts.archiveReason ? { archiveReason: opts.archiveReason } : {}
+        };
+      });
+    } catch (error) {
+      captureError(error);
+    }
+  }
+  try {
+    session.sendSessionDeath();
+  } catch (error) {
+    captureError(error);
+  }
+  try {
+    await session.flush();
+  } catch (error) {
+    captureError(error);
+  }
+  try {
+    await session.close();
+  } catch (error) {
+    captureError(error);
+  }
+  if (firstError !== void 0) {
+    throw firstError;
+  }
+}
+
+function createSessionMetadata(opts) {
+  const state = {
+    controlledByUser: false
+  };
+  const metadataPath = opts.path ?? process.cwd();
+  const metadataHostPid = opts.hostPid === void 0 ? process.pid : opts.hostPid;
+  const metadata = {
+    path: metadataPath,
+    host: os.hostname(),
+    version: api.packageJson.version,
+    os: os.platform(),
+    machineId: opts.machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: api.configuration.happyCloudHomeDir,
+    happyLibDir: projectPath(),
+    happyToolsDir: path.resolve(projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    startedBy: opts.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: opts.flavor,
+    ...metadataHostPid == null ? {} : { hostPid: metadataHostPid }
+  };
+  return { state, metadata };
+}
+
+async function archiveManagedSessionById(opts) {
+  try {
+    const sessionClient = opts.api.sessionSyncClient({ id: opts.sessionId });
+    await closeProviderSession(sessionClient, {
+      archiveReason: opts.archiveReason,
+      archivedBy: "daemon"
+    });
+  } catch (error) {
+    api.logger.debug(
+      `[DAEMON RUN] Failed to archive managed session ${opts.sessionId}: ${opts.archiveReason}`,
+      error
+    );
+  }
+}
+async function precreateDaemonManagedSession(opts) {
+  const { state, metadata } = createSessionMetadata({
+    flavor: opts.flavor,
+    machineId: opts.machineId,
+    startedBy: "daemon",
+    path: opts.directory,
+    hostPid: null
+  });
+  try {
+    return await opts.api.getOrCreateSession({
+      tag: opts.sessionTag,
+      metadata,
+      state
+    });
+  } catch (error) {
+    api.logger.debug(`[DAEMON RUN] Failed to precreate ${opts.flavor} session for tag ${opts.sessionTag}`, error);
+    return null;
+  }
+}
+async function archivePrecreatedManagedSession(opts) {
+  await archiveManagedSessionById({
+    api: opts.api,
+    sessionId: opts.session.id,
+    archiveReason: opts.archiveReason
+  });
+}
+async function archiveDetachedManagedSessionIfNeeded(opts) {
+  const { trackedSession } = opts;
+  if (trackedSession.startedBy !== "daemon" || !trackedSession.happySessionId || trackedSession.happySessionMetadataFromLocalWebhook) {
+    return false;
+  }
+  await archiveManagedSessionById({
+    api: opts.api,
+    sessionId: trackedSession.happySessionId,
+    archiveReason: opts.archiveReason
+  });
+  return true;
+}
+
 const NON_SESSION_PROCESS_TYPES$1 = /* @__PURE__ */ new Set([
   "current",
   "daemon",
@@ -2843,6 +2965,19 @@ async function recoverTrackedSessionsFromLocalRegistry({
   return { recoveredCount, removedStaleCount };
 }
 
+const HAPPY_MANAGED_SESSION_TAG_ENV = "HAPPY_MANAGED_SESSION_TAG";
+function readManagedSessionTag(env = process.env) {
+  const raw = env[HAPPY_MANAGED_SESSION_TAG_ENV];
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function resolveManagedSessionTag(env = process.env) {
+  return readManagedSessionTag(env) ?? node_crypto.randomUUID();
+}
+
 const DEFAULT_SESSION_WEBHOOK_TIMEOUT_MS = 45e3;
 function resolveSessionWebhookTimeoutMs() {
   const parsed = Number.parseInt(process.env.HAPPY_DAEMON_SESSION_WEBHOOK_TIMEOUT || "", 10);
@@ -2939,9 +3074,21 @@ async function startDaemon() {
     }
     const { credentials, machineId } = await authAndSetupMachineIfNeeded();
     api.logger.debug("[DAEMON RUN] Auth and machine setup complete");
+    let api$1 = null;
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const pidToAwaiter = /* @__PURE__ */ new Map();
     const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
+    const removeTrackedSession = (pid, archiveReason) => {
+      const trackedSession = pidToTrackedSession.get(pid);
+      if (trackedSession && api$1) {
+        void archiveDetachedManagedSessionIfNeeded({
+          api: api$1,
+          trackedSession,
+          archiveReason
+        });
+      }
+      pidToTrackedSession.delete(pid);
+    };
     const onHappySessionWebhook = (sessionId, sessionMetadata) => {
       api.logger.debugLargeJson(`[DAEMON RUN] Session reported`, sessionMetadata);
       const pid = sessionMetadata.hostPid;
@@ -2978,8 +3125,9 @@ async function startDaemon() {
     };
     const spawnSession = async (options) => {
       api.logger.debugLargeJson("[DAEMON RUN] Spawning session", options);
-      const { directory, sessionId, machineId: machineId2, approvedNewDirectoryCreation = true } = options;
+      const { directory, sessionId, machineId: _requestedMachineId, approvedNewDirectoryCreation = true } = options;
       let directoryCreated = false;
+      let precreatedCodexSession = null;
       try {
         await fs$2.access(directory);
         api.logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
@@ -3053,6 +3201,11 @@ async function startDaemon() {
         }
         let extraEnv = { ...profileEnv, ...authEnv };
         api.logger.debug(`[DAEMON RUN] Final environment variable keys (before expansion) (${Object.keys(extraEnv).length}): ${Object.keys(extraEnv).join(", ")}`);
+        const managedSessionTag = options.agent === "codex" ? node_crypto.randomUUID() : null;
+        if (managedSessionTag) {
+          extraEnv[HAPPY_MANAGED_SESSION_TAG_ENV] = managedSessionTag;
+          api.logger.debug(`[DAEMON RUN] Reserved managed Codex session tag ${managedSessionTag}`);
+        }
         extraEnv = expandEnvironmentVariables(extraEnv, process.env);
         api.logger.debug(`[DAEMON RUN] After variable expansion: ${Object.keys(extraEnv).join(", ")}`);
         const potentialAuthVars = ["ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "OPENAI_API_KEY", "CODEX_HOME", "AZURE_OPENAI_API_KEY", "TOGETHER_API_KEY"];
@@ -3091,6 +3244,18 @@ async function startDaemon() {
           const fullCommand = `node --no-warnings --no-deprecation ${cliPath} ${buildDaemonSpawnArgs(agent).join(" ")}`;
           const windowName = `happy-${Date.now()}-${agent}`;
           const tmuxEnv = buildDaemonChildEnv(process.env, extraEnv);
+          if (managedSessionTag && api$1) {
+            precreatedCodexSession = await precreateDaemonManagedSession({
+              api: api$1,
+              sessionTag: managedSessionTag,
+              machineId,
+              directory,
+              flavor: "codex"
+            });
+            if (precreatedCodexSession) {
+              api.logger.debug(`[DAEMON RUN] Precreated Codex session ${precreatedCodexSession.id} before tmux spawn`);
+            }
+          }
           const tmuxResult = await tmux.spawnInTmux([fullCommand], {
             sessionName: tmuxSessionName,
             windowName,
@@ -3103,6 +3268,7 @@ async function startDaemon() {
             }
             const trackedSession = {
               startedBy: "daemon",
+              happySessionId: precreatedCodexSession?.id,
               pid: tmuxResult.pid,
               // Real PID from tmux -P flag
               tmuxSessionId: tmuxResult.sessionId,
@@ -3110,6 +3276,13 @@ async function startDaemon() {
               message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.` : `Spawned new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.`
             };
             pidToTrackedSession.set(tmuxResult.pid, trackedSession);
+            if (precreatedCodexSession) {
+              api.logger.debug(`[DAEMON RUN] Returning precreated Codex session ${precreatedCodexSession.id} without waiting for webhook`);
+              return {
+                type: "success",
+                sessionId: precreatedCodexSession.id
+              };
+            }
             api.logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${tmuxResult.pid} (tmux)`);
             return new Promise((resolve) => {
               const timeout = setTimeout(() => {
@@ -3130,6 +3303,14 @@ async function startDaemon() {
               });
             });
           } else {
+            if (precreatedCodexSession && api$1) {
+              await archivePrecreatedManagedSession({
+                api: api$1,
+                session: precreatedCodexSession,
+                archiveReason: `tmux spawn failed before Codex session ${precreatedCodexSession.id} attached`
+              });
+              precreatedCodexSession = null;
+            }
             api.logger.debug(`[DAEMON RUN] Failed to spawn in tmux: ${tmuxResult.error}, falling back to regular spawning`);
             useTmux = false;
           }
@@ -3149,6 +3330,18 @@ async function startDaemon() {
               errorMessage: spawnError.errorMessage
             };
           }
+          if (managedSessionTag && api$1) {
+            precreatedCodexSession = await precreateDaemonManagedSession({
+              api: api$1,
+              sessionTag: managedSessionTag,
+              machineId,
+              directory,
+              flavor: "codex"
+            });
+            if (precreatedCodexSession) {
+              api.logger.debug(`[DAEMON RUN] Precreated Codex session ${precreatedCodexSession.id} before process spawn`);
+            }
+          }
           const happyProcess = spawnHappyCLI(args, {
             cwd: directory,
             detached: true,
@@ -3167,6 +3360,14 @@ async function startDaemon() {
           }
           if (!happyProcess.pid) {
             api.logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
+            if (precreatedCodexSession && api$1) {
+              await archivePrecreatedManagedSession({
+                api: api$1,
+                session: precreatedCodexSession,
+                archiveReason: `spawn produced no PID for precreated Codex session ${precreatedCodexSession.id}`
+              });
+              precreatedCodexSession = null;
+            }
             const spawnError = createSpawnSessionError(
               SPAWN_SESSION_ERROR_CODES.SPAWN_NO_PID,
               "Failed to spawn Happy process - no PID returned"
@@ -3179,6 +3380,7 @@ async function startDaemon() {
           api.logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
           const trackedSession = {
             startedBy: "daemon",
+            happySessionId: precreatedCodexSession?.id,
             pid: happyProcess.pid,
             childProcess: happyProcess,
             directoryCreated,
@@ -3197,6 +3399,13 @@ async function startDaemon() {
               onChildExited(happyProcess.pid);
             }
           });
+          if (precreatedCodexSession) {
+            api.logger.debug(`[DAEMON RUN] Returning precreated Codex session ${precreatedCodexSession.id} without waiting for webhook`);
+            return {
+              type: "success",
+              sessionId: precreatedCodexSession.id
+            };
+          }
           api.logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
           return new Promise((resolve) => {
             const timeout = setTimeout(() => {
@@ -3224,6 +3433,13 @@ async function startDaemon() {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         api.logger.debug("[DAEMON RUN] Failed to spawn session:", error);
+        if (precreatedCodexSession && api$1) {
+          await archivePrecreatedManagedSession({
+            api: api$1,
+            session: precreatedCodexSession,
+            archiveReason: `spawn failed before precreated Codex session ${precreatedCodexSession.id} attached: ${errorMessage}`
+          });
+        }
         const spawnError = createSpawnSessionError(
           SPAWN_SESSION_ERROR_CODES.SPAWN_FAILED,
           `Failed to spawn session: ${errorMessage}`
@@ -3253,7 +3469,7 @@ async function startDaemon() {
               api.logger.debug(`[DAEMON RUN] Failed to kill external session PID ${pid}:`, error);
             }
           }
-          pidToTrackedSession.delete(pid);
+          removeTrackedSession(pid, `session ${sessionId} was stopped from daemon control before local attachment completed`);
           api.logger.debug(`[DAEMON RUN] Removed session ${sessionId} from tracking`);
           return true;
         }
@@ -3275,7 +3491,7 @@ async function startDaemon() {
           errorMessage: spawnError.errorMessage
         });
       }
-      pidToTrackedSession.delete(pid);
+      removeTrackedSession(pid, `process ${pid} exited before the managed session fully attached`);
     };
     const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
       getChildren: getCurrentChildren,
@@ -3313,22 +3529,23 @@ async function startDaemon() {
       httpPort: controlPort,
       startedAt: Date.now()
     };
-    const api$1 = await api.ApiClient.create(credentials);
+    api$1 = await api.ApiClient.create(credentials);
+    const activeApi = api$1;
     let userScopedObserver = null;
     if (credentials.signing) {
       try {
-        userScopedObserver = api$1.userScopedObserverClient?.() ?? null;
+        userScopedObserver = activeApi.userScopedObserverClient?.() ?? null;
       } catch (error) {
         api.logger.debug("[DAEMON RUN] Failed to start user-scoped observer, continuing without it", error);
       }
     }
-    const machine = await api$1.getOrCreateMachine({
+    const machine = await activeApi.getOrCreateMachine({
       machineId,
       metadata: initialMachineMetadata,
       daemonState: initialDaemonState
     });
     api.logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
-    const apiMachine = api$1.machineSyncClient(machine);
+    const apiMachine = activeApi.machineSyncClient(machine);
     apiMachine.setRPCHandlers({
       spawnSession,
       stopSession,
@@ -3336,7 +3553,7 @@ async function startDaemon() {
     });
     const runRemoteSessionIndexRecovery = async (label) => {
       const recoveryResult = await recoverTrackedSessionsFromRemoteIndex({
-        api: api$1,
+        api: activeApi,
         machineId,
         trackedSessionPids: pidToTrackedSession.keys(),
         trackSession: (pid, trackedSession) => {
@@ -3392,7 +3609,7 @@ async function startDaemon() {
         await runDaemonHealthCheck({
           trackedSessionPids: pidToTrackedSession.keys(),
           removeTrackedSession: (pid) => {
-            pidToTrackedSession.delete(pid);
+            removeTrackedSession(pid, `health check removed stale tracked PID ${pid} before local attachment completed`);
           },
           currentCliVersion: api.configuration.currentCliVersion,
           onDaemonOutdated: async () => {
@@ -8265,7 +8482,7 @@ class AbortError extends Error {
   }
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D1BP-fEm.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DA-K28E3.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion() {
   try {
@@ -8387,6 +8604,7 @@ class Query {
   }
   pendingControlResponses = /* @__PURE__ */ new Map();
   cancelControllers = /* @__PURE__ */ new Map();
+  controlTasks = /* @__PURE__ */ new Set();
   sdkMessages;
   inputStream = new Stream();
   canCallTool;
@@ -8435,7 +8653,12 @@ class Query {
               }
               continue;
             } else if (message.type === "control_request") {
-              await this.handleControlRequest(message);
+              const controlTask = this.handleControlRequest(message).catch((error) => {
+                api.logger.debug("[ClaudeSDK] Failed to handle control request:", error);
+              }).finally(() => {
+                this.controlTasks.delete(controlTask);
+              });
+              this.controlTasks.add(controlTask);
               continue;
             } else if (message.type === "control_cancel_request") {
               this.handleControlCancelRequest(message);
@@ -8451,8 +8674,11 @@ class Query {
     } catch (error) {
       this.inputStream.error(error);
     } finally {
-      this.inputStream.done();
       this.cleanupControllers();
+      if (this.controlTasks.size > 0) {
+        await Promise.allSettled(Array.from(this.controlTasks));
+      }
+      this.inputStream.done();
       rl.close();
     }
   }
@@ -8517,7 +8743,7 @@ class Query {
           response
         }
       };
-      this.childStdin.write(JSON.stringify(controlResponse) + "\n");
+      this.writeControlResponse(controlResponse);
     } catch (error) {
       const controlErrorResponse = {
         type: "control_response",
@@ -8527,11 +8753,21 @@ class Query {
           error: error instanceof Error ? error.message : String(error)
         }
       };
-      this.childStdin.write(JSON.stringify(controlErrorResponse) + "\n");
+      this.writeControlResponse(controlErrorResponse);
     } finally {
       this.cancelControllers.delete(request.request_id);
     }
   }
+  writeControlResponse(response) {
+    if (!this.childStdin || this.childStdin.destroyed || !this.childStdin.writable) {
+      return;
+    }
+    try {
+      this.childStdin.write(JSON.stringify(response) + "\n");
+    } catch (error) {
+      api.logger.debug("[ClaudeSDK] Failed to write control response:", error);
+    }
+  }
   /**
    * Handle control cancel requests
    * Replicates the exact logic from the SDK's handleControlCancelRequest method
@@ -9516,11 +9752,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-DjnTGJGC.cjs'); });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-bAlUdUGw.cjs'); });
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-BHq7Rnq7.cjs'); });
+    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-CiIbJ1wa.cjs'); });
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -9529,7 +9765,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-hkZeOnA_.cjs'); });
+    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-BZJR84o-.cjs'); });
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -9605,7 +9841,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-DPLKOzMr.cjs'); });
+      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-UZr1nodh.cjs'); });
       console.log(renderRuntimeProviders());
       return;
     }
@@ -9783,8 +10019,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-EDmI-c8T.cjs'); });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-B6ESNpGB.cjs'); }).then(function (n) { return n.api; });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-CKgPuZRR.cjs'); });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-CvtU4DI-.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -10208,10 +10444,12 @@ exports.PushableAsyncIterable = PushableAsyncIterable;
 exports.RuntimeShell = RuntimeShell;
 exports.claudeCheckSession = claudeCheckSession;
 exports.claudeLocal = claudeLocal;
+exports.closeProviderSession = closeProviderSession;
 exports.createClaudeBackend = createClaudeBackend;
 exports.createCodexBackend = createCodexBackend;
 exports.createDefaultRuntimeShell = createDefaultRuntimeShell;
 exports.createGeminiBackend = createGeminiBackend;
+exports.createSessionMetadata = createSessionMetadata;
 exports.formatDisplayMessage = formatDisplayMessage;
 exports.getEnvironmentInfo = getEnvironmentInfo;
 exports.getInitialGeminiModel = getInitialGeminiModel;
@@ -10222,7 +10460,9 @@ exports.projectPath = projectPath;
 exports.publishSessionRegistration = publishSessionRegistration;
 exports.query = query;
 exports.readGeminiLocalConfig = readGeminiLocalConfig;
+exports.readManagedSessionTag = readManagedSessionTag;
 exports.resolveCanonicalToolNameV2 = resolveCanonicalToolNameV2;
+exports.resolveManagedSessionTag = resolveManagedSessionTag;
 exports.saveGeminiModelToConfig = saveGeminiModelToConfig;
 exports.startCaffeinate = startCaffeinate;
 exports.stopCaffeinate = stopCaffeinate;

package/dist/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
 require('chalk');
-require('./api-B6ESNpGB.cjs');
-require('./persistence-EDmI-c8T.cjs');
+require('./api-CvtU4DI-.cjs');
+require('./persistence-CKgPuZRR.cjs');
 require('zod');
-require('./index-D1BP-fEm.cjs');
+require('./index-DA-K28E3.cjs');
 require('node:child_process');
 require('node:fs');
 require('cross-spawn');

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import 'chalk';
-import './api-l8X03rs-.mjs';
-import './persistence-CyFjFOlN.mjs';
+import './api-DF9A136-.mjs';
+import './persistence-BsWBBi7E.mjs';
 import 'zod';
-import './index-D72RMo5Z.mjs';
+import './index-B5e-MA1d.mjs';
 import 'node:child_process';
 import 'node:fs';
 import 'cross-spawn';

package/dist/lib.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var api = require('./api-B6ESNpGB.cjs');
+var api = require('./api-CvtU4DI-.cjs');
 var types = require('./types-DVk3crez.cjs');
 require('axios');
 require('chalk');