very-happy-cli 0.2.89 → 0.2.91

package/dist/{types-d_104eQF.mjs → types-BKyjG23_.mjs}

@@ -29,7 +29,7 @@ import { SandboxManager } from '@anthropic-ai/sandbox-runtime';
 import { Expo } from 'expo-server-sdk';
 
 var name = "very-happy-cli";
-var version = "0.2.89";
+var version = "0.2.91";
 var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
 var author = "Kirill Dubovitskiy";
 var contributors = [
@@ -142,12 +142,12 @@ var dependencies = {
 	zod: "^4.0.0"
 };
 var optionalDependencies = {
-	"very-happy-tools-arm64-darwin": "0.2.89",
-	"very-happy-tools-x64-darwin": "0.2.89",
-	"very-happy-tools-arm64-linux": "0.2.89",
-	"very-happy-tools-x64-linux": "0.2.89",
-	"very-happy-tools-arm64-win32": "0.2.89",
-	"very-happy-tools-x64-win32": "0.2.89"
+	"very-happy-tools-arm64-darwin": "0.2.91",
+	"very-happy-tools-x64-darwin": "0.2.91",
+	"very-happy-tools-arm64-linux": "0.2.91",
+	"very-happy-tools-x64-linux": "0.2.91",
+	"very-happy-tools-arm64-win32": "0.2.91",
+	"very-happy-tools-x64-win32": "0.2.91"
 };
 var devDependencies = {
 	"@slopus/happy-wire": "workspace:*",
@@ -639,9 +639,27 @@ const sessionToolCallStartEventSchema = z.object({
   description: z.string(),
   args: z.record(z.string(), z.unknown())
 });
+const sessionSubagentResultSchema = z.object({
+  text: z.string(),
+  truncated: z.boolean().optional()
+});
+const sessionSubagentUsageSchema = z.object({
+  toolUses: z.number().optional(),
+  totalTokens: z.number().optional(),
+  durationMs: z.number().optional()
+});
 const sessionToolCallEndEventSchema = z.object({
   t: z.literal("tool-call-end"),
-  call: z.string()
+  call: z.string(),
+  // Foreground Agent/Task completion: the sub-agent's final report + run
+  // totals (SDK `tool_use_result`). Absent for ordinary tools and for the
+  // background stub ("Async agent launched").
+  result: sessionSubagentResultSchema.extend({
+    isError: z.boolean().optional(),
+    stats: sessionSubagentUsageSchema.extend({
+      toolStats: z.record(z.string(), z.unknown()).optional()
+    }).optional()
+  }).optional()
 });
 const sessionFileEventSchema = z.object({
   t: z.literal("file"),
@@ -660,7 +678,10 @@ const sessionTurnStartEventSchema = z.object({
 });
 const sessionStartEventSchema = z.object({
   t: z.literal("start"),
-  title: z.string().optional()
+  title: z.string().optional(),
+  // B-260-P2: identity from SDK task_started / Agent tool input.
+  description: z.string().optional(),
+  subagentType: z.string().optional()
 });
 const sessionTurnEndStatusSchema = z.enum(["completed", "failed", "cancelled"]);
 const sessionTurnUsageSchema = z.object({
@@ -683,7 +704,21 @@ const sessionTurnEndEventSchema = z.object({
   usage: sessionTurnUsageSchema.optional()
 });
 const sessionStopEventSchema = z.object({
-  t: z.literal("stop")
+  t: z.literal("stop"),
+  // B-260-P2: from SDK task_notification. A second `stop` for the same
+  // subagent may follow carrying `result` once the notification user message
+  // (which holds the <result> block) arrives; consumers fold by subagent id.
+  status: z.enum(["completed", "failed", "stopped"]).optional(),
+  result: sessionSubagentResultSchema.optional(),
+  usage: sessionSubagentUsageSchema.optional()
+});
+const sessionProgressEventSchema = z.object({
+  t: z.literal("progress"),
+  toolUses: z.number(),
+  lastTool: z.string().optional(),
+  totalTokens: z.number().optional(),
+  durationMs: z.number().optional(),
+  summary: z.string().optional()
 });
 const sessionEventSchema = z.discriminatedUnion("t", [
   sessionTextEventSchema,
@@ -694,7 +729,8 @@ const sessionEventSchema = z.discriminatedUnion("t", [
   sessionTurnStartEventSchema,
   sessionStartEventSchema,
   sessionTurnEndEventSchema,
-  sessionStopEventSchema
+  sessionStopEventSchema,
+  sessionProgressEventSchema
 ]);
 const sessionEnvelopeSchema = z.object({
   id: z.string(),
@@ -725,7 +761,14 @@ const sessionEnvelopeSchema = z.object({
       path: ["role"]
     });
   }
-  if ((envelope.ev.t === "start" || envelope.ev.t === "stop") && envelope.role !== "agent") {
+  if (envelope.ev.t === "progress" && !envelope.subagent) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "progress events must carry a subagent",
+      path: ["subagent"]
+    });
+  }
+  if ((envelope.ev.t === "start" || envelope.ev.t === "stop" || envelope.ev.t === "progress") && envelope.role !== "agent") {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       message: `${envelope.ev.t} events must use role "agent"`,
@@ -2149,6 +2192,69 @@ function shouldReconnect() {
   return true;
 }
 
+const SUBAGENT_RESULT_MAX_CHARS = 16384;
+const SUBAGENT_PROGRESS_MIN_INTERVAL_MS = 5e3;
+function capSubagentText(text, max = SUBAGENT_RESULT_MAX_CHARS) {
+  const trimmed = text.trim();
+  if (trimmed.length <= max) return { text: trimmed };
+  return { text: trimmed.slice(0, max), truncated: true };
+}
+function toolUseResultToText(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return null;
+  const content = toolUseResult.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function toolUseResultStatus(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return "unknown";
+  const status = toolUseResult.status;
+  if (status === "async_launched") return "async_launched";
+  if (status === "completed") return "completed";
+  return "unknown";
+}
+function toolUseResultStats(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return void 0;
+  const r = toolUseResult;
+  const stats = {};
+  if (typeof r.totalToolUseCount === "number") stats.toolUses = r.totalToolUseCount;
+  if (typeof r.totalTokens === "number") stats.totalTokens = r.totalTokens;
+  if (typeof r.totalDurationMs === "number") stats.durationMs = r.totalDurationMs;
+  if (r.toolStats && typeof r.toolStats === "object") stats.toolStats = r.toolStats;
+  return Object.keys(stats).length > 0 ? stats : void 0;
+}
+function parseTaskNotificationText(text) {
+  if (!/<task-notification>/i.test(text)) return null;
+  const pick = (tag) => text.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, "i"))?.[1] ?? null;
+  const rawStatus = pick("status")?.trim().toLowerCase() ?? null;
+  const status = rawStatus === "completed" || rawStatus === "failed" || rawStatus === "stopped" ? rawStatus : null;
+  let resultText = pick("result");
+  let result = null;
+  if (resultText !== null) {
+    resultText = resultText.replace(/^\s*\[harness:[^\]]*\]\s*/i, "").replace(/<usage>[\s\S]*?<\/usage>/gi, "").trim();
+    if (resultText.length > 0) result = capSubagentText(resultText);
+  }
+  return {
+    toolUseId: pick("tool-use-id")?.trim() || null,
+    taskId: pick("task-id")?.trim() || null,
+    status,
+    summary: pick("summary")?.trim() || null,
+    result
+  };
+}
+function shouldEmitProgress(previous, toolUses, now) {
+  if (!previous) return true;
+  if (previous.lastToolUses === toolUses) return false;
+  return now - previous.lastAt >= SUBAGENT_PROGRESS_MIN_INTERVAL_MS;
+}
+
+const SUBAGENT_BUFFER_MAX_MESSAGES = 100;
 function isSubagentTool(name) {
   return name === "Task" || name === "Agent";
 }
@@ -2217,6 +2323,7 @@ function bufferSubagentMessage(state, subagent, message) {
   const buffer = getBufferedSubagentMessages(state);
   const queue = buffer.get(subagent) ?? [];
   queue.push(message);
+  while (queue.length > SUBAGENT_BUFFER_MAX_MESSAGES) queue.shift();
   buffer.set(subagent, queue);
 }
 function consumeBufferedSubagentMessages(state, subagent) {
@@ -2237,6 +2344,31 @@ function getActiveSubagents(state) {
   }
   return state.activeSubagents;
 }
+function getAgentToolCalls(state) {
+  if (!state.agentToolCalls) state.agentToolCalls = /* @__PURE__ */ new Set();
+  return state.agentToolCalls;
+}
+function getSubagentMeta(state) {
+  if (!state.subagentMeta) state.subagentMeta = /* @__PURE__ */ new Map();
+  return state.subagentMeta;
+}
+function getStubSubagents(state) {
+  if (!state.stubSubagents) state.stubSubagents = /* @__PURE__ */ new Set();
+  return state.stubSubagents;
+}
+function getProgressThrottle(state) {
+  if (!state.progressThrottle) state.progressThrottle = /* @__PURE__ */ new Map();
+  return state.progressThrottle;
+}
+function nowOf(state) {
+  return state.now ? state.now() : Date.now();
+}
+function rememberSubagentMeta(state, subagent, meta) {
+  const existing = getSubagentMeta(state).get(subagent) ?? {};
+  const description = typeof meta.description === "string" && meta.description.trim() ? meta.description.trim() : existing.description;
+  const subagentType = typeof meta.subagentType === "string" && meta.subagentType.trim() ? meta.subagentType.trim() : existing.subagentType;
+  getSubagentMeta(state).set(subagent, { ...description ? { description } : {}, ...subagentType ? { subagentType } : {} });
+}
 function pickAssistantUsage(message) {
   if (message.type !== "assistant") return void 0;
   const usage = message.message?.usage;
@@ -2413,13 +2545,26 @@ function maybeEmitSubagentStart(state, turn, subagent, envelopes) {
     return;
   }
   const title = getSubagentTitles(state).get(subagent);
+  const meta = getSubagentMeta(state).get(subagent);
   envelopes.push(createEnvelope("agent", {
     t: "start",
-    ...title ? { title } : {}
+    ...title ? { title } : {},
+    ...meta?.description ? { description: meta.description } : {},
+    ...meta?.subagentType ? { subagentType: meta.subagentType } : {}
   }, { turn, subagent }));
   started.add(subagent);
   getActiveSubagents(state).add(subagent);
 }
+function emitSubagentStopWithStatus(state, turn, subagent, envelopes, payload) {
+  envelopes.push(createEnvelope("agent", {
+    t: "stop",
+    ...payload.status ? { status: payload.status } : {},
+    ...payload.result ? { result: payload.result } : {},
+    ...payload.usage ? { usage: payload.usage } : {}
+  }, { ...turn ? { turn } : {}, subagent }));
+  getActiveSubagents(state).delete(subagent);
+  getStartedSubagents(state).delete(subagent);
+}
 function maybeEmitSubagentStop(state, turn, subagent, envelopes) {
   const active = getActiveSubagents(state);
   if (!active.has(subagent)) {
@@ -2431,8 +2576,6 @@ function maybeEmitSubagentStop(state, turn, subagent, envelopes) {
 function clearSubagentTracking(state) {
   getUuidToProviderSubagent(state).clear();
   getTaskPromptToSubagents(state).clear();
-  getProviderSubagentToSessionSubagent(state).clear();
-  getSubagentTitles(state).clear();
   getBufferedSubagentMessages(state).clear();
   getHiddenParentToolCalls(state).clear();
   getStartedSubagents(state).clear();
@@ -2493,6 +2636,58 @@ function closeClaudeTurnWithStatus(state, status, meta) {
 function mapClaudeLogMessageToSessionEnvelopes(message, state) {
   return mapClaudeLogMessageToSessionEnvelopesInternal(message, state);
 }
+function mapTaskLifecycleSystemMessage(message, state, envelopes) {
+  const raw = message;
+  const subtype = typeof raw.subtype === "string" ? raw.subtype : "";
+  if (!subtype.startsWith("task_")) return;
+  if (raw.skip_transcript === true) return;
+  const toolUseId = typeof raw.tool_use_id === "string" && raw.tool_use_id.length > 0 ? raw.tool_use_id : null;
+  if (!toolUseId || !getAgentToolCalls(state).has(toolUseId)) return;
+  const subagent = ensureSessionSubagentIdForProviderSubagent(state, toolUseId);
+  const usage = raw.usage && typeof raw.usage === "object" ? {
+    ...typeof raw.usage.tool_uses === "number" ? { toolUses: raw.usage.tool_uses } : {},
+    ...typeof raw.usage.total_tokens === "number" ? { totalTokens: raw.usage.total_tokens } : {},
+    ...typeof raw.usage.duration_ms === "number" ? { durationMs: raw.usage.duration_ms } : {}
+  } : void 0;
+  if (subtype === "task_started") {
+    rememberSubagentMeta(state, subagent, { description: raw.description, subagentType: raw.subagent_type });
+    const turn = ensureTurn(state, envelopes);
+    getStartedSubagents(state).delete(subagent);
+    maybeEmitSubagentStart(state, turn, subagent, envelopes);
+    return;
+  }
+  if (subtype === "task_progress") {
+    const toolUses = typeof raw.usage?.tool_uses === "number" ? raw.usage.tool_uses : 0;
+    const throttle = getProgressThrottle(state);
+    const now = nowOf(state);
+    if (!shouldEmitProgress(throttle.get(subagent), toolUses, now)) return;
+    throttle.set(subagent, { lastAt: now, lastToolUses: toolUses });
+    const turn = ensureTurn(state, envelopes);
+    maybeEmitSubagentStart(state, turn, subagent, envelopes);
+    envelopes.push(createEnvelope("agent", {
+      t: "progress",
+      toolUses,
+      ...typeof raw.last_tool_name === "string" && raw.last_tool_name ? { lastTool: raw.last_tool_name } : {},
+      ...usage?.totalTokens !== void 0 ? { totalTokens: usage.totalTokens } : {},
+      ...usage?.durationMs !== void 0 ? { durationMs: usage.durationMs } : {},
+      ...typeof raw.summary === "string" && raw.summary.trim() ? { summary: raw.summary.trim() } : {}
+    }, { turn, subagent }));
+    return;
+  }
+  if (subtype === "task_notification") {
+    const status = raw.status === "completed" || raw.status === "failed" || raw.status === "stopped" ? raw.status : "completed";
+    emitSubagentStopWithStatus(state, state.currentTurnId ?? void 0, subagent, envelopes, {
+      status,
+      ...usage ? { usage } : {}
+    });
+    getStubSubagents(state).delete(subagent);
+    getProgressThrottle(state).delete(subagent);
+    return;
+  }
+  if (subtype === "task_updated" && raw.patch?.is_backgrounded === true) {
+    getStubSubagents(state).add(subagent);
+  }
+}
 function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
   const envelopes = [];
   const claudeUuid = pickUuid(message);
@@ -2513,6 +2708,7 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
     };
   }
   if (message.type === "system") {
+    mapTaskLifecycleSystemMessage(message, state, envelopes);
     return {
       currentTurnId: state.currentTurnId,
       envelopes
@@ -2554,6 +2750,9 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
             queueTaskPromptSubagent(state, prompt, call);
           }
           setSubagentTitle(state, sessionSubagentForCall, pickTaskTitle(block.input) ?? prompt);
+          getAgentToolCalls(state).add(call);
+          const input = block.input ?? {};
+          rememberSubagentMeta(state, sessionSubagentForCall, { description: input.description, subagentType: input.subagent_type });
         }
         if (shouldHideParentToolCall(name)) {
           getHiddenParentToolCalls(state).add(call);
@@ -2598,6 +2797,18 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
         maybeEmitSubagentStart(state, turnId2, subagent, envelopes);
         envelopes.push(createEnvelope("agent", { t: "text", text: message.message.content }, { turn: turnId2, subagent, claudeUuid }));
       } else {
+        const origin = message.origin;
+        if (origin?.kind === "task-notification" || /<task-notification>/i.test(message.message.content)) {
+          const fields = parseTaskNotificationText(message.message.content);
+          const providerId = fields?.toolUseId ?? null;
+          const subagentForNotification = providerId && getAgentToolCalls(state).has(providerId) ? getSessionSubagentIdForProviderSubagent(state, providerId) : void 0;
+          if (fields && subagentForNotification && (fields.result || fields.status)) {
+            emitSubagentStopWithStatus(state, state.currentTurnId ?? void 0, subagentForNotification, envelopes, {
+              ...fields.status ? { status: fields.status } : {},
+              ...fields.result ? { result: fields.result } : {}
+            });
+          }
+        }
         closeTurn(state, "completed", envelopes);
         envelopes.push(createEnvelope("user", { t: "text", text: message.message.content }, { claudeUuid }));
       }
@@ -2628,6 +2839,31 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
             getHiddenParentToolCalls(state).delete(block.tool_use_id);
             continue;
           }
+          if (sessionSubagentForToolResult && getAgentToolCalls(state).has(block.tool_use_id)) {
+            const toolUseResult = message.tool_use_result;
+            const resultStatus = toolUseResultStatus(toolUseResult);
+            if (resultStatus === "async_launched") {
+              getStubSubagents(state).add(sessionSubagentForToolResult);
+              envelopes.push(createEnvelope("agent", { t: "tool-call-end", call: block.tool_use_id }, { turn: turnId, subagent }));
+              continue;
+            }
+            if (resultStatus === "completed") {
+              const text = toolUseResultToText(toolUseResult);
+              const stats = toolUseResultStats(toolUseResult);
+              const result = text ? capSubagentText(text) : void 0;
+              emitSubagentStopWithStatus(state, turnId, sessionSubagentForToolResult, envelopes, {
+                status: "completed",
+                ...result ? { result } : {},
+                ...stats ? { usage: { toolUses: stats.toolUses, totalTokens: stats.totalTokens, durationMs: stats.durationMs } } : {}
+              });
+              envelopes.push(createEnvelope("agent", {
+                t: "tool-call-end",
+                call: block.tool_use_id,
+                ...result ? { result: { ...result, ...stats ? { stats } : {} } } : {}
+              }, { turn: turnId, subagent }));
+              continue;
+            }
+          }
           if (sessionSubagentForToolResult) {
             maybeEmitSubagentStop(state, turnId, sessionSubagentForToolResult, envelopes);
           }
@@ -8807,6 +9043,20 @@ function previewAscii(line) {
   return line.length > 80 ? `${out}\u2026` : out;
 }
 
+const VH_TMUX_SOCKET_ENV = "VH_TMUX_SOCKET";
+function tmuxSocketFlags(env = process.env) {
+  const socket = env[VH_TMUX_SOCKET_ENV];
+  return socket ? ["-S", socket] : [];
+}
+function tmuxArgs(args, env = process.env) {
+  return [...tmuxSocketFlags(env), ...args];
+}
+function scrubTmuxClientEnv(env) {
+  delete env.TMUX;
+  delete env.TMUX_PANE;
+  return env;
+}
+
 const CONTROL_CLIENT_KILL_GRACE_MS = 2e3;
 const CONTROL_COMMAND_TIMEOUT_MS = 1e4;
 function isSafeControlCommand(command) {
@@ -8816,7 +9066,7 @@ class ControlClient {
   constructor(tmuxSession, env, handlers) {
     this.tmuxSession = tmuxSession;
     this.handlers = handlers;
-    this.child = spawn$2("tmux", ["-C", "attach-session", "-t", `=${tmuxSession}:`], {
+    this.child = spawn$2("tmux", tmuxArgs(["-C", "attach-session", "-t", `=${tmuxSession}:`], env), {
       stdio: ["pipe", "pipe", "pipe"],
       env
     });
@@ -9968,7 +10218,7 @@ let tmuxAvailableCache = null;
 function isTmuxAvailable() {
   if (tmuxAvailableCache !== null) return tmuxAvailableCache;
   try {
-    const r = spawnSync("tmux", ["-V"], { stdio: "ignore", env: ptyEnv() });
+    const r = spawnSync("tmux", tmuxArgs(["-V"]), { stdio: "ignore", env: ptyEnv() });
     tmuxAvailableCache = r.status === 0;
   } catch {
     tmuxAvailableCache = false;
@@ -9979,7 +10229,7 @@ let tmuxEnvFlagCache = null;
 function tmuxSupportsEnvFlag() {
   if (tmuxEnvFlagCache !== null) return tmuxEnvFlagCache;
   try {
-    const r = spawnSync("tmux", ["-V"], { encoding: "utf8", env: ptyEnv() });
+    const r = spawnSync("tmux", tmuxArgs(["-V"]), { encoding: "utf8", env: ptyEnv() });
     tmuxEnvFlagCache = r.status === 0 && tmuxSupportsNewSessionEnv(r.stdout || "");
   } catch {
     tmuxEnvFlagCache = false;
@@ -10023,6 +10273,7 @@ function ptyEnv() {
   for (const [k, v] of Object.entries(process.env)) {
     if (typeof v === "string") env[k] = v;
   }
+  scrubTmuxClientEnv(env);
   const local = `${os$1.homedir()}/.local/bin`;
   if (!(env.PATH || "").split(":").includes(local)) {
     env.PATH = `${local}:${env.PATH || ""}`;
@@ -10678,7 +10929,7 @@ class WebTerminalManager {
     const name = `vh-${plan.terminalId}`;
     const exists = spawnSync(
       "tmux",
-      ["has-session", "-t", `=${name}:`],
+      tmuxArgs(["has-session", "-t", `=${name}:`]),
       { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
     ).status === 0;
     if (exists) return false;
@@ -10692,12 +10943,12 @@ class WebTerminalManager {
     ] : [];
     const created = spawnSync(
       "tmux",
-      tmuxNewSessionArgs(name, 120, 30, plan.cwd, envFlags, defaultShell()),
+      tmuxArgs(tmuxNewSessionArgs(name, 120, 30, plan.cwd, envFlags, defaultShell())),
       { stdio: "ignore", timeout: TMUX_CREATE_TIMEOUT_MS, env }
     );
     const live = created.status === 0 && spawnSync(
       "tmux",
-      ["has-session", "-t", `=${name}:`],
+      tmuxArgs(["has-session", "-t", `=${name}:`]),
       { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
     ).status === 0;
     if (!live) {
@@ -10707,12 +10958,12 @@ class WebTerminalManager {
     if (plan.title) {
       spawnSync(
         "tmux",
-        ["set-option", "-t", `=${name}:`, "@vh_title", plan.title],
+        tmuxArgs(["set-option", "-t", `=${name}:`, "@vh_title", plan.title]),
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
       );
     }
     for (const argv of startupInjectionArgs(name, plan.command)) {
-      spawnSync("tmux", argv, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+      spawnSync("tmux", tmuxArgs(argv), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
     }
     logger.info(`[WEB TERMINAL] auto-restored ${plan.terminalId} in ${plan.cwd}`);
     return true;
@@ -10844,14 +11095,14 @@ class WebTerminalManager {
     if (opts.attachOnly || opts.resub) {
       const alive = isTmuxAvailable() && spawnSync(
         "tmux",
-        ["has-session", "-t", `=vh-${id}:`],
+        tmuxArgs(["has-session", "-t", `=vh-${id}:`]),
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       ).status === 0;
       if (!alive) throw new Error("terminal-gone");
     } else if (this.tombstones[id]) {
       const alive = isTmuxAvailable() && spawnSync(
         "tmux",
-        ["has-session", "-t", `=vh-${id}:`],
+        tmuxArgs(["has-session", "-t", `=vh-${id}:`]),
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       ).status === 0;
       if (!alive) {
@@ -10880,7 +11131,7 @@ class WebTerminalManager {
         try {
           const created = spawnSync(
             "tmux",
-            tmuxNewSessionArgs(tmuxSession, cols, rows, cwd, envFlags, defaultShell()),
+            tmuxArgs(tmuxNewSessionArgs(tmuxSession, cols, rows, cwd, envFlags, defaultShell())),
             { stdio: "ignore", timeout: TMUX_CREATE_TIMEOUT_MS, env }
           );
           createdNew = created.status === 0;
@@ -10912,7 +11163,7 @@ class WebTerminalManager {
       ];
       for (const a of optArgs) {
         try {
-          spawnSync("tmux", a, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+          spawnSync("tmux", tmuxArgs(a), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
         } catch {
         }
       }
@@ -10921,7 +11172,7 @@ class WebTerminalManager {
         if (startup) {
           try {
             for (const a of startupInjectionArgs(tmuxSession, startup)) {
-              spawnSync("tmux", a, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+              spawnSync("tmux", tmuxArgs(a), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
             }
             logger.debug(`[WEB TERMINAL] injected startup command into new session ${tmuxSession}`);
           } catch {
@@ -10931,13 +11182,13 @@ class WebTerminalManager {
       if (!attachOnly && !createdNew) {
         const alive = spawnSync(
           "tmux",
-          ["has-session", "-t", `=${tmuxSession}:`],
+          tmuxArgs(["has-session", "-t", `=${tmuxSession}:`]),
           { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
         ).status === 0;
         if (shouldUseDirectPtyFallback(attachOnly, createdNew, alive)) {
           const retry = spawnSync(
             "tmux",
-            tmuxNewSessionArgs(tmuxSession, cols, rows, cwd, envFlags, defaultShell()),
+            tmuxArgs(tmuxNewSessionArgs(tmuxSession, cols, rows, cwd, envFlags, defaultShell())),
             { stdio: "ignore", timeout: TMUX_CREATE_TIMEOUT_MS, env }
           );
           createdNew = retry.status === 0;
@@ -10946,7 +11197,7 @@ class WebTerminalManager {
             if (startup) {
               for (const a of startupInjectionArgs(tmuxSession, startup)) {
                 try {
-                  spawnSync("tmux", a, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+                  spawnSync("tmux", tmuxArgs(a), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
                 } catch {
                 }
               }
@@ -10957,7 +11208,7 @@ class WebTerminalManager {
       if (!attachOnly && !createdNew) {
         const alive = spawnSync(
           "tmux",
-          ["has-session", "-t", `=${tmuxSession}:`],
+          tmuxArgs(["has-session", "-t", `=${tmuxSession}:`]),
           { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
         ).status === 0;
         if (!alive) {
@@ -11284,8 +11535,8 @@ class WebTerminalManager {
   killSession(terminalId) {
     const info = this.lastSeenInfo.get(terminalId) ?? this.listSessions().find((t) => t.id === terminalId);
     const target = `=vh-${terminalId}:`;
-    const killed = spawnSync("tmux", ["kill-session", "-t", target], { stdio: "ignore", env: ptyEnv() });
-    const verified = spawnSync("tmux", ["has-session", "-t", target], { stdio: "ignore", env: ptyEnv() });
+    const killed = spawnSync("tmux", tmuxArgs(["kill-session", "-t", target]), { stdio: "ignore", env: ptyEnv() });
+    const verified = spawnSync("tmux", tmuxArgs(["has-session", "-t", target]), { stdio: "ignore", env: ptyEnv() });
     if (!tmuxKillVerified(killed, verified)) {
       logger.debug(`[WEB TERMINAL] failed to verify tmux session removal ${target}`);
       return false;
@@ -11346,7 +11597,7 @@ class WebTerminalManager {
       const env = ptyEnv();
       const r = spawnSync(
         "tmux",
-        ["list-sessions", "-F", LIST_SESSIONS_FORMAT],
+        tmuxArgs(["list-sessions", "-F", LIST_SESSIONS_FORMAT]),
         { encoding: "utf8", env }
       );
       if (r.status !== 0 || !r.stdout) return [];
@@ -11362,7 +11613,7 @@ class WebTerminalManager {
           try {
             const w = spawnSync(
               "tmux",
-              ["set-option", "-t", `=${s.name}:`, "@vh_title", auto],
+              tmuxArgs(["set-option", "-t", `=${s.name}:`, "@vh_title", auto]),
               { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
             );
             if (w.status === 0) title = auto;
@@ -11413,13 +11664,13 @@ class WebTerminalManager {
     try {
       const cmd = spawnSync(
         "tmux",
-        ["display-message", "-p", "-t", sessionName, "#{pane_current_command}"],
+        tmuxArgs(["display-message", "-p", "-t", sessionName, "#{pane_current_command}"]),
         { encoding: "utf8", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       );
       if (cmd.status !== 0 || typeof cmd.stdout !== "string") return void 0;
       const cap = spawnSync(
         "tmux",
-        ["capture-pane", "-p", "-t", sessionName, "-S", "-40"],
+        tmuxArgs(["capture-pane", "-p", "-t", sessionName, "-S", "-40"]),
         { encoding: "utf8", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       );
       if (cap.status !== 0 || typeof cap.stdout !== "string") return void 0;
@@ -11446,7 +11697,7 @@ class WebTerminalManager {
     try {
       const probe = spawnSync(
         "tmux",
-        ["display-message", "-p", "-t", name, "#{pane_in_mode}	#{alternate_on}	#{mouse_any_flag}	#{pane_width}	#{pane_height}	#{pane_current_command}"],
+        tmuxArgs(["display-message", "-p", "-t", name, "#{pane_in_mode}	#{alternate_on}	#{mouse_any_flag}	#{pane_width}	#{pane_height}	#{pane_current_command}"]),
         { encoding: "utf8", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       );
       if (probe.status !== 0 || typeof probe.stdout !== "string") return;
@@ -11464,7 +11715,7 @@ class WebTerminalManager {
         const hex = sgrWheelHexBytes(action.dir, action.count, Number(paneW) || 80, Number(paneH) || 24);
         spawnSync(
           "tmux",
-          ["send-keys", "-t", name, "-H", ...hex],
+          tmuxArgs(["send-keys", "-t", name, "-H", ...hex]),
           { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
         );
         return;
@@ -11472,7 +11723,7 @@ class WebTerminalManager {
       if (action.kind === "page-keys") {
         spawnSync(
           "tmux",
-          ["send-keys", "-t", name, "-N", String(action.count), action.key],
+          tmuxArgs(["send-keys", "-t", name, "-N", String(action.count), action.key]),
           { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
         );
         return;
@@ -11480,19 +11731,19 @@ class WebTerminalManager {
       if (action.kind === "keys") {
         spawnSync(
           "tmux",
-          ["send-keys", "-t", name, "-N", String(action.count), action.key],
+          tmuxArgs(["send-keys", "-t", name, "-N", String(action.count), action.key]),
           { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
         );
         return;
       }
       spawnSync(
         "tmux",
-        ["copy-mode", "-e", "-t", name],
+        tmuxArgs(["copy-mode", "-e", "-t", name]),
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       );
       spawnSync(
         "tmux",
-        [
+        tmuxArgs([
           "send-keys",
           "-X",
           "-t",
@@ -11500,7 +11751,7 @@ class WebTerminalManager {
           "-N",
           String(action.count),
           action.dir === "up" ? "scroll-up" : "scroll-down"
-        ],
+        ]),
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       );
     } catch {
@@ -11534,14 +11785,14 @@ class WebTerminalManager {
     const name = `vh-${terminalId}`;
     try {
       if (ifAbsent) {
-        const cur = spawnSync("tmux", ["show-options", "-t", name, "-v", "@vh_title"], { encoding: "utf8", env: ptyEnv() });
+        const cur = spawnSync("tmux", tmuxArgs(["show-options", "-t", name, "-v", "@vh_title"]), { encoding: "utf8", env: ptyEnv() });
         if (cur.status === 0 && cur.stdout && cur.stdout.trim()) return true;
       }
-      const r = spawnSync("tmux", ["set-option", "-t", name, "@vh_title", title], { stdio: "ignore", env: ptyEnv() });
+      const r = spawnSync("tmux", tmuxArgs(["set-option", "-t", name, "@vh_title", title]), { stdio: "ignore", env: ptyEnv() });
       if (r.status !== 0) return false;
       if (!ifAbsent) {
         try {
-          spawnSync("tmux", ["set-option", "-t", name, "@vh_title_manual", "1"], { stdio: "ignore", env: ptyEnv() });
+          spawnSync("tmux", tmuxArgs(["set-option", "-t", name, "@vh_title_manual", "1"]), { stdio: "ignore", env: ptyEnv() });
         } catch {
         }
       }
@@ -11559,7 +11810,7 @@ class WebTerminalManager {
     if (!valid) return false;
     const name = `vh-${terminalId}`;
     try {
-      const r = spawnSync("tmux", ["set-option", "-t", name, "@vh_tags", JSON.stringify(valid)], {
+      const r = spawnSync("tmux", tmuxArgs(["set-option", "-t", name, "@vh_tags", JSON.stringify(valid)]), {
         stdio: "ignore",
         env: ptyEnv()
       });
@@ -11591,10 +11842,11 @@ function parseVhTerminals(stdout, hostname = os$1.hostname()) {
 }
 function runTmux(args, input) {
   try {
-    const r = spawnSync("tmux", args, {
+    const r = spawnSync("tmux", tmuxArgs(args), {
       encoding: "utf8",
       timeout: TMUX_TIMEOUT_MS,
-      input
+      input,
+      env: scrubTmuxClientEnv({ ...process.env })
     });
     if (r.error) return { ok: false, stdout: "", error: r.error.message };
     if (r.status !== 0) return { ok: false, stdout: r.stdout ?? "", error: (r.stderr || `tmux exited with ${r.status}`).trim() };
@@ -15149,4 +15401,4 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { summarizeSpawnSessionForLog as $, ApiClient as A, deriveLocalCliUpdateSummary as B, updateSettings as C, encodeBase64Url as D, decodeBase64 as E, writeCredentialsLegacy as F, writeCredentialsDataKey as G, readCredentialsForConfiguredRelay as H, InvalidateSync as I, encrypt as J, getLocalHappyAgentCredentialPath as K, readLocalHappyAgentCredentials as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, decryptWithDataKey as N, decryptLegacy as O, extractCompleteLines as P, decideBackfill as Q, RawJSONLinesSchema as R, parseTerminalHookPayload as S, decideMirrorBinding as T, persistSession as U, MIRROR_BACKFILL_LINES_DEFAULT as V, mirrorLineKey as W, mirrorLocalId as X, detectResumeSupport as Y, detectCLIAvailability as Z, acquireDaemonLock as _, ApiSessionClient as a, deletePersistedSessions as a0, decrypt as a1, writeDaemonState as a2, fetchCliUpdateState as a3, resolveCliUpdateCheckInterval as a4, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as a5, releaseDaemonLock as a6, isValidSessionId as a7, listVhTerminals as a8, isValidTerminalId as a9, readVhTerminal as aa, sendToVhTerminal as ab, startOfflineReconnection as ac, clearCredentials as ad, clearMachineId as ae, SandboxConfigSchema as af, CodexAppServerClient as ag, getLatestDaemonLog as ah, persistence as ai, api as aj, createEnvelope as b, configuration as c, contentLogMetadata as d, errorLogMetadata as e, packageJson as f, delay as g, connectionState as h, readSettings as i, encodeBase64 as j, ensurePrivateDirectorySync as k, logger as l, hardenPrivateFileSync as m, readDaemonState as n, clearDaemonState as o, projectPath as p, getProjectPath as q, readPersistedSessions as r, initializeSandbox as s, wrapCommand as t, AsyncLock as u, ensurePrivateDirectory as v, writePrivateFileSync as w, hardenPrivateFile as x, readCredentials as y, credentialRelayProblem as z };
+export { detectCLIAvailability as $, ApiClient as A, deriveLocalCliUpdateSummary as B, updateSettings as C, encodeBase64Url as D, decodeBase64 as E, writeCredentialsLegacy as F, writeCredentialsDataKey as G, readCredentialsForConfiguredRelay as H, InvalidateSync as I, encrypt as J, getLocalHappyAgentCredentialPath as K, readLocalHappyAgentCredentials as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, decryptWithDataKey as N, decryptLegacy as O, extractCompleteLines as P, decideBackfill as Q, RawJSONLinesSchema as R, parseTerminalHookPayload as S, tmuxArgs as T, scrubTmuxClientEnv as U, decideMirrorBinding as V, persistSession as W, MIRROR_BACKFILL_LINES_DEFAULT as X, mirrorLineKey as Y, mirrorLocalId as Z, detectResumeSupport as _, ApiSessionClient as a, acquireDaemonLock as a0, summarizeSpawnSessionForLog as a1, deletePersistedSessions as a2, decrypt as a3, writeDaemonState as a4, fetchCliUpdateState as a5, resolveCliUpdateCheckInterval as a6, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as a7, releaseDaemonLock as a8, isValidSessionId as a9, listVhTerminals as aa, isValidTerminalId as ab, readVhTerminal as ac, sendToVhTerminal as ad, startOfflineReconnection as ae, clearCredentials as af, clearMachineId as ag, SandboxConfigSchema as ah, CodexAppServerClient as ai, getLatestDaemonLog as aj, persistence as ak, api as al, createEnvelope as b, configuration as c, contentLogMetadata as d, errorLogMetadata as e, packageJson as f, delay as g, connectionState as h, readSettings as i, encodeBase64 as j, ensurePrivateDirectorySync as k, logger as l, hardenPrivateFileSync as m, readDaemonState as n, clearDaemonState as o, projectPath as p, getProjectPath as q, readPersistedSessions as r, initializeSandbox as s, wrapCommand as t, AsyncLock as u, ensurePrivateDirectory as v, writePrivateFileSync as w, hardenPrivateFile as x, readCredentials as y, credentialRelayProblem as z };