very-happy-cli 0.2.89 → 0.2.91

package/dist/{index-vCgb7QnZ.mjs → index-UCYD5Wk3.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 } from 'node:os';
 import { randomUUID, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { n as readDaemonState, l as logger, c as configuration, o as clearDaemonState, q as getProjectPath, p as projectPath, s as initializeSandbox, t as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, u as AsyncLock, v as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, x as hardenPrivateFile, f as packageJson, i as readSettings, y as readCredentials, z as credentialRelayProblem, B as deriveLocalCliUpdateSummary, j as encodeBase64, C as updateSettings, D as encodeBase64Url, E as decodeBase64, F as writeCredentialsLegacy, G as writeCredentialsDataKey, H as readCredentialsForConfiguredRelay, J as encrypt, r as readPersistedSessions, K as getLocalHappyAgentCredentialPath, L as readLocalHappyAgentCredentials, N as decryptWithDataKey, O as decryptLegacy, P as extractCompleteLines, Q as decideBackfill, S as parseTerminalHookPayload, T as decideMirrorBinding, U as persistSession, V as MIRROR_BACKFILL_LINES_DEFAULT, W as mirrorLineKey, X as mirrorLocalId, Y as detectResumeSupport, Z as detectCLIAvailability, _ as acquireDaemonLock, $ as summarizeSpawnSessionForLog, a0 as deletePersistedSessions, a1 as decrypt, a2 as writeDaemonState, A as ApiClient, a3 as fetchCliUpdateState, a4 as resolveCliUpdateCheckInterval, a5 as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, a6 as releaseDaemonLock, a7 as isValidSessionId, a8 as listVhTerminals, a9 as isValidTerminalId, aa as readVhTerminal, ab as sendToVhTerminal, h as connectionState, ac as startOfflineReconnection, ad as clearCredentials, ae as clearMachineId, k as ensurePrivateDirectorySync, w as writePrivateFileSync, af as SandboxConfigSchema, b as createEnvelope, ag as CodexAppServerClient, ah as getLatestDaemonLog } from './types-d_104eQF.mjs';
+import { n as readDaemonState, l as logger, c as configuration, o as clearDaemonState, q as getProjectPath, p as projectPath, s as initializeSandbox, t as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, u as AsyncLock, v as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, x as hardenPrivateFile, f as packageJson, i as readSettings, y as readCredentials, z as credentialRelayProblem, B as deriveLocalCliUpdateSummary, j as encodeBase64, C as updateSettings, D as encodeBase64Url, E as decodeBase64, F as writeCredentialsLegacy, G as writeCredentialsDataKey, H as readCredentialsForConfiguredRelay, J as encrypt, r as readPersistedSessions, K as getLocalHappyAgentCredentialPath, L as readLocalHappyAgentCredentials, N as decryptWithDataKey, O as decryptLegacy, P as extractCompleteLines, Q as decideBackfill, S as parseTerminalHookPayload, T as tmuxArgs, U as scrubTmuxClientEnv, V as decideMirrorBinding, W as persistSession, X as MIRROR_BACKFILL_LINES_DEFAULT, Y as mirrorLineKey, Z as mirrorLocalId, _ as detectResumeSupport, $ as detectCLIAvailability, a0 as acquireDaemonLock, a1 as summarizeSpawnSessionForLog, a2 as deletePersistedSessions, a3 as decrypt, a4 as writeDaemonState, A as ApiClient, a5 as fetchCliUpdateState, a6 as resolveCliUpdateCheckInterval, a7 as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, a8 as releaseDaemonLock, a9 as isValidSessionId, aa as listVhTerminals, ab as isValidTerminalId, ac as readVhTerminal, ad as sendToVhTerminal, h as connectionState, ae as startOfflineReconnection, af as clearCredentials, ag as clearMachineId, k as ensurePrivateDirectorySync, w as writePrivateFileSync, ah as SandboxConfigSchema, b as createEnvelope, ai as CodexAppServerClient, aj as getLatestDaemonLog } from './types-BKyjG23_.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, isAbsolute, normalize, sep, dirname } from 'node:path';
 import { createInterface } from 'node:readline';
@@ -1633,6 +1633,12 @@ function resolveRemoteClaudePermissionMode(currentMode, incomingMode, sandboxEna
   }
   return nextMode;
 }
+function reconcilePublishedPermissionMode(input) {
+  if (!input.effective) return null;
+  const mismatch = input.effective !== input.intent;
+  if (input.effective === input.published) return mismatch ? { publish: input.effective, mismatch } : null;
+  return { publish: input.effective, mismatch };
+}
 
 function parseCompact(message) {
   const trimmed = message.trim();
@@ -1962,7 +1968,12 @@ async function claudeRemote(opts) {
             mcpServers: systemInit.mcp_servers?.map((s) => ({ name: s.name, status: s.status })),
             skills: systemInit.skills,
             model: systemInit.model,
-            modelIsDefault: initial.mode.model == null
+            modelIsDefault: initial.mode.model == null,
+            // The SDK's own verdict on the mode it will enforce —
+            // settings (permissions.deny/ask/defaultMode/
+            // disableBypassPermissionsMode) can override what we
+            // asked for. runClaude publishes THIS, not our intent.
+            permissionMode: systemInit.permissionMode
           });
         }
         if (systemInit.session_id) {
@@ -1980,6 +1991,10 @@ async function claudeRemote(opts) {
       if (message.type === "result") {
         updateThinking(false);
         logger.debug("[claudeRemote] Result received");
+        const denials = message.permission_denials;
+        if (denials && denials.length > 0) {
+          logger.warn(`[claudeRemote] ${denials.length} tool call(s) auto-denied by Claude Code policy: ${denials.map((d) => d.tool_name ?? "?").join(", ")}`);
+        }
         if (isCompactCommand) {
           const compactSucceeded = message.subtype === "success";
           logger.debug(`[claudeRemote] Compaction ${compactSucceeded ? "completed" : "failed"}`);
@@ -2065,6 +2080,8 @@ class PermissionHandler {
   setPermissionModeCallback;
   modeChangeQueue = Promise.resolve();
   deferredPermissionMode;
+  /** Fired when an approval response (plan approval / approve-with-mode) moved the mode. */
+  onModeChangedCallback;
   constructor(session) {
     this.session = session;
     this.setupClientHandler();
@@ -2078,6 +2095,18 @@ class PermissionHandler {
   handleModeChange(mode) {
     this.permissionMode = mapToClaudeMode(mode);
   }
+  /** Current locally enforced mode (what canUseTool applies right now). */
+  getPermissionMode() {
+    return this.permissionMode;
+  }
+  /**
+   * Observe mode transitions that originate inside the approval flow
+   * (ExitPlanMode approval, approve-with-mode). Live/idle RPC changes and
+   * queue-driven changes are owned by the launcher and do not fire this.
+   */
+  setOnModeChanged(callback) {
+    this.onModeChangedCallback = callback;
+  }
   /**
    * Set callback to dynamically change permission mode on the active query.
    * Called by claudeRemote after the Query object is created.
@@ -2166,24 +2195,19 @@ class PermissionHandler {
         updatedInput: contentLogMetadata(response.updatedInput)
       });
       if (response.approved) {
-        const newMode = response.mode && ["default", "acceptEdits", "bypassPermissions"].includes(response.mode) ? response.mode : "default";
+        const newMode = response.mode && ["default", "acceptEdits", "bypassPermissions"].includes(response.mode) ? response.mode : "bypassPermissions";
         logger.debug(`Plan approved - allowing ExitPlanMode with ${newMode} as the local follow-up mode`);
         this.permissionMode = newMode;
+        this.onModeChangedCallback?.(newMode);
         pending.resolve({ behavior: "allow", updatedInput: pending.input || {} });
       } else {
         pending.resolve({ behavior: "deny", message: response.reason || "Plan rejected" });
       }
     } else {
       if (response.approved && response.mode) {
-        try {
-          if (!this.setPermissionModeCallback) throw new Error("permission mode updater unavailable");
-          await this.setPermissionModeCallback(response.mode);
-          this.permissionMode = response.mode;
-        } catch (err) {
-          const reason = `Failed to switch permission mode: ${err instanceof Error ? err.message : String(err)}`;
-          pending.resolve({ behavior: "deny", message: reason });
-          return { ...response, approved: false, reason };
-        }
+        this.permissionMode = response.mode;
+        this.deferredPermissionMode = response.mode;
+        this.onModeChangedCallback?.(response.mode);
       }
       if (response.approved && !pending.suggestions?.length && response.allowTools?.length) {
         response.allowTools.forEach((tool) => {
@@ -2524,6 +2548,17 @@ class PermissionHandler {
   }
 }
 
+function rewriteQueuedPermissionMode(queue, hasher, permissionMode) {
+  let rewritten = 0;
+  for (const item of queue) {
+    if (item.mode.permissionMode === permissionMode) continue;
+    item.mode = { ...item.mode, permissionMode };
+    item.modeHash = hasher(item.mode);
+    rewritten += 1;
+  }
+  return rewritten;
+}
+
 function formatClaudeMessageForInk(message, messageBuffer, onAssistantResult) {
   logger.debugLargeJson("[CLAUDE INK] Message from remote mode:", message);
   switch (message.type) {
@@ -2778,7 +2813,13 @@ class SDKToLogConverter {
           type: "user",
           message: userMsg.message,
           ...userMsg.parent_tool_use_id ? { parent_tool_use_id: userMsg.parent_tool_use_id } : {},
-          ...meta ? { isMeta: true } : {}
+          ...meta ? { isMeta: true } : {},
+          // B-260-P2: structured tool output (Agent/Task final report +
+          // run totals, or the `async_launched` stub marker) and the
+          // message origin (task-notification). Both are consumed by
+          // sessionProtocolMapper; the raw-line schema is passthrough.
+          ...userMsg.tool_use_result !== void 0 ? { tool_use_result: userMsg.tool_use_result } : {},
+          ...userMsg.origin ? { origin: userMsg.origin } : {}
         };
         if (Array.isArray(userMsg.message.content)) {
           for (const content of userMsg.message.content) {
@@ -3289,7 +3330,7 @@ function createTurnSteeringController() {
   };
 }
 
-async function claudeRemoteLauncher(session, onPermissionModeChange) {
+async function claudeRemoteLauncher(session, onPermissionModeChange, onEffectivePermissionMode) {
   logger.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
@@ -3351,16 +3392,23 @@ async function claudeRemoteLauncher(session, onPermissionModeChange) {
   });
   session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
   let livePermissionModeHandler = null;
+  let idlePermissionModeHandler = null;
   session.client.rpcHandlerManager.registerHandler(
     "set-permission-mode",
     async (request) => {
       const requestedMode = parseClaudePermissionMode(request?.mode);
       if (!requestedMode) throw new Error("Invalid Claude permission mode");
-      if (!livePermissionModeHandler) throw new Error("No active Claude query");
-      return { mode: await livePermissionModeHandler(requestedMode) };
+      if (livePermissionModeHandler) return { mode: await livePermissionModeHandler(requestedMode) };
+      if (idlePermissionModeHandler) return { mode: idlePermissionModeHandler(requestedMode) };
+      throw new Error("No active Claude query");
     }
   );
   const permissionHandler = new PermissionHandler(session);
+  idlePermissionModeHandler = (nextMode) => {
+    permissionHandler.handleModeChange(nextMode);
+    onPermissionModeChange?.(nextMode);
+    return nextMode;
+  };
   permissionHandler.reset("Previous CLI process exited before responding");
   const messageQueue = new OutgoingMessageQueue(
     (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
@@ -3510,6 +3558,23 @@ async function claudeRemoteLauncher(session, onPermissionModeChange) {
       abortFuture = new Future();
       let modeHash = null;
       let mode = null;
+      const commitPermissionMode = (nextMode) => {
+        permissionHandler.handleModeChange(nextMode);
+        if (mode) {
+          mode = { ...mode, permissionMode: nextMode };
+          modeHash = session.queue.modeHasher(mode);
+        }
+        rewriteQueuedPermissionMode(session.queue.queue, session.queue.modeHasher, nextMode);
+        if (pending) {
+          pending = { ...pending, mode: { ...pending.mode, permissionMode: nextMode } };
+        }
+        onPermissionModeChange?.(nextMode);
+        return nextMode;
+      };
+      idlePermissionModeHandler = commitPermissionMode;
+      permissionHandler.setOnModeChanged((nextMode) => {
+        commitPermissionMode(nextMode);
+      });
       try {
         const attachmentDirectory = chatAttachmentDirectory(configuration.happyHomeDir, session.client.sessionId);
         await ensurePrivateDirectory(attachmentDirectory);
@@ -3575,6 +3640,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange) {
               skillCount: metadata.skills?.length ?? 0
             });
             session.client.updateMetadata((currentMetadata) => applyClaudeSdkMetadata(currentMetadata, metadata));
+            if (metadata.permissionMode) onEffectivePermissionMode?.(metadata.permissionMode);
           },
           onQueryReady: (q) => {
             turnSteering.setInterrupt(q.interrupt);
@@ -3752,7 +3818,7 @@ async function loop(opts) {
         break;
       }
       case "remote": {
-        const reason = await claudeRemoteLauncher(session, opts.onPermissionModeChange);
+        const reason = await claudeRemoteLauncher(session, opts.onPermissionModeChange, opts.onEffectivePermissionMode);
         switch (reason) {
           case "exit":
             return 0;
@@ -6614,7 +6680,7 @@ function createMirrorManager(deps) {
   let chain = Promise.resolve();
   const isTerminalAlive = deps.isTerminalAlive ?? ((terminalId) => {
     try {
-      return spawnSync("tmux", ["has-session", "-t", `=vh-${terminalId}:`], { stdio: "ignore", timeout: 3e3 }).status === 0;
+      return spawnSync("tmux", tmuxArgs(["has-session", "-t", `=vh-${terminalId}:`]), { stdio: "ignore", timeout: 3e3, env: scrubTmuxClientEnv({ ...process.env }) }).status === 0;
     } catch {
       return false;
     }
@@ -9242,7 +9308,10 @@ async function runClaude(credentials, options = {}) {
     // a brand-new session cannot pick a PDF until after sending once.
     attachmentKinds: [...CLAUDE_ATTACHMENT_KINDS],
     queueCancellation: true,
-    capabilities: ["claude-steer-v1", "claude-live-permission-v1"],
+    capabilities: ["claude-steer-v1", "claude-live-permission-v1", "claude-live-permission-v2"],
+    // Effective mode this process enforces. Kept current by
+    // publishPermissionMode below; the web renders it instead of guessing.
+    permissionMode: mapToClaudeMode(initialPermissionMode ?? "default"),
     sandbox: sandboxConfig?.enabled ? sandboxConfig : null,
     dangerouslySkipPermissions,
     ...forkedFromSessionId ? { parentSessionId: forkedFromSessionId } : {},
@@ -9347,7 +9416,11 @@ async function runClaude(credentials, options = {}) {
       ...meta,
       lifecycleState: "running",
       archivedBy: void 0,
-      queueCancellation: true
+      queueCancellation: true,
+      // B-262 batch 2 (B5): a reconnected process re-publishes the mode
+      // IT enforces; the server copy may still carry the previous
+      // process's value.
+      permissionMode: mapToClaudeMode(initialPermissionMode ?? "default")
     }));
   }
   const forkClaudeSessionId = process.env.HAPPY_FORK_CLAUDE_SESSION_ID;
@@ -9479,6 +9552,30 @@ async function runClaude(credentials, options = {}) {
     )
   }));
   let currentPermissionMode = initialPermissionMode;
+  let publishedPermissionMode = mapToClaudeMode(initialPermissionMode ?? "default");
+  const publishPermissionMode = (mode) => {
+    currentPermissionMode = mode;
+    const published = mapToClaudeMode(mode ?? "default");
+    if (published === publishedPermissionMode) return;
+    publishedPermissionMode = published;
+    session.updateMetadata((meta) => ({ ...meta, permissionMode: published }));
+  };
+  const publishEffectivePermissionMode = (effective) => {
+    const decision = reconcilePublishedPermissionMode({
+      intent: mapToClaudeMode(currentPermissionMode ?? "default"),
+      published: publishedPermissionMode,
+      effective
+    });
+    if (!decision) return;
+    if (decision.mismatch) {
+      logger.warn(`[loop] Claude Code enforces permission mode '${effective}' but this process asked for '${mapToClaudeMode(currentPermissionMode ?? "default")}' \u2014 check ~/.claude settings (permissions.deny/ask/defaultMode/disableBypassPermissionsMode). Publishing the effective mode.`);
+    }
+    if (decision.publish !== publishedPermissionMode) {
+      publishedPermissionMode = decision.publish;
+      session.updateMetadata((meta) => ({ ...meta, permissionMode: decision.publish }));
+    }
+  };
+  let lastExplicitModeSwitchAt = 0;
   let currentModel = options.model ?? DEFAULT_CLAUDE_MODEL;
   let currentFallbackModel = void 0;
   let currentCustomSystemPrompt = void 0;
@@ -9487,7 +9584,6 @@ async function runClaude(credentials, options = {}) {
   let currentDisallowedTools = withAssistantDenylist(void 0, isAssistantVariant);
   let currentEffort = DEFAULT_CLAUDE_EFFORT;
   const resetCurrentModeDefaults = () => {
-    currentPermissionMode = initialPermissionMode;
     currentModel = options.model ?? DEFAULT_CLAUDE_MODEL;
     currentFallbackModel = void 0;
     currentCustomSystemPrompt = void 0;
@@ -9524,14 +9620,18 @@ async function runClaude(credentials, options = {}) {
     }
     const attachmentsForThisMessage = await session.drainAttachmentsForUserMessage();
     let messagePermissionMode = currentPermissionMode;
-    if (message.meta?.permissionMode) {
+    const messageCreatedAt = message.createdAt;
+    const staleModeSnapshot = message.meta?.permissionMode !== void 0 && typeof messageCreatedAt === "number" && messageCreatedAt < lastExplicitModeSwitchAt;
+    if (staleModeSnapshot) {
+      logger.debug(`[loop] Ignoring stale meta.permissionMode=${message.meta?.permissionMode} (message ${messageCreatedAt} predates explicit switch ${lastExplicitModeSwitchAt}); keeping ${currentPermissionMode}`);
+    } else if (message.meta?.permissionMode) {
       const previousPermissionMode = currentPermissionMode;
       messagePermissionMode = resolveRemoteClaudePermissionMode(
         currentPermissionMode,
         message.meta.permissionMode,
         sandboxEnabled
       );
-      currentPermissionMode = messagePermissionMode;
+      publishPermissionMode(messagePermissionMode);
       const ignoredDefaultDowngrade = (previousPermissionMode === "bypassPermissions" || previousPermissionMode === "yolo") && message.meta.permissionMode === "default" && currentPermissionMode === previousPermissionMode;
       if (ignoredDefaultDowngrade) {
         logger.debug(`[loop] Ignoring permission mode downgrade from ${previousPermissionMode} to default`);
@@ -9788,9 +9888,11 @@ async function runClaude(credentials, options = {}) {
     },
     onAbort: resetCurrentModeDefaults,
     onPermissionModeChange: (mode) => {
-      currentPermissionMode = mode;
-      logger.debug(`[loop] Permission mode updated from live session RPC to: ${mode}`);
+      lastExplicitModeSwitchAt = Date.now();
+      publishPermissionMode(mode);
+      logger.debug(`[loop] Permission mode updated from session RPC / approval to: ${mode}`);
     },
+    onEffectivePermissionMode: (mode) => publishEffectivePermissionMode(mode),
     mcpServers: {
       "happy": {
         type: "http",
@@ -13547,7 +13649,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-C7JS6CBM.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-TkkGzzbI.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -13564,7 +13666,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-Dx_xnLlg.mjs');
+      const { handleSpawnCommand } = await import('./spawn-CRW4ioms.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13576,7 +13678,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-M2ax7UGy.mjs');
+      const { handleSendCommand } = await import('./send-9nJxn09Y.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13682,9 +13784,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-CdoGLla8.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-d_104eQF.mjs').then(function (n) { return n.ai; });
-        const { ApiClient: ApiClient2 } = await import('./types-d_104eQF.mjs').then(function (n) { return n.aj; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-ra8iKxdU.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-BKyjG23_.mjs').then(function (n) { return n.ak; });
+        const { ApiClient: ApiClient2 } = await import('./types-BKyjG23_.mjs').then(function (n) { return n.al; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -13715,7 +13817,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-CdoGLla8.mjs');
+        const { readGeminiLocalConfig } = await import('./config-ra8iKxdU.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -13755,7 +13857,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-B3iv1QRL.mjs');
+      const { runGemini } = await import('./runGemini-BbC0uwUj.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -13777,7 +13879,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-BP2wylez.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-CB5H7YI6.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -13817,7 +13919,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-CmM4ZLYi.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw--nbqTW3K.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -13868,7 +13970,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-B3EgenZh.mjs');
+      const { handleMcpCommand } = await import('./mcp-C3MiqObi.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 require('chalk');
-require('./index-DYDAFqAN.cjs');
-require('./types-DLI6sss2.cjs');
+require('./index-FkXJNwiy.cjs');
+require('./types-ClDADuxP.cjs');
 require('zod');
 require('node:child_process');
 require('node:os');

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import 'chalk';
-import './index-vCgb7QnZ.mjs';
-import './types-d_104eQF.mjs';
+import './index-UCYD5Wk3.mjs';
+import './types-BKyjG23_.mjs';
 import 'zod';
 import 'node:child_process';
 import 'node:os';

package/dist/{installTerminalHooks-T4NE5fmC.cjs → installTerminalHooks-CoK5wNcA.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-DLI6sss2.cjs');
-var index = require('./index-DYDAFqAN.cjs');
+var persistence = require('./types-ClDADuxP.cjs');
+var index = require('./index-FkXJNwiy.cjs');
 require('axios');
 require('node:util');
 require('node:fs/promises');

package/dist/{installTerminalHooks-C7JS6CBM.mjs → installTerminalHooks-TkkGzzbI.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-d_104eQF.mjs';
-import { t as tmuxSupportsSessionEnv } from './index-vCgb7QnZ.mjs';
+import { p as projectPath } from './types-BKyjG23_.mjs';
+import { t as tmuxSupportsSessionEnv } from './index-UCYD5Wk3.mjs';
 import 'axios';
 import 'node:util';
 import 'node:fs/promises';

package/dist/lib.cjs

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

package/dist/lib.d.cts

@@ -45,6 +45,17 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"tool-call-end">;
         call: z.ZodString;
+        result: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            truncated: z.ZodOptional<z.ZodBoolean>;
+            isError: z.ZodOptional<z.ZodBoolean>;
+            stats: z.ZodOptional<z.ZodObject<{
+                toolUses: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                toolStats: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"file">;
         ref: z.ZodString;
@@ -61,6 +72,8 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"start">;
         title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        subagentType: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"turn-end">;
         status: z.ZodEnum<{
@@ -80,6 +93,27 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"stop">;
+        status: z.ZodOptional<z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            stopped: "stopped";
+        }>>;
+        result: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            truncated: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        usage: z.ZodOptional<z.ZodObject<{
+            toolUses: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"progress">;
+        toolUses: z.ZodNumber;
+        lastTool: z.ZodOptional<z.ZodString>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        summary: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "t">;
 }, z.core.$strip>;
 type SessionEnvelope = z.infer<typeof sessionEnvelopeSchema>;
@@ -451,6 +485,14 @@ type Metadata = {
     flavor?: string;
     sandbox?: SandboxConfig | null;
     dangerouslySkipPermissions?: boolean | null;
+    /**
+     * Effective permission mode the running Claude process enforces right now
+     * (SDK vocabulary: default | acceptEdits | bypassPermissions | plan). The
+     * CLI is the single source of truth: it writes this at start, on every
+     * message/RPC/plan-approval change. Web displays it verbatim; old clients
+     * ignore it and old CLIs never write it (capability claude-live-permission-v2).
+     */
+    permissionMode?: string;
     /** Lineage for sessions created via the fork / duplicate flow. */
     parentSessionId?: string;
     forkedFromMessageId?: string;

package/dist/lib.d.mts

@@ -45,6 +45,17 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"tool-call-end">;
         call: z.ZodString;
+        result: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            truncated: z.ZodOptional<z.ZodBoolean>;
+            isError: z.ZodOptional<z.ZodBoolean>;
+            stats: z.ZodOptional<z.ZodObject<{
+                toolUses: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                toolStats: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"file">;
         ref: z.ZodString;
@@ -61,6 +72,8 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"start">;
         title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        subagentType: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"turn-end">;
         status: z.ZodEnum<{
@@ -80,6 +93,27 @@ declare const sessionEnvelopeSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         t: z.ZodLiteral<"stop">;
+        status: z.ZodOptional<z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            stopped: "stopped";
+        }>>;
+        result: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            truncated: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        usage: z.ZodOptional<z.ZodObject<{
+            toolUses: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"progress">;
+        toolUses: z.ZodNumber;
+        lastTool: z.ZodOptional<z.ZodString>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        summary: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "t">;
 }, z.core.$strip>;
 type SessionEnvelope = z.infer<typeof sessionEnvelopeSchema>;
@@ -451,6 +485,14 @@ type Metadata = {
     flavor?: string;
     sandbox?: SandboxConfig | null;
     dangerouslySkipPermissions?: boolean | null;
+    /**
+     * Effective permission mode the running Claude process enforces right now
+     * (SDK vocabulary: default | acceptEdits | bypassPermissions | plan). The
+     * CLI is the single source of truth: it writes this at start, on every
+     * message/RPC/plan-approval change. Web displays it verbatim; old clients
+     * ignore it and old CLIs never write it (capability claude-live-permission-v2).
+     */
+    permissionMode?: string;
     /** Lineage for sessions created via the fork / duplicate flow. */
     parentSessionId?: string;
     forkedFromMessageId?: string;

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-d_104eQF.mjs';
+export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-BKyjG23_.mjs';
 import 'axios';
 import 'chalk';
 import 'node:util';

package/dist/{mcp-B3EgenZh.mjs → mcp-C3MiqObi.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-vCgb7QnZ.mjs';
+import { p as pushClipboardViaDaemon } from './index-UCYD5Wk3.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-d_104eQF.mjs';
+import { l as logger } from './types-BKyjG23_.mjs';
 import 'chalk';
 import 'node:os';
 import 'node:crypto';

package/dist/{mcp-DgPg5mKa.cjs → mcp-DcRvswVI.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-DYDAFqAN.cjs');
+var index = require('./index-FkXJNwiy.cjs');
 var limits = require('./limits-KdWKmwtH.cjs');
-var persistence = require('./types-DLI6sss2.cjs');
+var persistence = require('./types-ClDADuxP.cjs');
 require('chalk');
 require('node:os');
 require('node:crypto');

package/dist/{runGemini-B3iv1QRL.mjs → runGemini-BbC0uwUj.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, i as readSettings, e as errorLogMetadata, j as encodeBase64, p as projectPath, d as contentLogMetadata } from './types-d_104eQF.mjs';
-import { g as GEMINI_API_KEY_ENV, j as GOOGLE_API_KEY_ENV, G as GEMINI_MODEL_ENV, B as BasePermissionHandler, k as BaseReasoningProcessor, i as initialMachineMetadata, d as createSessionMetadata, e as setupOfflineReconnection, n as notifyDaemonSessionStarted, M as MessageQueue2, h as hashObject, l as MessageBuffer, C as CHANGE_TITLE_INSTRUCTION, r as registerKillSessionHandler, f as startHappyServer } from './index-vCgb7QnZ.mjs';
-import { A as AcpBackend } from './AcpBackend-DuxcHPyn.mjs';
-import { readGeminiLocalConfig, determineGeminiModel, getGeminiModelSource, getInitialGeminiModel, saveGeminiModelToConfig } from './config-CdoGLla8.mjs';
+import { l as logger, h as connectionState, A as ApiClient, i as readSettings, e as errorLogMetadata, j as encodeBase64, p as projectPath, d as contentLogMetadata } from './types-BKyjG23_.mjs';
+import { g as GEMINI_API_KEY_ENV, j as GOOGLE_API_KEY_ENV, G as GEMINI_MODEL_ENV, B as BasePermissionHandler, k as BaseReasoningProcessor, i as initialMachineMetadata, d as createSessionMetadata, e as setupOfflineReconnection, n as notifyDaemonSessionStarted, M as MessageQueue2, h as hashObject, l as MessageBuffer, C as CHANGE_TITLE_INSTRUCTION, r as registerKillSessionHandler, f as startHappyServer } from './index-UCYD5Wk3.mjs';
+import { A as AcpBackend } from './AcpBackend-B5RRlzLU.mjs';
+import { readGeminiLocalConfig, determineGeminiModel, getGeminiModelSource, getInitialGeminiModel, saveGeminiModelToConfig } from './config-ra8iKxdU.mjs';
 import 'axios';
 import 'chalk';
 import 'node:util';