very-happy-cli 0.2.89 → 0.2.91

package/dist/{types-DLI6sss2.cjs → types-ClDADuxP.cjs}

@@ -51,7 +51,7 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 var pty__namespace = /*#__PURE__*/_interopNamespaceDefault(pty);
 
 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 = [
@@ -164,12 +164,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:*",
@@ -661,9 +661,27 @@ const sessionToolCallStartEventSchema = z__namespace.object({
   description: z__namespace.string(),
   args: z__namespace.record(z__namespace.string(), z__namespace.unknown())
 });
+const sessionSubagentResultSchema = z__namespace.object({
+  text: z__namespace.string(),
+  truncated: z__namespace.boolean().optional()
+});
+const sessionSubagentUsageSchema = z__namespace.object({
+  toolUses: z__namespace.number().optional(),
+  totalTokens: z__namespace.number().optional(),
+  durationMs: z__namespace.number().optional()
+});
 const sessionToolCallEndEventSchema = z__namespace.object({
   t: z__namespace.literal("tool-call-end"),
-  call: z__namespace.string()
+  call: z__namespace.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__namespace.boolean().optional(),
+    stats: sessionSubagentUsageSchema.extend({
+      toolStats: z__namespace.record(z__namespace.string(), z__namespace.unknown()).optional()
+    }).optional()
+  }).optional()
 });
 const sessionFileEventSchema = z__namespace.object({
   t: z__namespace.literal("file"),
@@ -682,7 +700,10 @@ const sessionTurnStartEventSchema = z__namespace.object({
 });
 const sessionStartEventSchema = z__namespace.object({
   t: z__namespace.literal("start"),
-  title: z__namespace.string().optional()
+  title: z__namespace.string().optional(),
+  // B-260-P2: identity from SDK task_started / Agent tool input.
+  description: z__namespace.string().optional(),
+  subagentType: z__namespace.string().optional()
 });
 const sessionTurnEndStatusSchema = z__namespace.enum(["completed", "failed", "cancelled"]);
 const sessionTurnUsageSchema = z__namespace.object({
@@ -705,7 +726,21 @@ const sessionTurnEndEventSchema = z__namespace.object({
   usage: sessionTurnUsageSchema.optional()
 });
 const sessionStopEventSchema = z__namespace.object({
-  t: z__namespace.literal("stop")
+  t: z__namespace.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__namespace.enum(["completed", "failed", "stopped"]).optional(),
+  result: sessionSubagentResultSchema.optional(),
+  usage: sessionSubagentUsageSchema.optional()
+});
+const sessionProgressEventSchema = z__namespace.object({
+  t: z__namespace.literal("progress"),
+  toolUses: z__namespace.number(),
+  lastTool: z__namespace.string().optional(),
+  totalTokens: z__namespace.number().optional(),
+  durationMs: z__namespace.number().optional(),
+  summary: z__namespace.string().optional()
 });
 const sessionEventSchema = z__namespace.discriminatedUnion("t", [
   sessionTextEventSchema,
@@ -716,7 +751,8 @@ const sessionEventSchema = z__namespace.discriminatedUnion("t", [
   sessionTurnStartEventSchema,
   sessionStartEventSchema,
   sessionTurnEndEventSchema,
-  sessionStopEventSchema
+  sessionStopEventSchema,
+  sessionProgressEventSchema
 ]);
 const sessionEnvelopeSchema = z__namespace.object({
   id: z__namespace.string(),
@@ -747,7 +783,14 @@ const sessionEnvelopeSchema = z__namespace.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__namespace.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__namespace.ZodIssueCode.custom,
       message: `${envelope.ev.t} events must use role "agent"`,
@@ -1484,7 +1527,7 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-DLI6sss2.cjs', document.baseURI).href))));
+const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-ClDADuxP.cjs', document.baseURI).href))));
 function projectPath() {
   const path = path$1.resolve(__dirname$1, "..");
   return path;
@@ -2171,6 +2214,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";
 }
@@ -2239,6 +2345,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) {
@@ -2259,6 +2366,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;
@@ -2435,13 +2567,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)) {
@@ -2453,8 +2598,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();
@@ -2515,6 +2658,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);
@@ -2535,6 +2730,7 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
     };
   }
   if (message.type === "system") {
+    mapTaskLifecycleSystemMessage(message, state, envelopes);
     return {
       currentTurnId: state.currentTurnId,
       envelopes
@@ -2576,6 +2772,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);
@@ -2620,6 +2819,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 }));
       }
@@ -2650,6 +2861,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);
           }
@@ -8829,6 +9065,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) {
@@ -8838,7 +9088,7 @@ class ControlClient {
   constructor(tmuxSession, env, handlers) {
     this.tmuxSession = tmuxSession;
     this.handlers = handlers;
-    this.child = node_child_process.spawn("tmux", ["-C", "attach-session", "-t", `=${tmuxSession}:`], {
+    this.child = node_child_process.spawn("tmux", tmuxArgs(["-C", "attach-session", "-t", `=${tmuxSession}:`], env), {
       stdio: ["pipe", "pipe", "pipe"],
       env
     });
@@ -9990,7 +10240,7 @@ let tmuxAvailableCache = null;
 function isTmuxAvailable() {
   if (tmuxAvailableCache !== null) return tmuxAvailableCache;
   try {
-    const r = node_child_process.spawnSync("tmux", ["-V"], { stdio: "ignore", env: ptyEnv() });
+    const r = node_child_process.spawnSync("tmux", tmuxArgs(["-V"]), { stdio: "ignore", env: ptyEnv() });
     tmuxAvailableCache = r.status === 0;
   } catch {
     tmuxAvailableCache = false;
@@ -10001,7 +10251,7 @@ let tmuxEnvFlagCache = null;
 function tmuxSupportsEnvFlag() {
   if (tmuxEnvFlagCache !== null) return tmuxEnvFlagCache;
   try {
-    const r = node_child_process.spawnSync("tmux", ["-V"], { encoding: "utf8", env: ptyEnv() });
+    const r = node_child_process.spawnSync("tmux", tmuxArgs(["-V"]), { encoding: "utf8", env: ptyEnv() });
     tmuxEnvFlagCache = r.status === 0 && tmuxSupportsNewSessionEnv(r.stdout || "");
   } catch {
     tmuxEnvFlagCache = false;
@@ -10045,6 +10295,7 @@ function ptyEnv() {
   for (const [k, v] of Object.entries(process.env)) {
     if (typeof v === "string") env[k] = v;
   }
+  scrubTmuxClientEnv(env);
   const local = `${os.homedir()}/.local/bin`;
   if (!(env.PATH || "").split(":").includes(local)) {
     env.PATH = `${local}:${env.PATH || ""}`;
@@ -10700,7 +10951,7 @@ class WebTerminalManager {
     const name = `vh-${plan.terminalId}`;
     const exists = node_child_process.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;
@@ -10714,12 +10965,12 @@ class WebTerminalManager {
     ] : [];
     const created = node_child_process.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 && node_child_process.spawnSync(
       "tmux",
-      ["has-session", "-t", `=${name}:`],
+      tmuxArgs(["has-session", "-t", `=${name}:`]),
       { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
     ).status === 0;
     if (!live) {
@@ -10729,12 +10980,12 @@ class WebTerminalManager {
     if (plan.title) {
       node_child_process.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)) {
-      node_child_process.spawnSync("tmux", argv, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+      node_child_process.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;
@@ -10866,14 +11117,14 @@ class WebTerminalManager {
     if (opts.attachOnly || opts.resub) {
       const alive = isTmuxAvailable() && node_child_process.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() && node_child_process.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) {
@@ -10902,7 +11153,7 @@ class WebTerminalManager {
         try {
           const created = node_child_process.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;
@@ -10934,7 +11185,7 @@ class WebTerminalManager {
       ];
       for (const a of optArgs) {
         try {
-          node_child_process.spawnSync("tmux", a, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+          node_child_process.spawnSync("tmux", tmuxArgs(a), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
         } catch {
         }
       }
@@ -10943,7 +11194,7 @@ class WebTerminalManager {
         if (startup) {
           try {
             for (const a of startupInjectionArgs(tmuxSession, startup)) {
-              node_child_process.spawnSync("tmux", a, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+              node_child_process.spawnSync("tmux", tmuxArgs(a), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
             }
             logger.debug(`[WEB TERMINAL] injected startup command into new session ${tmuxSession}`);
           } catch {
@@ -10953,13 +11204,13 @@ class WebTerminalManager {
       if (!attachOnly && !createdNew) {
         const alive = node_child_process.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 = node_child_process.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;
@@ -10968,7 +11219,7 @@ class WebTerminalManager {
             if (startup) {
               for (const a of startupInjectionArgs(tmuxSession, startup)) {
                 try {
-                  node_child_process.spawnSync("tmux", a, { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
+                  node_child_process.spawnSync("tmux", tmuxArgs(a), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
                 } catch {
                 }
               }
@@ -10979,7 +11230,7 @@ class WebTerminalManager {
       if (!attachOnly && !createdNew) {
         const alive = node_child_process.spawnSync(
           "tmux",
-          ["has-session", "-t", `=${tmuxSession}:`],
+          tmuxArgs(["has-session", "-t", `=${tmuxSession}:`]),
           { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
         ).status === 0;
         if (!alive) {
@@ -11306,8 +11557,8 @@ class WebTerminalManager {
   killSession(terminalId) {
     const info = this.lastSeenInfo.get(terminalId) ?? this.listSessions().find((t) => t.id === terminalId);
     const target = `=vh-${terminalId}:`;
-    const killed = node_child_process.spawnSync("tmux", ["kill-session", "-t", target], { stdio: "ignore", env: ptyEnv() });
-    const verified = node_child_process.spawnSync("tmux", ["has-session", "-t", target], { stdio: "ignore", env: ptyEnv() });
+    const killed = node_child_process.spawnSync("tmux", tmuxArgs(["kill-session", "-t", target]), { stdio: "ignore", env: ptyEnv() });
+    const verified = node_child_process.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;
@@ -11368,7 +11619,7 @@ class WebTerminalManager {
       const env = ptyEnv();
       const r = node_child_process.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 [];
@@ -11384,7 +11635,7 @@ class WebTerminalManager {
           try {
             const w = node_child_process.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;
@@ -11435,13 +11686,13 @@ class WebTerminalManager {
     try {
       const cmd = node_child_process.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 = node_child_process.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;
@@ -11468,7 +11719,7 @@ class WebTerminalManager {
     try {
       const probe = node_child_process.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;
@@ -11486,7 +11737,7 @@ class WebTerminalManager {
         const hex = sgrWheelHexBytes(action.dir, action.count, Number(paneW) || 80, Number(paneH) || 24);
         node_child_process.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;
@@ -11494,7 +11745,7 @@ class WebTerminalManager {
       if (action.kind === "page-keys") {
         node_child_process.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;
@@ -11502,19 +11753,19 @@ class WebTerminalManager {
       if (action.kind === "keys") {
         node_child_process.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;
       }
       node_child_process.spawnSync(
         "tmux",
-        ["copy-mode", "-e", "-t", name],
+        tmuxArgs(["copy-mode", "-e", "-t", name]),
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       );
       node_child_process.spawnSync(
         "tmux",
-        [
+        tmuxArgs([
           "send-keys",
           "-X",
           "-t",
@@ -11522,7 +11773,7 @@ class WebTerminalManager {
           "-N",
           String(action.count),
           action.dir === "up" ? "scroll-up" : "scroll-down"
-        ],
+        ]),
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       );
     } catch {
@@ -11556,14 +11807,14 @@ class WebTerminalManager {
     const name = `vh-${terminalId}`;
     try {
       if (ifAbsent) {
-        const cur = node_child_process.spawnSync("tmux", ["show-options", "-t", name, "-v", "@vh_title"], { encoding: "utf8", env: ptyEnv() });
+        const cur = node_child_process.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 = node_child_process.spawnSync("tmux", ["set-option", "-t", name, "@vh_title", title], { stdio: "ignore", env: ptyEnv() });
+      const r = node_child_process.spawnSync("tmux", tmuxArgs(["set-option", "-t", name, "@vh_title", title]), { stdio: "ignore", env: ptyEnv() });
       if (r.status !== 0) return false;
       if (!ifAbsent) {
         try {
-          node_child_process.spawnSync("tmux", ["set-option", "-t", name, "@vh_title_manual", "1"], { stdio: "ignore", env: ptyEnv() });
+          node_child_process.spawnSync("tmux", tmuxArgs(["set-option", "-t", name, "@vh_title_manual", "1"]), { stdio: "ignore", env: ptyEnv() });
         } catch {
         }
       }
@@ -11581,7 +11832,7 @@ class WebTerminalManager {
     if (!valid) return false;
     const name = `vh-${terminalId}`;
     try {
-      const r = node_child_process.spawnSync("tmux", ["set-option", "-t", name, "@vh_tags", JSON.stringify(valid)], {
+      const r = node_child_process.spawnSync("tmux", tmuxArgs(["set-option", "-t", name, "@vh_tags", JSON.stringify(valid)]), {
         stdio: "ignore",
         env: ptyEnv()
       });
@@ -11613,10 +11864,11 @@ function parseVhTerminals(stdout, hostname = os.hostname()) {
 }
 function runTmux(args, input) {
   try {
-    const r = node_child_process.spawnSync("tmux", args, {
+    const r = node_child_process.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() };
@@ -15236,9 +15488,11 @@ exports.readSettings = readSettings;
 exports.readVhTerminal = readVhTerminal;
 exports.releaseDaemonLock = releaseDaemonLock;
 exports.resolveCliUpdateCheckInterval = resolveCliUpdateCheckInterval;
+exports.scrubTmuxClientEnv = scrubTmuxClientEnv;
 exports.sendToVhTerminal = sendToVhTerminal;
 exports.startOfflineReconnection = startOfflineReconnection;
 exports.summarizeSpawnSessionForLog = summarizeSpawnSessionForLog;
+exports.tmuxArgs = tmuxArgs;
 exports.updateSettings = updateSettings;
 exports.wrapCommand = wrapCommand;
 exports.writeCredentialsDataKey = writeCredentialsDataKey;