claude-code-best 1.8.0 → 1.9.0

package/dist/{chunk-n9p0ss91.js → chunk-2pr8dmkw.js}

@@ -9,14 +9,14 @@ import {
   initializeTeammateContextFromSession,
   recordTipShown,
   shouldShowDesktopUpsellStartup
-} from "./chunk-qkvakhx1.js";
+} from "./chunk-e732zxst.js";
 import {
   useManagePlugins
-} from "./chunk-e1awvmbq.js";
+} from "./chunk-a0kvb5h1.js";
 import {
   applySkillImprovement,
   startBackgroundHousekeeping
-} from "./chunk-bp5dhef8.js";
+} from "./chunk-f2k7vxg3.js";
 import {
   SANDBOX_NETWORK_ACCESS_TOOL_NAME,
   createCronScheduler,
@@ -26,7 +26,7 @@ import {
   init_cronJitterConfig,
   init_cronScheduler,
   reconcileMarketplaces
-} from "./chunk-8xa1kfya.js";
+} from "./chunk-ed7z1w7p.js";
 import {
   computeStandaloneAgentContext,
   exitRestoredWorktree,
@@ -34,13 +34,13 @@ import {
   restoreSessionStateFromLog,
   restoreWorktreeForResume,
   skillChangeDetector
-} from "./chunk-ap8sbteg.js";
+} from "./chunk-ww3p4y9a.js";
 import {
   useFpsMetrics
 } from "./chunk-x0ym1db4.js";
 import {
   BoundedUUIDSet
-} from "./chunk-vmxyzqbq.js";
+} from "./chunk-rdbr0mc5.js";
 import {
   consumeEarlyInput
 } from "./chunk-46fcr28b.js";
@@ -53,62 +53,84 @@ import {
   messagesAfterAreOnlySynthetic,
   processUserInput,
   selectableUserMessagesFilter
-} from "./chunk-bgc5qnd6.js";
+} from "./chunk-0sz4ykc8.js";
 import {
   init_sprites,
   renderFace,
   renderSprite,
   spriteFrameCount
-} from "./chunk-v1k15ae4.js";
+} from "./chunk-yz7f0ahp.js";
 import {
-  exports_useVoice,
-  init_useVoice
-} from "./chunk-zr8jx1me.js";
+  exports_lanBeacon,
+  init_lanBeacon
+} from "./chunk-c12prd7j.js";
+import {
+  clearMasterMutedPipes,
+  clearSendOverrides,
+  exports_useMasterMonitor,
+  getAllSlaveClients,
+  getSendOverrideVersion,
+  getSlaveClientRegistryVersion,
+  hasSendOverride,
+  init_pipeMuteState,
+  init_useMasterMonitor,
+  setMasterMutedPipes,
+  subscribeSendOverride,
+  subscribeToSlaveClientRegistry
+} from "./chunk-yashkw24.js";
 import {
   RemoteCallout,
   init_RemoteCallout
-} from "./chunk-hr3btr8b.js";
+} from "./chunk-yhb095v3.js";
 import {
   PermissionDialog,
   PermissionRequestTitle,
   init_PermissionDialog,
   init_PermissionRequestTitle
 } from "./chunk-2pjptqfa.js";
+import {
+  exports_useVoice,
+  init_useVoice
+} from "./chunk-mja6394w.js";
 import {
   ExitFlow,
   init_ExitFlow
-} from "./chunk-650dg84f.js";
+} from "./chunk-t688crr3.js";
 import {
   init_exportRenderer,
   renderMessagesToPlainText
-} from "./chunk-4w14tqd3.js";
-import {
-  init_useMergedTools,
-  useMergedTools
-} from "./chunk-jkpnx6d7.js";
-import {
-  init_toolPool,
-  mergeAndFilterTools
-} from "./chunk-hy4eg9rh.js";
-import {
-  init_refresh,
-  refreshActivePlugins
-} from "./chunk-tkwtc12m.js";
+} from "./chunk-km555nmz.js";
 import {
   init_setup,
   isChromeExtensionInstalled,
   shouldEnableClaudeInChrome
-} from "./chunk-svkdak63.js";
+} from "./chunk-9s6wjjgc.js";
 import {
-  init_autoModeDenials,
-  recordAutoModeDenial
-} from "./chunk-bcfd2zw7.js";
+  getTeammateStatuses,
+  init_teamDiscovery
+} from "./chunk-ktvcgnpw.js";
+import {
+  exports_pipeRegistry,
+  init_pipeRegistry
+} from "./chunk-c2tvdak4.js";
+import {
+  init_refresh,
+  refreshActivePlugins
+} from "./chunk-26bxxwf6.js";
 import {
   FastModePicker,
   getFastIconString,
   init_FastIcon,
   init_fast
-} from "./chunk-kegv11w9.js";
+} from "./chunk-q9ekcqx7.js";
+import {
+  init_useMergedTools,
+  useMergedTools
+} from "./chunk-6f8rdjpr.js";
+import {
+  init_toolPool,
+  mergeAndFilterTools
+} from "./chunk-x4xsq1s2.js";
 import {
   BackgroundTasksDialog,
   enterTeammateView,
@@ -119,22 +141,26 @@ import {
   isTerminalStatus,
   shouldHideTasksFooter,
   stopOrDismissAgent
-} from "./chunk-egwsh2d3.js";
+} from "./chunk-zvh8p8b8.js";
 import {
   fromSDKCompactMetadata,
   init_mappers
-} from "./chunk-vank0acb.js";
+} from "./chunk-040fs3bs.js";
 import {
   init_Dialog
 } from "./chunk-w5j0dhpp.js";
+import {
+  init_autoModeDenials,
+  recordAutoModeDenial
+} from "./chunk-bcfd2zw7.js";
 import {
   generateSessionName,
   init_generateSessionName
-} from "./chunk-rhfz4rps.js";
+} from "./chunk-fgzywhh2.js";
 import {
   generateSessionTitle,
   init_sessionTitle
-} from "./chunk-hdwtr2yf.js";
+} from "./chunk-y8pkn3xy.js";
 import {
   Fuse,
   init_fuse
@@ -149,7 +175,7 @@ import {
   useSetPromptOverlay,
   useSetPromptOverlayDialog,
   useUnseenDivider
-} from "./chunk-av4xr370.js";
+} from "./chunk-gdrmj2pf.js";
 import {
   MCPConnectionManager,
   filterPermissionRelayClients,
@@ -157,35 +183,27 @@ import {
   init_channelPermissions,
   shortRequestId,
   truncateForPreview
-} from "./chunk-rf16rpg8.js";
+} from "./chunk-6h2zne6a.js";
 import {
   init_pluginAutoupdate,
   onPluginsAutoUpdated
-} from "./chunk-kh3eed6x.js";
+} from "./chunk-a6a879pe.js";
 import {
   CHANNEL_PERMISSION_REQUEST_METHOD,
   findChannelEntry,
   init_channelNotification
-} from "./chunk-gbm9xcsb.js";
+} from "./chunk-kaxc456a.js";
 import {
   $toString,
   init_server
 } from "./chunk-jdgeec04.js";
-import {
-  init_useSettingsErrors,
-  useSettingsErrors
-} from "./chunk-ebhvnagj.js";
-import {
-  detectUnreachableRules,
-  init_shadowedRuleDetection
-} from "./chunk-4fghnb4h.js";
 import {
   PromptInputHelpMenu,
   init_PromptInputHelpMenu,
   init_utils as init_utils3,
   isNonSpacePrintable,
   isVimModeEnabled
-} from "./chunk-pzrjj7h0.js";
+} from "./chunk-79bf1qvf.js";
 import {
   editFileInEditor,
   editPromptInEditor,
@@ -193,11 +211,11 @@ import {
   init_editor,
   init_promptEditor,
   openFileInExternalEditor
-} from "./chunk-sa4v49yg.js";
+} from "./chunk-sdcwxxk6.js";
 import {
   getResolvedLanguage,
   init_language
-} from "./chunk-dmsneaaq.js";
+} from "./chunk-0bmy4kjm.js";
 import {
   ModelPicker,
   effortLevelToSymbol,
@@ -206,19 +224,23 @@ import {
   init_ModelPicker,
   init_extraUsage,
   isBilledAsExtraUsage
-} from "./chunk-z9fjyp10.js";
+} from "./chunk-dxdkze8z.js";
 import {
   init_useSearchInput,
   useSearchInput
-} from "./chunk-rqf8xzbe.js";
+} from "./chunk-acad1ptb.js";
 import {
-  init_Feedback,
-  redactSensitiveInfo
-} from "./chunk-y3f0q1yz.js";
+  init_useSettingsErrors,
+  useSettingsErrors
+} from "./chunk-8qraqb46.js";
+import {
+  detectUnreachableRules,
+  init_shadowedRuleDetection
+} from "./chunk-64m2p0fr.js";
 import {
   clearConversation,
   init_conversation
-} from "./chunk-e41z7j8n.js";
+} from "./chunk-v9qatj12.js";
 import {
   applyFileSuggestion,
   findLongestCommonPrefix,
@@ -226,34 +248,34 @@ import {
   init_fileSuggestions,
   onIndexBuildComplete,
   startBackgroundCacheRefresh
-} from "./chunk-x9jtstht.js";
+} from "./chunk-73yp3q0h.js";
 import {
   getDirectoryCompletions,
   getPathCompletions,
   init_directoryCompletion,
   isPathLikeToken
-} from "./chunk-1g7vd9aw.js";
+} from "./chunk-tamranmv.js";
 import {
   PromptInputFooterSuggestions,
   init_PromptInputFooterSuggestions
-} from "./chunk-4djqhsnj.js";
+} from "./chunk-xk0tvbw1.js";
 import {
   findBtwTriggerPositions,
   init_sideQuestion
-} from "./chunk-6b6pv595.js";
+} from "./chunk-12yhesm9.js";
+import {
+  init_Feedback,
+  redactSensitiveInfo
+} from "./chunk-2y22jqr5.js";
 import {
   checkAndDisableAutoModeIfNeeded,
   init_bypassPermissionsKillswitch,
   useKickOffCheckAndDisableAutoModeIfNeeded
-} from "./chunk-jwa7qf81.js";
+} from "./chunk-27hsrkpd.js";
 import {
   init_useMainLoopModel,
   useMainLoopModel
-} from "./chunk-8wn7137w.js";
-import {
-  attachNdjsonFramer,
-  init_ndjsonFramer
-} from "./chunk-r854e43q.js";
+} from "./chunk-0xbnw7e9.js";
 import {
   AGENT_COLORS,
   AGENT_COLOR_TO_THEME_COLOR,
@@ -416,6 +438,7 @@ import {
   exports_contextCollapse,
   exports_coordinatorMode,
   exports_loadAgentsDir,
+  exports_messages,
   exports_sessionStorage,
   extractAgentIdsFromMessages,
   extractBashToolsFromMessages,
@@ -870,6 +893,7 @@ import {
   readCapped,
   readUnreadMessages,
   reconstructContentReplacementState,
+  recordAttributionSnapshot,
   recordTranscript,
   registerLeaderSetToolPermissionContext,
   registerLeaderToolUseConfirmQueue,
@@ -957,14 +981,15 @@ import {
   verifyApiKey,
   withMemoryCorrectionHint,
   writeToMailbox
-} from "./chunk-m2akjkdt.js";
+} from "./chunk-abcmnpw1.js";
 import {
   init_undercover,
   isUndercover
-} from "./chunk-2x9v6ryw.js";
+} from "./chunk-9z8x61ch.js";
 import {
+  incrementPromptCount,
   init_commitAttribution
-} from "./chunk-r0qx6xgc.js";
+} from "./chunk-enqry8t5.js";
 import {
   DEFAULT_TASKS_MODE_TASK_LIST_ID,
   claimTask,
@@ -986,7 +1011,7 @@ import {
   syncTeammateMode,
   unassignTeammateTasks,
   updateTask
-} from "./chunk-2qnmyxpy.js";
+} from "./chunk-g4jdxw9z.js";
 import {
   asSystemPrompt,
   emitTaskTerminatedSdk,
@@ -1000,36 +1025,43 @@ import {
   notifyAutomationStateChanged,
   setNextTickAt,
   shouldTick
-} from "./chunk-7rzk7d37.js";
-import {
-  escapeXml,
-  init_xml as init_xml2
-} from "./chunk-7hqaeswx.js";
+} from "./chunk-4c843krn.js";
 import {
   init_bridgeEnabled,
   isBridgeEnabled
-} from "./chunk-0nh980p8.js";
+} from "./chunk-w710jpa2.js";
+import {
+  escapeXml,
+  init_xml as init_xml2
+} from "./chunk-skhb9mm3.js";
 import {
   CLAUDE_IN_CHROME_MCP_SERVER_NAME,
   init_common,
   isTrackedClaudeInChromeTabId
-} from "./chunk-vvj9yfd6.js";
+} from "./chunk-nb32de90.js";
+import {
+  exports_pipeTransport,
+  getPipeDisplayRole,
+  getPipeIpc,
+  init_pipeTransport,
+  isPipeControlled
+} from "./chunk-mfhds0dp.js";
 import {
   RARITY_COLORS,
   getCompanion,
   init_companion,
   init_types
-} from "./chunk-n0vth4gp.js";
+} from "./chunk-hprabxne.js";
 import {
   init_shellQuote,
   quote,
   tryParseShellCommand
-} from "./chunk-h0jkyyzh.js";
+} from "./chunk-t33p3qh3.js";
 import {
   init_useDoublePress,
   init_useExitOnCtrlCDWithKeybindings,
   useExitOnCtrlCDWithKeybindings
-} from "./chunk-xrcw33a6.js";
+} from "./chunk-g5snnfpz.js";
 import {
   READ_FILE_STATE_CACHE_SIZE,
   createFileStateCacheWithSizeLimit,
@@ -1041,41 +1073,41 @@ import {
   init_projectOnboardingState,
   init_terminalSetup,
   maybeMarkProjectOnboardingComplete
-} from "./chunk-rm1mheme.js";
+} from "./chunk-xsdh0nhd.js";
 import {
   init_useKeybinding
 } from "./chunk-rd2884ff.js";
 import {
   init_poorMode,
   isPoorModeActive
-} from "./chunk-4wvqsj82.js";
+} from "./chunk-sxkyxfc7.js";
 import {
   hasVoiceAuth,
   init_voiceModeEnabled,
   isVoiceGrowthBookEnabled
-} from "./chunk-by6f5f3f.js";
+} from "./chunk-g1fmphn5.js";
+import {
+  init_browser,
+  openBrowser
+} from "./chunk-1fexraxj.js";
 import {
   getOAuthHeaders,
   init_api,
   prepareApiRequest,
   updateSessionTitle
-} from "./chunk-zcg5wkge.js";
-import {
-  init_browser,
-  openBrowser
-} from "./chunk-ns5ckn0j.js";
+} from "./chunk-kty5fqkx.js";
 import {
   endInteractionSpan,
   init_events,
   init_sessionTracing,
   logOTelEvent
-} from "./chunk-pm491jb5.js";
+} from "./chunk-7at6y3z2.js";
 import {
   IT2_COMMAND,
   init_detection,
   isInsideTmux,
   isInsideTmuxSync
-} from "./chunk-7w71dt0w.js";
+} from "./chunk-a2yz9sk4.js";
 import {
   TEAM_LEAD_NAME,
   TMUX_COMMAND,
@@ -1086,7 +1118,7 @@ import {
   extractCommandArguments,
   init_parser,
   parseCommand
-} from "./chunk-8eg4phfy.js";
+} from "./chunk-dsk2j7pz.js";
 import {
   ALLOWED_OFFICIAL_MARKETPLACE_NAMES,
   AwsAuthStatusManager,
@@ -1194,17 +1226,17 @@ import {
   toExternalPermissionMode,
   truncateToLines,
   updateSettingsForSource
-} from "./chunk-za24x8e6.js";
+} from "./chunk-1dh9y2g9.js";
 import {
   init_json,
   safeParseJSON
-} from "./chunk-ec9bfefg.js";
+} from "./chunk-0rjgkz6a.js";
 import {
   expandPath,
   getDirectoryForPath,
   init_path,
   toRelativePath
-} from "./chunk-6383ssyr.js";
+} from "./chunk-nkn6kceq.js";
 import {
   count,
   getAgentName,
@@ -1227,12 +1259,12 @@ import {
 import {
   getPlatform,
   init_platform
-} from "./chunk-ctr3c1sg.js";
+} from "./chunk-rcz0e093.js";
 import {
   env,
   getHostPlatformForAnalytics,
   init_env
-} from "./chunk-1aaad6af.js";
+} from "./chunk-bc7vdtyx.js";
 import {
   init_bundledMode,
   isInBundledMode
@@ -1255,7 +1287,7 @@ import {
   formatTokens,
   init_format,
   truncateToWidth
-} from "./chunk-k3h49w53.js";
+} from "./chunk-0s5rp3xp.js";
 import {
   firstGrapheme,
   getGraphemeSegmenter,
@@ -1328,19 +1360,19 @@ import {
   init_diagLogs,
   init_git,
   logForDiagnosticsNoPII
-} from "./chunk-a6aj70ts.js";
+} from "./chunk-e80zc1av.js";
 import {
   init_memoize,
   memoizeWithLRU
-} from "./chunk-vyxrqq2j.js";
+} from "./chunk-ntdnzp2z.js";
 import {
   execFileNoThrow,
   init_execFileNoThrow
-} from "./chunk-24dgse44.js";
+} from "./chunk-9d7dhwhn.js";
 import {
   getCwd,
   init_cwd
-} from "./chunk-tv74hgw9.js";
+} from "./chunk-znv3atvc.js";
 import {
   BASH_INPUT_TAG,
   CHANNEL_TAG,
@@ -1355,11 +1387,11 @@ import {
   init_log,
   init_xml,
   logError
-} from "./chunk-jgdm5p7t.js";
+} from "./chunk-2cyjtt9z.js";
 import {
   init_which,
   which
-} from "./chunk-wx6n79wt.js";
+} from "./chunk-x313wqn1.js";
 import {
   figures_default,
   init_figures
@@ -1380,9 +1412,10 @@ import {
   registerCleanup,
   safeResolvePath,
   toError
-} from "./chunk-edk6reza.js";
+} from "./chunk-wb2sg18w.js";
 import {
   createSignal,
+  exports_state,
   getAllowedChannels,
   getBudgetContinuationCount,
   getCurrentTurnTokenBudget,
@@ -1429,13 +1462,12 @@ import {
   snapshotOutputTokensForTurn,
   switchSession,
   updateLastInteractionTime
-} from "./chunk-gzp6rza1.js";
+} from "./chunk-wmgyt01k.js";
 import {
   APIUserAbortError,
   init_sdk
-} from "./chunk-z0csm2zq.js";
+} from "./chunk-jg5ac2fy.js";
 import {
-  getClaudeConfigHomeDir,
   init_envUtils,
   isEnvDefinedFalsy,
   isEnvTruthy,
@@ -2150,6 +2182,194 @@ var init_VoiceIndicator = __esm(() => {
   PROCESSING_BRIGHT = { r: 185, g: 185, b: 185 };
 });
 
+// src/utils/pipePermissionRelay.ts
+var exports_pipePermissionRelay = {};
+__export(exports_pipePermissionRelay, {
+  tryRelayPipePermissionRequest: () => tryRelayPipePermissionRequest,
+  setRelayMuted: () => setRelayMuted,
+  setPipeRelay: () => setPipeRelay,
+  resolvePipePermissionResponse: () => resolvePipePermissionResponse,
+  notifyPipePermissionCancel: () => notifyPipePermissionCancel,
+  makePipePermissionResponsePayload: () => makePipePermissionResponsePayload,
+  isRelayMuted: () => isRelayMuted,
+  getPipeRelay: () => getPipeRelay,
+  forgetPipePermissionRequest: () => forgetPipePermissionRequest,
+  clearPendingPipePermissions: () => clearPendingPipePermissions,
+  cancelPipePermissionRequest: () => cancelPipePermissionRequest
+});
+import { randomUUID as randomUUID7 } from "crypto";
+function setRelayMuted(muted) {
+  _relayMuted = muted;
+}
+function isRelayMuted() {
+  return _relayMuted;
+}
+function setPipeRelay(fn) {
+  _pipeRelay = fn;
+  if (!fn)
+    _relayMuted = false;
+}
+function getPipeRelay() {
+  return _pipeRelay;
+}
+function getPipeSender() {
+  return _pipeRelay ?? null;
+}
+function tryRelayPipePermissionRequest(toolUseConfirm, onResponse) {
+  if (_relayMuted)
+    return null;
+  const send = getPipeSender();
+  if (!send)
+    return null;
+  const requestId = randomUUID7();
+  const payload = {
+    requestId,
+    toolName: toolUseConfirm.tool.name,
+    toolUseID: toolUseConfirm.toolUseID,
+    description: toolUseConfirm.description,
+    input: toolUseConfirm.input,
+    permissionResult: toolUseConfirm.permissionResult,
+    permissionPromptStartTimeMs: toolUseConfirm.permissionPromptStartTimeMs
+  };
+  pendingPipePermissions.set(requestId, { onResponse });
+  send({ type: "permission_request", data: JSON.stringify(payload) });
+  return requestId;
+}
+function resolvePipePermissionResponse(payload) {
+  const pending = pendingPipePermissions.get(payload.requestId);
+  if (!pending)
+    return false;
+  pendingPipePermissions.delete(payload.requestId);
+  pending.onResponse(payload);
+  return true;
+}
+function cancelPipePermissionRequest(requestId, reason) {
+  const pending = pendingPipePermissions.get(requestId);
+  if (!pending)
+    return false;
+  pendingPipePermissions.delete(requestId);
+  pending.onResponse({
+    requestId,
+    behavior: "deny",
+    feedback: reason ?? "Permission request was cancelled by main."
+  });
+  return true;
+}
+function forgetPipePermissionRequest(requestId) {
+  if (!requestId)
+    return;
+  pendingPipePermissions.delete(requestId);
+}
+function notifyPipePermissionCancel(requestId, reason) {
+  if (!requestId)
+    return;
+  if (_relayMuted)
+    return;
+  const send = getPipeSender();
+  if (!send)
+    return;
+  send({
+    type: "permission_cancel",
+    data: JSON.stringify({ requestId, reason })
+  });
+}
+function clearPendingPipePermissions(reason = "Pipe permission relay was disconnected.") {
+  for (const requestId of [...pendingPipePermissions.keys()]) {
+    cancelPipePermissionRequest(requestId, reason);
+  }
+}
+function makePipePermissionResponsePayload(requestId, behavior, updatedInputOrFeedback, permissionUpdatesOrContentBlocks, feedback, contentBlocks) {
+  if (behavior === "allow") {
+    return {
+      requestId,
+      behavior,
+      updatedInput: updatedInputOrFeedback ?? {},
+      permissionUpdates: permissionUpdatesOrContentBlocks ?? [],
+      feedback,
+      contentBlocks
+    };
+  }
+  return {
+    requestId,
+    behavior,
+    feedback: updatedInputOrFeedback,
+    contentBlocks: permissionUpdatesOrContentBlocks
+  };
+}
+var pendingPipePermissions, _pipeRelay = null, _relayMuted = false;
+var init_pipePermissionRelay = __esm(() => {
+  pendingPipePermissions = new Map;
+});
+
+// src/components/FeedbackSurvey/submitTranscriptShare.ts
+import { readFile, stat } from "fs/promises";
+async function submitTranscriptShare(messages, trigger, appearanceId) {
+  try {
+    logForDebugging("Collecting transcript for sharing", { level: "info" });
+    const transcript = normalizeMessagesForAPI(messages);
+    const agentIds = extractAgentIdsFromMessages(messages);
+    const subagentTranscripts = await loadSubagentTranscripts(agentIds);
+    let rawTranscriptJsonl;
+    try {
+      const transcriptPath = getTranscriptPath();
+      const { size } = await stat(transcriptPath);
+      if (size <= MAX_TRANSCRIPT_READ_BYTES) {
+        rawTranscriptJsonl = await readFile(transcriptPath, "utf-8");
+      } else {
+        logForDebugging(`Skipping raw transcript read: file too large (${size} bytes)`, { level: "warn" });
+      }
+    } catch {}
+    const data = {
+      trigger,
+      version: "2.1.888",
+      platform: process.platform,
+      transcript,
+      subagentTranscripts: Object.keys(subagentTranscripts).length > 0 ? subagentTranscripts : undefined,
+      rawTranscriptJsonl
+    };
+    const content = redactSensitiveInfo(jsonStringify(data));
+    await checkAndRefreshOAuthTokenIfNeeded();
+    const authResult = getAuthHeaders();
+    if (authResult.error) {
+      return { success: false };
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": getUserAgent(),
+      ...authResult.headers
+    };
+    const response = await axios_default.post("https://api.anthropic.com/api/claude_code_shared_session_transcripts", { content, appearance_id: appearanceId }, {
+      headers,
+      timeout: 30000
+    });
+    if (response.status === 200 || response.status === 201) {
+      const result = response.data;
+      logForDebugging("Transcript shared successfully", { level: "info" });
+      return {
+        success: true,
+        transcriptId: result?.transcript_id
+      };
+    }
+    return { success: false };
+  } catch (err) {
+    logForDebugging(errorMessage(err), {
+      level: "error"
+    });
+    return { success: false };
+  }
+}
+var init_submitTranscriptShare = __esm(() => {
+  init_axios();
+  init_auth();
+  init_debug();
+  init_errors();
+  init_http();
+  init_messages();
+  init_sessionStorage();
+  init_slowOperations();
+  init_Feedback();
+});
+
 // src/hooks/useVoiceIntegration.tsx
 var exports_useVoiceIntegration = {};
 __export(exports_useVoiceIntegration, {
@@ -2514,10 +2734,45 @@ var exports_useFrustrationDetection = {};
 __export(exports_useFrustrationDetection, {
   useFrustrationDetection: () => useFrustrationDetection
 });
-function useFrustrationDetection(_messages, _isLoading, _hasActivePrompt, _otherSurveyOpen) {
-  return { state: "closed", handleTranscriptSelect: () => {} };
+function detectFrustration(messages) {
+  const apiErrors = messages.filter((m) => m.isApiErrorMessage);
+  return apiErrors.length >= 2;
 }
-var init_useFrustrationDetection = () => {};
+function useFrustrationDetection(messages, isLoading, hasActivePrompt, otherSurveyOpen) {
+  const [state, setState] = import_react122.useState("closed");
+  const config = getGlobalConfig();
+  if (config.transcriptShareDismissed) {
+    return { state: "closed", handleTranscriptSelect: () => {} };
+  }
+  if (!isPolicyAllowed("product_feedback")) {
+    return { state: "closed", handleTranscriptSelect: () => {} };
+  }
+  if (isLoading || hasActivePrompt || otherSurveyOpen) {
+    return { state: "closed", handleTranscriptSelect: () => {} };
+  }
+  const frustrated = detectFrustration(messages);
+  const effectiveState = frustrated && state === "closed" ? "transcript_prompt" : state;
+  function handleTranscriptSelect(choice) {
+    if (choice === "yes") {
+      submitTranscriptShare(messages, "frustration", crypto.randomUUID());
+      setState("submitted");
+    } else {
+      saveGlobalConfig((current) => ({
+        ...current,
+        transcriptShareDismissed: true
+      }));
+      setState("closed");
+    }
+  }
+  return { state: effectiveState, handleTranscriptSelect };
+}
+var import_react122;
+var init_useFrustrationDetection = __esm(() => {
+  init_config2();
+  init_policyLimits();
+  init_submitTranscriptShare();
+  import_react122 = __toESM(require_react(), 1);
+});
 
 // src/hooks/notifs/useAntOrgWarningNotification.ts
 var exports_useAntOrgWarningNotification = {};
@@ -2533,9 +2788,9 @@ __export(exports_useProactive, {
   useProactive: () => useProactive
 });
 function useProactive(opts) {
-  const optsRef = import_react122.useRef(opts);
+  const optsRef = import_react123.useRef(opts);
   optsRef.current = opts;
-  import_react122.useEffect(() => {
+  import_react123.useEffect(() => {
     if (!isProactiveActive())
       return;
     let timer = null;
@@ -2584,13 +2839,13 @@ function useProactive(opts) {
     isContextBlocked()
   ]);
 }
-var import_react122, TICK_INTERVAL_MS = 30000;
+var import_react123, TICK_INTERVAL_MS = 30000;
 var init_useProactive = __esm(() => {
   init_xml();
   init_cwd();
   init_autonomyRuns();
   init_proactive();
-  import_react122 = __toESM(require_react(), 1);
+  import_react123 = __toESM(require_react(), 1);
 });
 
 // src/hooks/useScheduledTasks.ts
@@ -2603,11 +2858,11 @@ function useScheduledTasks({
   assistantMode = false,
   setMessages
 }) {
-  const isLoadingRef = import_react123.useRef(isLoading);
+  const isLoadingRef = import_react124.useRef(isLoading);
   isLoadingRef.current = isLoading;
   const store = useAppStateStore();
   const setAppState = useSetAppState();
-  import_react123.useEffect(() => {
+  import_react124.useEffect(() => {
     if (!isKairosCronEnabled())
       return;
     const enqueueForLead = async (prompt) => {
@@ -2688,7 +2943,7 @@ function formatCronFireTime(d) {
     minute: "2-digit"
   }).replace(/,? at |, /, " ").replace(/ ([AP]M)/, (_, ampm) => ampm.toLowerCase());
 }
-var import_react123;
+var import_react124;
 var init_useScheduledTasks = __esm(() => {
   init_AppState();
   init_Task();
@@ -2704,7 +2959,889 @@ var init_useScheduledTasks = __esm(() => {
   init_messageQueueManager();
   init_messages();
   init_workloadContext();
-  import_react123 = __toESM(require_react(), 1);
+  import_react124 = __toESM(require_react(), 1);
+});
+
+// src/hooks/useSlaveNotifications.ts
+var exports_useSlaveNotifications = {};
+__export(exports_useSlaveNotifications, {
+  useSlaveNotifications: () => useSlaveNotifications
+});
+function foldSlaveNotif(acc, _incoming) {
+  if (!("text" in acc))
+    return acc;
+  const match = acc.text.match(/\((\d+)\)$/);
+  const count2 = match ? parseInt(match[1], 10) + 1 : 2;
+  const base = acc.text.replace(/\s*\(\d+\)$/, "");
+  return {
+    ...acc,
+    text: `${base} (${count2})`,
+    fold: foldSlaveNotif
+  };
+}
+function truncate(s, max) {
+  if (s.length <= max)
+    return s;
+  return s.slice(0, max) + "\u2026";
+}
+function useSlaveNotifications() {
+  const role = useAppState((s) => getPipeIpc(s).role);
+  const slaves = useAppState((s) => getPipeIpc(s).slaves);
+  const { addNotification } = useNotifications();
+  const lastSeenRef = import_react125.useRef({});
+  import_react125.useEffect(() => {
+    if (role !== "master")
+      return;
+    for (const [name, slave] of Object.entries(slaves)) {
+      const lastSeen = lastSeenRef.current[name] ?? 0;
+      const newEntries = slave.history.slice(lastSeen);
+      lastSeenRef.current[name] = slave.history.length;
+      for (const entry of newEntries) {
+        const notification = makeNotification(name, entry);
+        if (notification) {
+          addNotification(notification);
+        }
+      }
+    }
+    for (const name of Object.keys(lastSeenRef.current)) {
+      if (!(name in slaves)) {
+        delete lastSeenRef.current[name];
+      }
+    }
+  }, [addNotification, role, slaves]);
+}
+function makeNotification(slaveName, entry) {
+  const shortName = slaveName.length > 16 ? `${slaveName.slice(0, 16)}\u2026` : slaveName;
+  switch (entry.type) {
+    case "prompt_ack":
+      return {
+        key: `slave-ack-${slaveName}`,
+        text: `[${shortName}] \u2713 \u5DF2\u63A5\u6536\u4EFB\u52A1`,
+        priority: "low",
+        timeoutMs: 2500,
+        fold: foldSlaveNotif
+      };
+    case "done":
+      return {
+        key: `slave-done-${slaveName}`,
+        text: `[${shortName}] \u2713 \u4EFB\u52A1\u5B8C\u6210`,
+        priority: "medium",
+        timeoutMs: 5000,
+        fold: foldSlaveNotif
+      };
+    case "error":
+      return {
+        key: `slave-error-${slaveName}`,
+        text: `[${shortName}] \u2717 \u9519\u8BEF: ${truncate(entry.content, 60)}`,
+        color: "error",
+        priority: "high",
+        timeoutMs: 8000
+      };
+    case "tool_start":
+      return {
+        key: `slave-tool-${slaveName}`,
+        text: `[${shortName}] \u5DE5\u5177: ${truncate(entry.content, 40)}`,
+        priority: "low",
+        timeoutMs: 3000,
+        fold: foldSlaveNotif
+      };
+    case "prompt":
+      return {
+        key: `slave-prompt-${slaveName}`,
+        text: `[${shortName}] \u25B6 \u5F00\u59CB\u5904\u7406: ${truncate(entry.content, 50)}`,
+        priority: "medium",
+        timeoutMs: 4000
+      };
+    case "stream":
+    case "tool_result":
+    default:
+      return null;
+  }
+}
+var import_react125;
+var init_useSlaveNotifications = __esm(() => {
+  init_notifications();
+  init_AppState();
+  init_pipeTransport();
+  import_react125 = __toESM(require_react(), 1);
+});
+
+// src/hooks/usePipeIpc.ts
+var exports_usePipeIpc = {};
+__export(exports_usePipeIpc, {
+  usePipeIpc: () => usePipeIpc
+});
+function removeDeadSlave(slaveName, store) {
+  mm().removeSlaveClient(slaveName);
+  store.setState((prev) => {
+    const pipeIpc = pt().getPipeIpc(prev);
+    const { [slaveName]: _removed, ...remainingSlaves } = pipeIpc.slaves;
+    return {
+      ...prev,
+      pipeIpc: {
+        ...pipeIpc,
+        role: Object.keys(remainingSlaves).length > 0 ? "master" : "main",
+        displayRole: Object.keys(remainingSlaves).length > 0 ? "master" : "main",
+        slaves: remainingSlaves,
+        selectedPipes: (pipeIpc.selectedPipes ?? []).filter((name) => name !== slaveName),
+        discoveredPipes: (pipeIpc.discoveredPipes ?? []).filter((pipe) => pipe.pipeName !== slaveName)
+      }
+    };
+  });
+}
+function refreshDiscoveredPipes(pipeName, aliveSubs, store) {
+  const freshDiscovered = aliveSubs.filter((sub) => sub.pipeName !== pipeName).map((sub) => ({
+    id: sub.id,
+    pipeName: sub.pipeName,
+    role: `sub-${sub.subIndex}`,
+    machineId: sub.machineId,
+    ip: sub.ip,
+    hostname: sub.hostname,
+    alive: true
+  }));
+  let lanDiscovered = [];
+  if (true) {
+    const beacon = lb().getLanBeacon();
+    if (beacon) {
+      const localNames = new Set(freshDiscovered.map((p) => p.pipeName));
+      localNames.add(pipeName);
+      for (const [pName, peer] of beacon.getPeers()) {
+        if (!localNames.has(pName)) {
+          lanDiscovered.push({
+            id: `lan-${pName}`,
+            pipeName: pName,
+            role: peer.role,
+            machineId: peer.machineId,
+            ip: peer.ip,
+            hostname: peer.hostname,
+            alive: true
+          });
+        }
+      }
+    }
+  }
+  const allDiscovered = [...freshDiscovered, ...lanDiscovered];
+  const prev = pt().getPipeIpc(store.getState());
+  const prevNames = (prev.discoveredPipes ?? []).map((p) => p.pipeName).join(",");
+  const newNames = allDiscovered.map((p) => p.pipeName).join(",");
+  if (prevNames === newNames)
+    return;
+  store.setState((prev2) => {
+    const pipeIpc = pt().getPipeIpc(prev2);
+    const aliveNames = new Set(allDiscovered.map((pipe) => pipe.pipeName));
+    return {
+      ...prev2,
+      pipeIpc: {
+        ...pipeIpc,
+        discoveredPipes: allDiscovered,
+        selectedPipes: (pipeIpc.selectedPipes ?? []).filter((name) => aliveNames.has(name))
+      }
+    };
+  });
+}
+function registerMessageHandlers(server, pipeName, machineId, store, handleIncomingPrompt) {
+  server.onMessage((msg, reply) => {
+    if (msg.type === "ping")
+      reply({ type: "pong" });
+  });
+  server.onMessage((msg, reply) => {
+    if (msg.type !== "attach_request")
+      return;
+    const state = store.getState();
+    const currentPipeState = pt().getPipeIpc(state);
+    if (pt().isPipeControlled(currentPipeState)) {
+      reply({ type: "attach_reject", data: "Already controlled" });
+      return;
+    }
+    const isLanPeer = msg.meta?.machineId && msg.meta.machineId !== machineId;
+    if (!isLanPeer && currentPipeState.role !== "sub") {
+      reply({
+        type: "attach_reject",
+        data: "Only sub sessions can be attached."
+      });
+      return;
+    }
+    reply({ type: "attach_accept" });
+    const clients = Array.from(server.clients);
+    const masterSocket = clients[clients.length - 1];
+    pp().setPipeRelay((relayMsg) => {
+      if (masterSocket && !masterSocket.destroyed) {
+        relayMsg.from = relayMsg.from ?? pipeName;
+        relayMsg.ts = relayMsg.ts ?? new Date().toISOString();
+        masterSocket.write(JSON.stringify(relayMsg) + `
+`);
+      }
+    });
+    store.setState((prev) => ({
+      ...prev,
+      pipeIpc: {
+        ...pt().getPipeIpc(prev),
+        role: "sub",
+        displayRole: pt().getPipeDisplayRole(pt().getPipeIpc(prev)),
+        attachedBy: msg.from ?? "unknown"
+      }
+    }));
+  });
+  server.onMessage((msg, reply) => {
+    if (msg.type === "prompt" && msg.data) {
+      const accepted = handleIncomingPrompt(msg.data);
+      if (accepted) {
+        reply({ type: "prompt_ack", data: "accepted" });
+      } else {
+        reply({
+          type: "error",
+          data: "Slave is busy and could not accept the prompt."
+        });
+      }
+    }
+  });
+  server.onMessage((msg, _reply) => {
+    if (msg.type !== "permission_response" && msg.type !== "permission_cancel")
+      return;
+    const { resolvePipePermissionResponse: resolvePipePermissionResponse2, cancelPipePermissionRequest: cancelPipePermissionRequest2 } = (init_pipePermissionRelay(), __toCommonJS(exports_pipePermissionRelay));
+    try {
+      const payload = msg.data ? JSON.parse(msg.data) : undefined;
+      if (!payload?.requestId)
+        return;
+      if (msg.type === "permission_response") {
+        resolvePipePermissionResponse2(payload);
+      } else {
+        cancelPipePermissionRequest2(payload.requestId, payload.reason);
+      }
+    } catch {}
+  });
+  server.onMessage((msg, _reply) => {
+    if (msg.type === "relay_mute") {
+      pp().setRelayMuted(true);
+    } else if (msg.type === "relay_unmute") {
+      pp().setRelayMuted(false);
+    }
+  });
+  server.onMessage((msg, _reply) => {
+    if (msg.type !== "detach")
+      return;
+    const { clearPendingPipePermissions: clearPendingPipePermissions2 } = (init_pipePermissionRelay(), __toCommonJS(exports_pipePermissionRelay));
+    clearPendingPipePermissions2("Pipe detached before permission was resolved.");
+    pp().setPipeRelay(null);
+    store.setState((prev) => ({
+      ...prev,
+      pipeIpc: (() => {
+        const pipeIpc = pt().getPipeIpc(prev);
+        const nextRole = pipeIpc.subIndex != null ? "sub" : "main";
+        const nextPipeState = { ...pipeIpc, role: nextRole, attachedBy: null };
+        return {
+          ...nextPipeState,
+          displayRole: pt().getPipeDisplayRole(nextPipeState)
+        };
+      })()
+    }));
+  });
+}
+function runMainHeartbeat(pipeName, machineId, store, disposed) {
+  (async () => {
+    try {
+      await pr().cleanupStaleEntries();
+      const aliveSubs = await pr().getAliveSubs();
+      refreshDiscoveredPipes(pipeName, aliveSubs, store);
+      const connectedSlaves = mm().getAllSlaveClients();
+      const aliveSubNames = new Set(aliveSubs.map((sub) => sub.pipeName));
+      const attachTargets = aliveSubs.map((sub) => ({
+        pipeName: sub.pipeName
+      }));
+      if (true) {
+        const beacon = lb().getLanBeacon();
+        if (beacon) {
+          const localNames = new Set(attachTargets.map((t) => t.pipeName));
+          localNames.add(pipeName);
+          for (const [pName, peer] of beacon.getPeers()) {
+            if (!localNames.has(pName)) {
+              attachTargets.push({
+                pipeName: pName,
+                tcpEndpoint: { host: peer.ip, port: peer.tcpPort }
+              });
+              aliveSubNames.add(pName);
+            }
+          }
+        }
+      }
+      const currentPipeState = pt().getPipeIpc(store.getState());
+      for (const target of attachTargets) {
+        if (target.pipeName === pipeName)
+          continue;
+        if (connectedSlaves.has(target.pipeName))
+          continue;
+        try {
+          const myName = currentPipeState.serverName ?? pipeName;
+          const client = await pt().connectToPipe(target.pipeName, myName, 3000, target.tcpEndpoint);
+          const attached = await new Promise((resolve) => {
+            const timeout2 = setTimeout(() => {
+              client.disconnect();
+              resolve(false);
+            }, 3000);
+            client.onMessage((msg) => {
+              if (msg.type === "attach_accept") {
+                clearTimeout(timeout2);
+                resolve(true);
+              } else if (msg.type === "attach_reject") {
+                clearTimeout(timeout2);
+                client.disconnect();
+                resolve(false);
+              }
+            });
+            client.send({
+              type: "attach_request",
+              meta: { machineId }
+            });
+          });
+          if (attached && !disposed.current) {
+            mm().addSlaveClient(target.pipeName, client);
+            client.on("disconnect", () => {
+              removeDeadSlave(target.pipeName, store);
+            });
+            store.setState((prev) => ({
+              ...prev,
+              pipeIpc: {
+                ...pt().getPipeIpc(prev),
+                role: "master",
+                displayRole: "master",
+                slaves: {
+                  ...pt().getPipeIpc(prev).slaves,
+                  [target.pipeName]: {
+                    name: target.pipeName,
+                    connectedAt: new Date().toISOString(),
+                    status: "idle",
+                    unreadCount: 0,
+                    history: []
+                  }
+                }
+              }
+            }));
+          }
+        } catch {}
+      }
+      let lanPeerNames = null;
+      if (true) {
+        const beacon = lb().getLanBeacon();
+        if (beacon) {
+          lanPeerNames = new Set(beacon.getPeers().keys());
+        }
+      }
+      for (const [slaveName, client] of connectedSlaves.entries()) {
+        const inLocalRegistry = aliveSubNames.has(slaveName);
+        const inLanBeacon = lanPeerNames?.has(slaveName) ?? false;
+        if (!client.connected || !inLocalRegistry && !inLanBeacon) {
+          removeDeadSlave(slaveName, store);
+        }
+      }
+    } catch {}
+  })();
+}
+function runSubHeartbeat(pipeName, machineId, entry, store, disposed) {
+  (async () => {
+    try {
+      const mainAlive = await pr().isMainAlive();
+      if (!mainAlive && !disposed.current) {
+        const registry = await pr().readRegistry();
+        const isSameMachine = pr().isMainMachine(machineId, registry);
+        if (isSameMachine) {
+          await pr().registerAsMain(entry);
+        } else {
+          await pr().revertToIndependent(pipeName);
+        }
+        store.setState((prev) => ({
+          ...prev,
+          pipeIpc: {
+            ...pt().getPipeIpc(prev),
+            role: "main",
+            subIndex: null,
+            displayRole: "main",
+            attachedBy: null
+          }
+        }));
+        pp().setPipeRelay(null);
+      }
+    } catch {}
+  })();
+}
+function usePipeIpc({
+  store,
+  handleIncomingPrompt
+}) {
+  if (false)
+    ;
+  import_react126.useEffect(() => {
+    const pipeName = `cli-${bs().getSessionId().slice(0, 8)}`;
+    const disposed = { current: false };
+    let heartbeatTimer = null;
+    let heartbeatBusy = false;
+    let pipeServer = null;
+    (async () => {
+      try {
+        const machId = await pr().getMachineId();
+        const mac = pr().getMacAddress();
+        const localIp = pt().getLocalIp();
+        const host = osm().hostname();
+        const roleResult = await pr().determineRole(machId);
+        const entry = {
+          id: pipeName,
+          pid: process.pid,
+          machineId: machId,
+          startedAt: Date.now(),
+          ip: localIp,
+          mac,
+          hostname: host,
+          pipeName
+        };
+        let initialRole = "main";
+        let subIndex = null;
+        let displayRole = "main";
+        if (roleResult.role === "main" || roleResult.role === "main-recover") {
+          await pr().registerAsMain(entry);
+        } else {
+          subIndex = roleResult.subIndex;
+          await pr().registerAsSub(entry, subIndex);
+          initialRole = "sub";
+          displayRole = `sub-${subIndex}`;
+        }
+        const server = await pt().createPipeServer(pipeName, { enableTcp: true, tcpPort: 0 });
+        pipeServer = server;
+        if (disposed.current) {
+          await server.close();
+          await pr().unregister(pipeName);
+          return;
+        }
+        if (server.tcpAddress) {
+          const beacon = new (lb()).LanBeacon({
+            pipeName,
+            machineId: machId,
+            hostname: host,
+            ip: localIp,
+            tcpPort: server.tcpAddress.port,
+            role: initialRole
+          });
+          beacon.start();
+          lb().setLanBeacon(beacon);
+          const entryWithTcp = {
+            ...entry,
+            tcpPort: server.tcpAddress.port,
+            lanVisible: true
+          };
+          if (initialRole === "main") {
+            await pr().registerAsMain(entryWithTcp);
+          } else if (subIndex != null) {
+            await pr().registerAsSub(entryWithTcp, subIndex);
+          }
+        }
+        store.setState((prev) => ({
+          ...prev,
+          pipeIpc: {
+            ...pt().getPipeIpc(prev),
+            serverName: pipeName,
+            role: initialRole,
+            subIndex,
+            displayRole,
+            localIp,
+            hostname: host,
+            machineId: machId,
+            mac
+          }
+        }));
+        registerMessageHandlers(server, pipeName, machId, store, handleIncomingPrompt);
+        const HEARTBEAT_INTERVAL_MS = 5000;
+        heartbeatTimer = setInterval(() => {
+          if (disposed.current || heartbeatBusy)
+            return;
+          heartbeatBusy = true;
+          const currentPipeState = pt().getPipeIpc(store.getState());
+          if (currentPipeState.role === "main" || currentPipeState.role === "master") {
+            runMainHeartbeat(pipeName, machId, store, disposed);
+          } else if (currentPipeState.role === "sub") {
+            runSubHeartbeat(pipeName, machId, entry, store, disposed);
+          }
+          setTimeout(() => {
+            heartbeatBusy = false;
+          }, 4000);
+        }, HEARTBEAT_INTERVAL_MS);
+      } catch {}
+    })();
+    return () => {
+      disposed.current = true;
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+      const allClients = mm().getAllSlaveClients();
+      for (const [name, client] of allClients.entries()) {
+        try {
+          client.send({ type: "detach" });
+        } catch {}
+        client.disconnect();
+        removeDeadSlave(name, store);
+      }
+      const beacon = lb().getLanBeacon();
+      if (beacon) {
+        try {
+          beacon.stop();
+        } catch {}
+        lb().setLanBeacon(null);
+      }
+      pr().unregister(pipeName).catch(() => {});
+      if (pipeServer) {
+        pipeServer.close().catch(() => {});
+        pipeServer = null;
+      }
+      pp().setPipeRelay(null);
+    };
+  }, []);
+}
+var import_react126, pt = () => (init_pipeTransport(), __toCommonJS(exports_pipeTransport)), pr = () => (init_pipeRegistry(), __toCommonJS(exports_pipeRegistry)), mm = () => (init_useMasterMonitor(), __toCommonJS(exports_useMasterMonitor)), bs = () => (init_state(), __toCommonJS(exports_state)), lb = () => (init_lanBeacon(), __toCommonJS(exports_lanBeacon)), pp = () => (init_pipePermissionRelay(), __toCommonJS(exports_pipePermissionRelay)), osm = () => __require("os");
+var init_usePipeIpc = __esm(() => {
+  import_react126 = __toESM(require_react(), 1);
+});
+
+// src/hooks/usePipeRelay.ts
+var exports_usePipeRelay = {};
+__export(exports_usePipeRelay, {
+  usePipeRelay: () => usePipeRelay
+});
+function usePipeRelay() {
+  const pipeReturnHadErrorRef = import_react127.useRef(false);
+  const relayPipeMessage = import_react127.useCallback((message) => {
+    const relay = getPipeRelay();
+    if (typeof relay !== "function") {
+      return false;
+    }
+    if (isRelayMuted()) {
+      return false;
+    }
+    relay(message);
+    return true;
+  }, []);
+  return { relayPipeMessage, pipeReturnHadErrorRef };
+}
+var import_react127;
+var init_usePipeRelay = __esm(() => {
+  init_pipePermissionRelay();
+  import_react127 = __toESM(require_react(), 1);
+});
+
+// src/hooks/usePipePermissionForward.ts
+var exports_usePipePermissionForward = {};
+__export(exports_usePipePermissionForward, {
+  usePipePermissionForward: () => usePipePermissionForward
+});
+function usePipePermissionForward({
+  store,
+  tools,
+  setMessages,
+  setToolUseConfirmQueue,
+  getToolUseContext,
+  mainLoopModel
+}) {
+  import_react128.useEffect(() => {
+    if (false)
+      ;
+    const { subscribePipeEntries, getSlaveClient } = (init_useMasterMonitor(), __toCommonJS(exports_useMasterMonitor));
+    const { getPipeIpc: getPipeIpc2 } = (init_pipeTransport(), __toCommonJS(exports_pipeTransport));
+    const { createAssistantMessage: createAssistantMessage2, createSystemMessage: createSystemMessage2 } = (init_messages(), __toCommonJS(exports_messages));
+    return subscribePipeEntries((pipeName, entry) => {
+      const content = entry.content.trim();
+      const pipeIpcState = getPipeIpc2(store.getState());
+      const peerInfo = (pipeIpcState.discoveredPipes ?? []).find((pipe) => pipe.pipeName === pipeName);
+      const isLan = peerInfo?.ip && peerInfo.ip !== pipeIpcState.localIp;
+      const displayRole = peerInfo ? isLan ? `${peerInfo.role} ${peerInfo.hostname}/${peerInfo.ip}` : peerInfo.role : pipeName;
+      if (entry.type === "permission_request") {
+        try {
+          const payload = JSON.parse(content);
+          const tool = tools.find((candidate) => candidate.name === payload.toolName);
+          const client = getSlaveClient(pipeName);
+          if (!client)
+            return;
+          if (!tool) {
+            client.send({
+              type: "permission_response",
+              data: JSON.stringify({
+                requestId: payload.requestId,
+                behavior: "deny",
+                feedback: `Tool "${payload.toolName}" is not available in main.`
+              })
+            });
+            return;
+          }
+          const assistantMessage = createAssistantMessage2({ content: "" });
+          const toolUseContext = getToolUseContext([], [], new AbortController, mainLoopModel);
+          setToolUseConfirmQueue((queue) => [
+            ...queue,
+            {
+              assistantMessage,
+              tool,
+              description: payload.description,
+              input: payload.input,
+              toolUseContext,
+              toolUseID: `pipe:${payload.requestId}`,
+              pipeName,
+              permissionResult: payload.permissionResult,
+              permissionPromptStartTimeMs: payload.permissionPromptStartTimeMs,
+              workerBadge: {
+                name: `${displayRole} / ${pipeName}`,
+                color: "cyan"
+              },
+              onUserInteraction() {},
+              onAbort() {
+                client.send({
+                  type: "permission_response",
+                  data: JSON.stringify({
+                    requestId: payload.requestId,
+                    behavior: "deny",
+                    feedback: "Permission request was aborted in main."
+                  })
+                });
+              },
+              onAllow(updatedInput, permissionUpdates, feedback, contentBlocks) {
+                client.send({
+                  type: "permission_response",
+                  data: JSON.stringify({
+                    requestId: payload.requestId,
+                    behavior: "allow",
+                    updatedInput,
+                    permissionUpdates,
+                    feedback,
+                    contentBlocks
+                  })
+                });
+              },
+              onReject(feedback, contentBlocks) {
+                client.send({
+                  type: "permission_response",
+                  data: JSON.stringify({
+                    requestId: payload.requestId,
+                    behavior: "deny",
+                    feedback,
+                    contentBlocks
+                  })
+                });
+              },
+              async recheckPermission() {}
+            }
+          ]);
+        } catch {}
+        return;
+      }
+      if (entry.type === "permission_cancel") {
+        try {
+          const payload = JSON.parse(content);
+          setToolUseConfirmQueue((queue) => queue.filter((item) => item.toolUseID !== `pipe:${payload.requestId}`));
+        } catch {}
+        return;
+      }
+      let message = null;
+      if (entry.type === "stream" && content) {
+        message = createSystemMessage2(`[${displayRole} / ${pipeName}] ${content}`, "warning");
+      } else if (entry.type === "error") {
+        message = createSystemMessage2(`[${displayRole} / ${pipeName}] Error: ${content || "no output"}`, "error");
+      } else if (entry.type === "done") {
+        message = createSystemMessage2(`[${displayRole} / ${pipeName}] Completed`, "warning");
+      }
+      if (message) {
+        setMessages((prev) => [...prev, message]);
+      }
+    });
+  }, [
+    getToolUseContext,
+    mainLoopModel,
+    setMessages,
+    setToolUseConfirmQueue,
+    store,
+    tools
+  ]);
+}
+var import_react128;
+var init_usePipePermissionForward = __esm(() => {
+  import_react128 = __toESM(require_react(), 1);
+});
+
+// src/hooks/usePipeMuteSync.ts
+var exports_usePipeMuteSync = {};
+__export(exports_usePipeMuteSync, {
+  usePipeMuteSync: () => usePipeMuteSync
+});
+function usePipeMuteSync({
+  setToolUseConfirmQueue
+}) {
+  const routeMode = useAppState((s) => getPipeIpc(s).routeMode ?? "selected");
+  const selectedPipes = useAppState((s) => getPipeIpc(s).selectedPipes ?? []);
+  const registryVersion = import_react129.useSyncExternalStore(subscribeToSlaveClientRegistry, getSlaveClientRegistryVersion, getSlaveClientRegistryVersion);
+  const sendOverrideVersion = import_react129.useSyncExternalStore(subscribeSendOverride, getSendOverrideVersion, getSendOverrideVersion);
+  const prevMutedRef = import_react129.useRef(new Set);
+  import_react129.useEffect(() => {
+    const slaves = getAllSlaveClients();
+    const nextMuted = new Set;
+    if (routeMode === "local") {
+      for (const name of slaves.keys()) {
+        if (!hasSendOverride(name)) {
+          nextMuted.add(name);
+        }
+      }
+    } else {
+      const selectedSet = new Set(selectedPipes);
+      for (const name of slaves.keys()) {
+        if (!selectedSet.has(name) && !hasSendOverride(name)) {
+          nextMuted.add(name);
+        }
+      }
+    }
+    setMasterMutedPipes(nextMuted);
+    const prevMuted = prevMutedRef.current;
+    for (const name of nextMuted) {
+      if (!prevMuted.has(name)) {
+        setToolUseConfirmQueue((queue) => {
+          const toAbort = queue.filter((item) => item.pipeName === name);
+          for (const item of toAbort) {
+            try {
+              item.onAbort?.();
+            } catch {}
+          }
+          return queue.filter((item) => item.pipeName !== name);
+        });
+        const client = slaves.get(name);
+        if (client?.connected) {
+          try {
+            client.send({ type: "relay_mute" });
+          } catch {}
+        }
+      }
+    }
+    for (const name of prevMuted) {
+      if (!nextMuted.has(name)) {
+        const client = slaves.get(name);
+        if (client?.connected) {
+          try {
+            client.send({ type: "relay_unmute" });
+          } catch {}
+        }
+      }
+    }
+    prevMutedRef.current = nextMuted;
+  }, [routeMode, selectedPipes, registryVersion, sendOverrideVersion, setToolUseConfirmQueue]);
+  import_react129.useEffect(() => {
+    return () => {
+      clearMasterMutedPipes();
+      clearSendOverrides();
+    };
+  }, []);
+}
+var import_react129;
+var init_usePipeMuteSync = __esm(() => {
+  init_AppState();
+  init_pipeTransport();
+  init_pipeMuteState();
+  init_useMasterMonitor();
+  import_react129 = __toESM(require_react(), 1);
+});
+
+// src/hooks/usePipeRouter.ts
+var exports_usePipeRouter = {};
+__export(exports_usePipeRouter, {
+  usePipeRouter: () => usePipeRouter
+});
+function usePipeRouter({ store, setAppState, addNotification }) {
+  const routeToSelectedPipes = import_react130.useCallback((input) => {
+    if (false)
+      ;
+    if (!input.trim() || input.trim().startsWith("/"))
+      return false;
+    const pipeState = store.getState().pipeIpc;
+    const selectedPipes = pipeState?.selectedPipes ?? [];
+    const routeMode = pipeState?.routeMode ?? "selected";
+    if (selectedPipes.length === 0 || routeMode === "local")
+      return false;
+    const { getConnectedSlaveTargets } = (init_useMasterMonitor(), __toCommonJS(exports_useMasterMonitor));
+    const { getPipeIpc: getPipeIpc2 } = (init_pipeTransport(), __toCommonJS(exports_pipeTransport));
+    const targets = getConnectedSlaveTargets(selectedPipes);
+    const pipeIpcForDisplay = getPipeIpc2(store.getState());
+    const discovered = pipeIpcForDisplay.discoveredPipes ?? [];
+    const sentTargetNames = [];
+    const sentTargetLabels = [];
+    const failedTargetNames = [];
+    for (const { name, client } of targets) {
+      try {
+        client.send({ type: "prompt", data: input.trim() });
+        sentTargetNames.push(name);
+        const info = discovered.find((d) => d.pipeName === name);
+        if (info) {
+          const isLan = info.ip && info.ip !== pipeIpcForDisplay.localIp;
+          sentTargetLabels.push(isLan ? `[${info.role}] ${info.hostname}/${info.ip}` : `[${info.role}]`);
+        } else {
+          sentTargetLabels.push(name);
+        }
+      } catch {
+        failedTargetNames.push(name);
+      }
+    }
+    if (sentTargetNames.length > 0) {
+      const promptText = input.trim();
+      const promptTimestamp = new Date().toISOString();
+      setAppState((prev) => {
+        const pipeIpc = getPipeIpc2(prev);
+        const nextSlaves = { ...pipeIpc.slaves };
+        for (const name of sentTargetNames) {
+          const slave = nextSlaves[name];
+          if (!slave)
+            continue;
+          nextSlaves[name] = {
+            ...slave,
+            status: "busy",
+            lastActivityAt: promptTimestamp,
+            lastSummary: `Queued: ${promptText}`,
+            lastEventType: "prompt",
+            history: [
+              ...slave.history,
+              {
+                type: "prompt",
+                content: promptText,
+                from: pipeIpc.serverName ?? "master",
+                timestamp: promptTimestamp
+              }
+            ]
+          };
+        }
+        return {
+          ...prev,
+          pipeIpc: { ...pipeIpc, slaves: nextSlaves }
+        };
+      });
+      addNotification({
+        key: "pipe-route-success",
+        text: `Routed to ${sentTargetLabels.join(", ")}; main can continue other tasks`,
+        color: "success",
+        priority: "immediate",
+        timeoutMs: 3000
+      });
+    } else {
+      addNotification({
+        key: "pipe-route-fallback",
+        text: "Selected pipes are unavailable; processing locally.",
+        color: "warning",
+        priority: "immediate",
+        timeoutMs: 4000
+      });
+    }
+    if (failedTargetNames.length > 0) {
+      addNotification({
+        key: "pipe-route-partial-failure",
+        text: `Failed to send to: ${failedTargetNames.join(", ")}`,
+        color: "warning",
+        priority: "immediate",
+        timeoutMs: 4000
+      });
+    }
+    return sentTargetNames.length > 0;
+  }, [store, setAppState, addNotification]);
+  return { routeToSelectedPipes };
+}
+var import_react130;
+var init_usePipeRouter = __esm(() => {
+  import_react130 = __toESM(require_react(), 1);
 });
 
 // src/components/AntModelSwitchCallout.tsx
@@ -2727,14 +3864,14 @@ __export(exports_UndercoverAutoCallout, {
   UndercoverAutoCallout: () => UndercoverAutoCallout
 });
 function UndercoverAutoCallout({ onDone }) {
-  import_react124.useEffect(() => {
+  import_react131.useEffect(() => {
     onDone();
   }, [onDone]);
   return null;
 }
-var import_react124;
+var import_react131;
 var init_UndercoverAutoCallout = __esm(() => {
-  import_react124 = __toESM(require_react(), 1);
+  import_react131 = __toESM(require_react(), 1);
 });
 
 // src/screens/REPL.tsx
@@ -2750,9 +3887,9 @@ init_exportRenderer();
 init_editor();
 init_src();
 import { spawnSync } from "child_process";
-import { dirname, join as join6 } from "path";
+import { dirname, join as join5 } from "path";
 import { tmpdir } from "os";
-import { writeFile as writeFile3 } from "fs/promises";
+import { writeFile as writeFile2 } from "fs/promises";
 
 // src/components/CostThresholdDialog.tsx
 init_src();
@@ -2849,7 +3986,7 @@ function formatIdleDuration(minutes) {
 init_notifications();
 init_notifier();
 var React47 = __toESM(require_react(), 1);
-var import_react125 = __toESM(require_react(), 1);
+var import_react132 = __toESM(require_react(), 1);
 
 // src/services/preventSleep.ts
 init_cleanupRegistry();
@@ -3532,11 +4669,11 @@ function useReplBridge(messages, setMessages, abortControllerRef, commands, main
           }
           if (cancelled)
             return;
-          const { initReplBridge } = await import("./chunk-4dxhrqgq.js");
-          const { shouldShowAppUpgradeMessage } = await import("./chunk-91aqhy8m.js");
+          const { initReplBridge } = await import("./chunk-dj6r3bps.js");
+          const { shouldShowAppUpgradeMessage } = await import("./chunk-s55ghchb.js");
           let perpetual = false;
           if (true) {
-            const { isAssistantMode } = await import("./chunk-0786r5qj.js");
+            const { isAssistantMode } = await import("./chunk-na5yxjbp.js");
             perpetual = isAssistantMode();
           }
           async function handleInboundMessage(msg) {
@@ -3545,7 +4682,7 @@ function useReplBridge(messages, setMessages, abortControllerRef, commands, main
               if (!fields)
                 return;
               const { uuid } = fields;
-              const { resolveAndPrepend } = await import("./chunk-vjdmt4qp.js");
+              const { resolveAndPrepend } = await import("./chunk-warzed1x.js");
               const rawContent = fields.content;
               let sanitized = typeof rawContent === "string" ? rawContent : rawContent;
               if (false) {}
@@ -16852,46 +17989,11 @@ init_PermissionMode();
 init_slowOperations();
 init_detection();
 init_registry();
+init_types4();
 init_constants7();
 init_teamHelpers();
 init_tasks();
-
-// src/utils/teamDiscovery.ts
-init_types4();
-init_teamHelpers();
-function getTeammateStatuses(teamName) {
-  const teamFile = readTeamFile(teamName);
-  if (!teamFile) {
-    return [];
-  }
-  const hiddenPaneIds = new Set(teamFile.hiddenPaneIds ?? []);
-  const statuses = [];
-  for (const member of teamFile.members) {
-    if (member.name === "team-lead") {
-      continue;
-    }
-    const isActive = member.isActive !== false;
-    const status = isActive ? "running" : "idle";
-    statuses.push({
-      name: member.name,
-      agentId: member.agentId,
-      agentType: member.agentType,
-      model: member.model,
-      prompt: member.prompt,
-      status,
-      color: member.color,
-      tmuxPaneId: member.tmuxPaneId,
-      cwd: member.cwd,
-      worktreePath: member.worktreePath,
-      isHidden: hiddenPaneIds.has(member.tmuxPaneId),
-      backendType: member.backendType && isPaneBackend(member.backendType) ? member.backendType : undefined,
-      mode: member.mode
-    });
-  }
-  return statuses;
-}
-
-// src/components/teams/TeamsDialog.tsx
+init_teamDiscovery();
 init_teammateMailbox();
 init_src();
 init_ThemedText();
@@ -16956,19 +18058,19 @@ function TeamsDialog({ initialTeams, onDone }) {
           memberName: teammateStatuses[selectedIndex].name
         });
       } else if (dialogLevel.type === "teammateDetail" && currentTeammate) {
-        viewTeammateOutput(currentTeammate.tmuxPaneId, currentTeammate.backendType);
+        viewTeammateOutput(currentTeammate.tmuxPaneId, currentTeammate.backendType && isPaneBackend(currentTeammate.backendType) ? currentTeammate.backendType : undefined);
         onDone();
       }
       return;
     }
     if (input === "k") {
       if (dialogLevel.type === "teammateList" && teammateStatuses[selectedIndex]) {
-        killTeammate(teammateStatuses[selectedIndex].tmuxPaneId, teammateStatuses[selectedIndex].backendType, dialogLevel.teamName, teammateStatuses[selectedIndex].agentId, teammateStatuses[selectedIndex].name, setAppState).then(() => {
+        killTeammate(teammateStatuses[selectedIndex].tmuxPaneId, teammateStatuses[selectedIndex].backendType && isPaneBackend(teammateStatuses[selectedIndex].backendType) ? teammateStatuses[selectedIndex].backendType : undefined, dialogLevel.teamName, teammateStatuses[selectedIndex].agentId, teammateStatuses[selectedIndex].name, setAppState).then(() => {
           setRefreshKey((k) => k + 1);
           setSelectedIndex((prev) => Math.max(0, Math.min(prev, teammateStatuses.length - 2)));
         });
       } else if (dialogLevel.type === "teammateDetail" && currentTeammate) {
-        killTeammate(currentTeammate.tmuxPaneId, currentTeammate.backendType, dialogLevel.teamName, currentTeammate.agentId, currentTeammate.name, setAppState);
+        killTeammate(currentTeammate.tmuxPaneId, currentTeammate.backendType && isPaneBackend(currentTeammate.backendType) ? currentTeammate.backendType : undefined, dialogLevel.teamName, currentTeammate.agentId, currentTeammate.name, setAppState);
         goBackToList();
       }
       return;
@@ -17009,7 +18111,7 @@ function TeamsDialog({ initialTeams, onDone }) {
     if (input === "p" && dialogLevel.type === "teammateList") {
       const idleTeammates = teammateStatuses.filter((t) => t.status === "idle");
       if (idleTeammates.length > 0) {
-        Promise.all(idleTeammates.map((t) => killTeammate(t.tmuxPaneId, t.backendType, dialogLevel.teamName, t.agentId, t.name, setAppState))).then(() => {
+        Promise.all(idleTeammates.map((t) => killTeammate(t.tmuxPaneId, t.backendType && isPaneBackend(t.backendType) ? t.backendType : undefined, dialogLevel.teamName, t.agentId, t.name, setAppState))).then(() => {
           setRefreshKey((k) => k + 1);
           setSelectedIndex((prev) => Math.max(0, Math.min(prev, teammateStatuses.length - idleTeammates.length - 1)));
         });
@@ -17040,12 +18142,7 @@ function TeamsDialog({ initialTeams, onDone }) {
   }
   return null;
 }
-function TeamDetailView({
-  teamName,
-  teammates,
-  selectedIndex,
-  onCancel
-}) {
+function TeamDetailView({ teamName, teammates, selectedIndex, onCancel }) {
   const subtitle = `${teammates.length} ${teammates.length === 1 ? "teammate" : "teammates"}`;
   const supportsHideShow = getCachedBackend()?.supportsHideShow ?? false;
   const cycleModeShortcut = useShortcutDisplay("confirm:cycleMode", "Confirmation", "shift+tab");
@@ -17087,10 +18184,7 @@ function TeamDetailView({
     ]
   }, undefined, true, undefined, this);
 }
-function TeammateListItem({
-  teammate,
-  isSelected
-}) {
+function TeammateListItem({ teammate, isSelected }) {
   const isIdle = teammate.status === "idle";
   const shouldDim = isIdle && !isSelected;
   const mode = teammate.mode ? permissionModeFromString(teammate.mode) : "default";
@@ -17129,11 +18223,7 @@ function TeammateListItem({
     ]
   }, undefined, true, undefined, this);
 }
-function TeammateDetailView({
-  teammate,
-  teamName,
-  onCancel
-}) {
+function TeammateDetailView({ teammate, teamName, onCancel }) {
   const [promptExpanded, setPromptExpanded] = import_react53.useState(false);
   const cycleModeShortcut = useShortcutDisplay("confirm:cycleMode", "Confirmation", "shift+tab");
   const themeColor = teammate.color ? AGENT_COLOR_TO_THEME_COLOR[teammate.color] : undefined;
@@ -17290,6 +18380,8 @@ async function killTeammate(paneId, backendType, teamName, teammateId, teammateN
 async function viewTeammateOutput(paneId, backendType) {
   if (backendType === "iterm2") {
     await execFileNoThrow(IT2_COMMAND, ["session", "focus", "-s", paneId]);
+  } else if (backendType === "windows-terminal") {
+    logForDebugging(`[TeamsDialog] viewTeammateOutput: Windows Terminal pane ${paneId} \u2014 manual tab switch required`);
   } else {
     const args = isInsideTmuxSync() ? ["select-pane", "-t", paneId] : ["-L", getSwarmSocketName(), "select-pane", "-t", paneId];
     await execFileNoThrow(TMUX_COMMAND, args);
@@ -18505,219 +19597,9 @@ init_src();
 init_overlayContext();
 init_AppState();
 init_fullscreen();
-var import_react60 = __toESM(require_react(), 1);
-
-// src/utils/pipeTransport.ts
-init_envUtils();
-init_log();
-init_ndjsonFramer();
-import { createServer, createConnection } from "net";
-import { mkdir, unlink, readdir, writeFile } from "fs/promises";
-import { join as join2 } from "path";
-import { EventEmitter } from "events";
-function getPipesDir() {
-  return join2(getClaudeConfigHomeDir(), "pipes");
-}
-function getPipePath(name) {
-  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\claude-code-${safeName}`;
-  }
-  return join2(getPipesDir(), `${safeName}.sock`);
-}
-async function ensurePipesDir() {
-  await mkdir(getPipesDir(), { recursive: true });
-}
-
-class PipeServer extends EventEmitter {
-  server = null;
-  tcpServer = null;
-  clients = new Set;
-  handlers = [];
-  _tcpAddress = null;
-  name;
-  socketPath;
-  constructor(name) {
-    super();
-    this.name = name;
-    this.socketPath = getPipePath(name);
-  }
-  get tcpAddress() {
-    return this._tcpAddress;
-  }
-  setupSocket(socket) {
-    this.clients.add(socket);
-    this.emit("connection", socket);
-    attachNdjsonFramer(socket, (msg) => {
-      this.emit("message", msg);
-      const reply = (replyMsg) => {
-        replyMsg.from = replyMsg.from ?? this.name;
-        replyMsg.ts = replyMsg.ts ?? new Date().toISOString();
-        if (!socket.destroyed) {
-          socket.write(JSON.stringify(replyMsg) + `
-`);
-        }
-      };
-      for (const handler of this.handlers) {
-        handler(msg, reply);
-      }
-    });
-    socket.on("close", () => {
-      this.clients.delete(socket);
-      this.emit("disconnect", socket);
-    });
-    socket.on("error", (err) => {
-      this.clients.delete(socket);
-      logError(err);
-    });
-  }
-  async start(options) {
-    await ensurePipesDir();
-    if (process.platform !== "win32") {
-      try {
-        await unlink(this.socketPath);
-      } catch {}
-    }
-    await new Promise((resolve, reject) => {
-      this.server = createServer((socket) => this.setupSocket(socket));
-      this.server.on("error", reject);
-      this.server.listen(this.socketPath, () => {
-        if (process.platform === "win32") {
-          const regFile = join2(getPipesDir(), `${this.name}.pipe`);
-          const { hostname } = __require("os");
-          writeFile(regFile, JSON.stringify({
-            pid: process.pid,
-            ts: Date.now(),
-            ip: getLocalIp(),
-            hostname: hostname()
-          })).catch(() => {});
-        }
-        resolve();
-      });
-    });
-    if (options?.enableTcp) {
-      await this.startTcpServer(options.tcpPort ?? 0);
-    }
-  }
-  async startTcpServer(port) {
-    return new Promise((resolve, reject) => {
-      this.tcpServer = createServer((socket) => this.setupSocket(socket));
-      this.tcpServer.on("error", reject);
-      this.tcpServer.listen(port, "0.0.0.0", () => {
-        const addr = this.tcpServer.address();
-        if (addr && typeof addr === "object") {
-          this._tcpAddress = { host: "0.0.0.0", port: addr.port };
-        }
-        resolve();
-      });
-    });
-  }
-  onMessage(handler) {
-    this.handlers.push(handler);
-  }
-  broadcast(msg) {
-    msg.from = msg.from ?? this.name;
-    msg.ts = msg.ts ?? new Date().toISOString();
-    const line = JSON.stringify(msg) + `
-`;
-    for (const client of this.clients) {
-      if (!client.destroyed) {
-        client.write(line);
-      }
-    }
-  }
-  sendTo(socket, msg) {
-    msg.from = msg.from ?? this.name;
-    msg.ts = msg.ts ?? new Date().toISOString();
-    if (!socket.destroyed) {
-      socket.write(JSON.stringify(msg) + `
-`);
-    }
-  }
-  get connectionCount() {
-    return this.clients.size;
-  }
-  async close() {
-    for (const client of this.clients) {
-      client.destroy();
-    }
-    this.clients.clear();
-    if (this.tcpServer) {
-      await new Promise((resolve) => {
-        this.tcpServer.close(() => {
-          this.tcpServer = null;
-          this._tcpAddress = null;
-          resolve();
-        });
-      });
-    }
-    return new Promise((resolve) => {
-      if (!this.server) {
-        resolve();
-        return;
-      }
-      this.server.close(() => {
-        this.server = null;
-        if (process.platform === "win32") {
-          const regFile = join2(getPipesDir(), `${this.name}.pipe`);
-          unlink(regFile).catch(() => {});
-        } else {
-          unlink(this.socketPath).catch(() => {});
-        }
-        resolve();
-      });
-    });
-  }
-}
-var DEFAULT_PIPE_IPC = {
-  role: "main",
-  subIndex: null,
-  displayRole: "main",
-  serverName: null,
-  attachedBy: null,
-  localIp: null,
-  hostname: null,
-  machineId: null,
-  mac: null,
-  statusVisible: false,
-  selectorOpen: false,
-  selectedPipes: [],
-  routeMode: "selected",
-  slaves: {},
-  discoveredPipes: []
-};
-function isPipeControlled(pipeIpc) {
-  return Boolean(pipeIpc.attachedBy);
-}
-function getPipeDisplayRole(pipeIpc) {
-  if (pipeIpc.role === "master") {
-    return "master";
-  }
-  if (pipeIpc.subIndex != null) {
-    return `sub-${pipeIpc.subIndex}`;
-  }
-  return "main";
-}
-function getLocalIp() {
-  try {
-    const { networkInterfaces } = __require("os");
-    const nets = networkInterfaces();
-    for (const name of Object.keys(nets)) {
-      for (const net of nets[name] ?? []) {
-        if (net.family === "IPv4" && !net.internal) {
-          return net.address;
-        }
-      }
-    }
-  } catch {}
-  return "127.0.0.1";
-}
-function getPipeIpc(state) {
-  return state?.pipeIpc ?? DEFAULT_PIPE_IPC;
-}
-
-// src/components/PromptInput/PromptInputFooter.tsx
+init_pipeTransport();
 init_undercover();
+var import_react60 = __toESM(require_react(), 1);
 
 // src/components/StatusLine.tsx
 init_analytics();
@@ -20118,8 +21000,8 @@ function BridgeStatusIndicator({ bridgeSelected }) {
   }, undefined, true, undefined, this);
 }
 function PipeStatusInline() {
-  if (true)
-    return null;
+  if (false)
+    ;
   const pipeIpc = useAppState((s) => s.pipeIpc);
   const setAppState = useSetAppState();
   const [cursorIndex, setCursorIndex] = import_react60.useState(0);
@@ -20668,10 +21550,13 @@ function useSwarmBanner() {
     const viewedTeammate = getViewedTeammateTask(state);
     const viewedColor = toThemeColor(viewedTeammate?.identity.color);
     const inProcessMode = isInProcessEnabled();
-    const nativePanes = getCachedDetectionResult()?.isNative ?? false;
+    const detection = getCachedDetectionResult();
+    const nativePanes = detection?.isNative ?? false;
+    const backendType = detection?.backend.type;
     if (insideTmux === false && !inProcessMode && !nativePanes) {
+      const hint = backendType === "windows-terminal" ? "View teammates in the Windows Terminal tabs spawned for each teammate" : `View teammates: \`tmux -L ${getSwarmSocketName()} a\``;
       return {
-        text: `View teammates: \`tmux -L ${getSwarmSocketName()} a\``,
+        text: hint,
         bgColor: viewedColor
       };
     }
@@ -24860,57 +25745,9 @@ init_bashPermissions();
 init_toolName();
 init_classifierApprovals();
 init_errors();
-import { randomUUID as randomUUID8 } from "crypto";
-
-// src/utils/pipePermissionRelay.ts
-import { randomUUID as randomUUID7 } from "crypto";
-var pendingPipePermissions = new Map;
-var _pipeRelay = null;
-var _relayMuted = false;
-function getPipeSender() {
-  return _pipeRelay ?? null;
-}
-function tryRelayPipePermissionRequest(toolUseConfirm, onResponse) {
-  if (_relayMuted)
-    return null;
-  const send = getPipeSender();
-  if (!send)
-    return null;
-  const requestId = randomUUID7();
-  const payload = {
-    requestId,
-    toolName: toolUseConfirm.tool.name,
-    toolUseID: toolUseConfirm.toolUseID,
-    description: toolUseConfirm.description,
-    input: toolUseConfirm.input,
-    permissionResult: toolUseConfirm.permissionResult,
-    permissionPromptStartTimeMs: toolUseConfirm.permissionPromptStartTimeMs
-  };
-  pendingPipePermissions.set(requestId, { onResponse });
-  send({ type: "permission_request", data: JSON.stringify(payload) });
-  return requestId;
-}
-function forgetPipePermissionRequest(requestId) {
-  if (!requestId)
-    return;
-  pendingPipePermissions.delete(requestId);
-}
-function notifyPipePermissionCancel(requestId, reason) {
-  if (!requestId)
-    return;
-  if (_relayMuted)
-    return;
-  const send = getPipeSender();
-  if (!send)
-    return;
-  send({
-    type: "permission_cancel",
-    data: JSON.stringify({ requestId, reason })
-  });
-}
-
-// src/hooks/toolPermission/handlers/interactiveHandler.ts
+init_pipePermissionRelay();
 init_permissions();
+import { randomUUID as randomUUID8 } from "crypto";
 
 // src/hooks/toolPermission/PermissionContext.ts
 init_analytics();
@@ -26204,6 +27041,7 @@ function TeammateViewHeader() {
 }
 
 // src/screens/REPL.tsx
+init_pipeTransport();
 init_useTasksV2();
 init_projectOnboardingState();
 init_sessionStart();
@@ -27455,73 +28293,7 @@ init_messages();
 init_model();
 init_settings();
 init_events();
-
-// src/components/FeedbackSurvey/submitTranscriptShare.ts
-init_axios();
-init_auth();
-init_debug();
-init_errors();
-init_http();
-init_messages();
-init_sessionStorage();
-init_slowOperations();
-init_Feedback();
-import { readFile, stat } from "fs/promises";
-async function submitTranscriptShare(messages, trigger, appearanceId) {
-  try {
-    logForDebugging("Collecting transcript for sharing", { level: "info" });
-    const transcript = normalizeMessagesForAPI(messages);
-    const agentIds = extractAgentIdsFromMessages(messages);
-    const subagentTranscripts = await loadSubagentTranscripts(agentIds);
-    let rawTranscriptJsonl;
-    try {
-      const transcriptPath = getTranscriptPath();
-      const { size } = await stat(transcriptPath);
-      if (size <= MAX_TRANSCRIPT_READ_BYTES) {
-        rawTranscriptJsonl = await readFile(transcriptPath, "utf-8");
-      } else {
-        logForDebugging(`Skipping raw transcript read: file too large (${size} bytes)`, { level: "warn" });
-      }
-    } catch {}
-    const data = {
-      trigger,
-      version: "2.1.888",
-      platform: process.platform,
-      transcript,
-      subagentTranscripts: Object.keys(subagentTranscripts).length > 0 ? subagentTranscripts : undefined,
-      rawTranscriptJsonl
-    };
-    const content = redactSensitiveInfo(jsonStringify(data));
-    await checkAndRefreshOAuthTokenIfNeeded();
-    const authResult = getAuthHeaders();
-    if (authResult.error) {
-      return { success: false };
-    }
-    const headers = {
-      "Content-Type": "application/json",
-      "User-Agent": getUserAgent(),
-      ...authResult.headers
-    };
-    const response = await axios_default.post("https://api.anthropic.com/api/claude_code_shared_session_transcripts", { content, appearance_id: appearanceId }, {
-      headers,
-      timeout: 30000
-    });
-    if (response.status === 200 || response.status === 201) {
-      const result = response.data;
-      logForDebugging("Transcript shared successfully", { level: "info" });
-      return {
-        success: true,
-        transcriptId: result?.transcript_id
-      };
-    }
-    return { success: false };
-  } catch (err) {
-    logForDebugging(errorMessage(err), {
-      level: "error"
-    });
-    return { success: false };
-  }
-}
+init_submitTranscriptShare();
 
 // src/components/FeedbackSurvey/useSurveyState.tsx
 var import_react97 = __toESM(require_react(), 1);
@@ -27849,6 +28621,7 @@ init_envUtils();
 init_memoryFileDetection();
 init_messages();
 init_events();
+init_submitTranscriptShare();
 var import_react99 = __toESM(require_react(), 1);
 var HIDE_THANKS_AFTER_MS = 3000;
 var MEMORY_SURVEY_GATE = "tengu_dunwich_bell";
@@ -28676,7 +29449,7 @@ init_marketplaceHelpers();
 init_marketplaceManager();
 init_officialMarketplace();
 init_officialMarketplaceGcs();
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 function isOfficialMarketplaceAutoInstallDisabled() {
   return isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_OFFICIAL_MARKETPLACE_AUTOINSTALL);
 }
@@ -28765,7 +29538,7 @@ async function checkAndInstallOfficialMarketplace() {
       return { installed: false, skipped: true, reason: "policy_blocked" };
     }
     const cacheDir = getMarketplacesCacheDir();
-    const installLocation = join3(cacheDir, OFFICIAL_MARKETPLACE_NAME);
+    const installLocation = join2(cacheDir, OFFICIAL_MARKETPLACE_NAME);
     const gcsSha = await fetchOfficialMarketplaceFromGcs(installLocation, cacheDir);
     if (gcsSha !== null) {
       const known = await loadKnownMarketplacesConfig();
@@ -29537,7 +30310,7 @@ init_config2();
 init_debug();
 init_log();
 var React37 = __toESM(require_react(), 1);
-import { extname as extname2, join as join4 } from "path";
+import { extname as extname2, join as join3 } from "path";
 
 // src/utils/plugins/lspRecommendation.ts
 import { extname } from "path";
@@ -29861,7 +30634,7 @@ function useLspPluginRecommendation() {
       case "yes":
         installPluginAndNotify(pluginId, pluginName, "lsp-plugin", addNotification, async (pluginData) => {
           logForDebugging(`[useLspPluginRecommendation] Installing plugin: ${pluginId}`);
-          const localSourcePath = typeof pluginData.entry.source === "string" ? join4(pluginData.marketplaceInstallLocation, pluginData.entry.source) : undefined;
+          const localSourcePath = typeof pluginData.entry.source === "string" ? join3(pluginData.marketplaceInstallLocation, pluginData.entry.source) : undefined;
           await cacheAndRegisterPlugin(pluginId, pluginData.entry, "user", undefined, localSourcePath);
           const settings = getSettingsForSource("userSettings");
           updateSettingsForSource("userSettings", {
@@ -30803,7 +31576,7 @@ var MIGRATIONS = [
       return;
     return {
       key: "opus-pro-update",
-      text: isLegacyRemap ? "Model updated to Opus 4.6 \xB7 Set CLAUDE_CODE_DISABLE_LEGACY_MODEL_REMAP=1 to opt out" : "Model updated to Opus 4.6",
+      text: isLegacyRemap ? "Model updated to Opus 4.7 \xB7 Set CLAUDE_CODE_DISABLE_LEGACY_MODEL_REMAP=1 to opt out" : "Model updated to Opus 4.7",
       color: "suggestion",
       priority: "high",
       timeoutMs: isLegacyRemap ? 8000 : 3000
@@ -31322,8 +32095,8 @@ init_sessionStorage();
 init_overlayContext();
 var React43 = __toESM(require_react(), 1);
 var jsx_dev_runtime95 = __toESM(require_jsx_dev_runtime(), 1);
-import { join as join5 } from "path";
-import { stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { stat as stat2, writeFile } from "fs/promises";
 var MAX_VISIBLE_LINES = 24;
 var CHROME_LINES = 11;
 function getDateStamp() {
@@ -31411,8 +32184,8 @@ Implement this plan.`,
         });
         break;
       case "cancel": {
-        const savePath = join5(getCwd(), `${getDateStamp()}-ultraplan.md`);
-        await writeFile2(savePath, plan, { encoding: "utf-8" });
+        const savePath = join4(getCwd(), `${getDateStamp()}-ultraplan.md`);
+        await writeFile(savePath, plan, { encoding: "utf-8" });
         setMessages((prev) => [
           ...prev,
           createSystemMessage(`Ultraplan rejected \xB7 Plan saved to ${toRelativePath(savePath)}`, "suggestion")
@@ -32234,23 +33007,13 @@ var PROACTIVE_NULL = () => null;
 var SUGGEST_BG_PR_NOOP = (_p, _n) => false;
 var useProactive2 = (init_useProactive(), __toCommonJS(exports_useProactive)).useProactive;
 var useScheduledTasks2 = (init_useScheduledTasks(), __toCommonJS(exports_useScheduledTasks)).useScheduledTasks;
-var useMasterMonitor = () => {
-  return;
-};
-var useSlaveNotifications = () => {
-  return;
-};
-var usePipeIpc = () => {
-  return;
-};
-var usePipeRelay = () => ({ relayPipeMessage: () => false, pipeReturnHadErrorRef: { current: false } });
-var usePipePermissionForward = () => {
-  return;
-};
-var usePipeMuteSync = () => {
-  return;
-};
-var usePipeRouter = () => ({ routeToSelectedPipes: () => false });
+var useMasterMonitor = (init_useMasterMonitor(), __toCommonJS(exports_useMasterMonitor)).useMasterMonitor;
+var useSlaveNotifications2 = (init_useSlaveNotifications(), __toCommonJS(exports_useSlaveNotifications)).useSlaveNotifications;
+var usePipeIpc2 = (init_usePipeIpc(), __toCommonJS(exports_usePipeIpc)).usePipeIpc;
+var usePipeRelay2 = (init_usePipeRelay(), __toCommonJS(exports_usePipeRelay)).usePipeRelay;
+var usePipePermissionForward2 = (init_usePipePermissionForward(), __toCommonJS(exports_usePipePermissionForward)).usePipePermissionForward;
+var usePipeMuteSync2 = (init_usePipeMuteSync(), __toCommonJS(exports_usePipeMuteSync)).usePipeMuteSync;
+var usePipeRouter2 = (init_usePipeRouter(), __toCommonJS(exports_usePipeRouter)).usePipeRouter;
 var AntModelSwitchCallout2 = process.env.USER_TYPE === "ant" ? (init_AntModelSwitchCallout(), __toCommonJS(exports_AntModelSwitchCallout)).AntModelSwitchCallout : null;
 var shouldShowAntModelSwitch = process.env.USER_TYPE === "ant" ? (init_AntModelSwitchCallout(), __toCommonJS(exports_AntModelSwitchCallout)).shouldShowModelSwitchCallout : () => false;
 var UndercoverAutoCallout2 = process.env.USER_TYPE === "ant" ? (init_UndercoverAutoCallout(), __toCommonJS(exports_UndercoverAutoCallout)).UndercoverAutoCallout : null;
@@ -32362,7 +33125,7 @@ function TranscriptSearchBar({
     };
   }, []);
   const warmDone = indexStatus !== "building";
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (!warmDone)
       return;
     jumpRef.current?.setSearchQuery(query2);
@@ -32432,8 +33195,8 @@ function AnimatedTerminalTitle({
   noPrefix
 }) {
   const terminalFocused = useTerminalFocus();
-  const [frame, setFrame] = import_react125.useState(0);
-  import_react125.useEffect(() => {
+  const [frame, setFrame] = import_react132.useState(0);
+  import_react132.useEffect(() => {
     if (disabled || noPrefix || !isAnimating || !terminalFocused)
       return;
     const interval = setInterval((setFrame2) => setFrame2((f) => (f + 1) % TITLE_ANIMATION_FRAMES.length), TITLE_ANIMATION_INTERVAL_MS, setFrame);
@@ -32471,15 +33234,15 @@ function REPL({
   thinkingConfig
 }) {
   const isRemoteSession = !!remoteSessionConfig;
-  const titleDisabled = import_react125.useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE), []);
-  const moreRightEnabled = import_react125.useMemo(() => process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.CLAUDE_MORERIGHT), []);
-  const disableVirtualScroll = import_react125.useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL), []);
+  const titleDisabled = import_react132.useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE), []);
+  const moreRightEnabled = import_react132.useMemo(() => process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.CLAUDE_MORERIGHT), []);
+  const disableVirtualScroll = import_react132.useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL), []);
   const disableMessageActions = false;
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     logForDebugging(`[REPL:mount] REPL mounted, disabled=${disabled}`);
     return () => logForDebugging(`[REPL:unmount] REPL unmounting`);
   }, [disabled]);
-  const [mainThreadAgentDefinition, setMainThreadAgentDefinition] = import_react125.useState(initialMainThreadAgentDefinition);
+  const [mainThreadAgentDefinition, setMainThreadAgentDefinition] = import_react132.useState(initialMainThreadAgentDefinition);
   const toolPermissionContext = useAppState((s) => s.toolPermissionContext);
   const verbose = useAppState((s) => s.verbose);
   const mcp = useAppState((s) => s.mcp);
@@ -32502,7 +33265,7 @@ function REPL({
   const setAppState = useSetAppState();
   const viewedLocalAgent = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
   const needsBootstrap = isLocalAgentTask(viewedLocalAgent) && viewedLocalAgent.retain && !viewedLocalAgent.diskLoaded;
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (!viewingAgentTaskId || !needsBootstrap)
       return;
     const taskId = viewingAgentTaskId;
@@ -32531,40 +33294,40 @@ function REPL({
   const store = useAppStateStore();
   const terminal = useTerminalNotification();
   const mainLoopModel = useMainLoopModel();
-  const [localCommands, setLocalCommands] = import_react125.useState(initialCommands);
+  const [localCommands, setLocalCommands] = import_react132.useState(initialCommands);
   useSkillsChange(isRemoteSession ? undefined : getProjectRoot(), setLocalCommands);
   const proactiveActive = React47.useSyncExternalStore(proactiveModule3?.subscribeToProactiveChanges ?? PROACTIVE_NO_OP_SUBSCRIBE, proactiveModule3?.isProactiveActive ?? PROACTIVE_FALSE);
   const proactiveNextTickAt = React47.useSyncExternalStore(proactiveModule3?.subscribeToProactiveChanges ?? PROACTIVE_NO_OP_SUBSCRIBE, proactiveModule3?.getNextTickAt ?? PROACTIVE_NULL);
   const isBriefOnly = useAppState((s) => s.isBriefOnly);
-  const localTools = import_react125.useMemo(() => getTools(toolPermissionContext), [toolPermissionContext, proactiveActive, isBriefOnly]);
+  const localTools = import_react132.useMemo(() => getTools(toolPermissionContext), [toolPermissionContext, proactiveActive, isBriefOnly]);
   useKickOffCheckAndDisableAutoModeIfNeeded();
-  const [dynamicMcpConfig, setDynamicMcpConfig] = import_react125.useState(initialDynamicMcpConfig);
-  const onChangeDynamicMcpConfig = import_react125.useCallback((config) => {
+  const [dynamicMcpConfig, setDynamicMcpConfig] = import_react132.useState(initialDynamicMcpConfig);
+  const onChangeDynamicMcpConfig = import_react132.useCallback((config) => {
     setDynamicMcpConfig(config);
   }, [setDynamicMcpConfig]);
-  const [screen, setScreen] = import_react125.useState("prompt");
-  const [showAllInTranscript, setShowAllInTranscript] = import_react125.useState(false);
-  const [dumpMode, setDumpMode] = import_react125.useState(false);
-  const [editorStatus, setEditorStatus] = import_react125.useState("");
-  const editorGenRef = import_react125.useRef(0);
-  const editorTimerRef = import_react125.useRef(undefined);
-  const editorRenderingRef = import_react125.useRef(false);
+  const [screen, setScreen] = import_react132.useState("prompt");
+  const [showAllInTranscript, setShowAllInTranscript] = import_react132.useState(false);
+  const [dumpMode, setDumpMode] = import_react132.useState(false);
+  const [editorStatus, setEditorStatus] = import_react132.useState("");
+  const editorGenRef = import_react132.useRef(0);
+  const editorTimerRef = import_react132.useRef(undefined);
+  const editorRenderingRef = import_react132.useRef(false);
   const { addNotification, removeNotification } = useNotifications();
   let trySuggestBgPRIntercept = SUGGEST_BG_PR_NOOP;
   const mcpClients = useMergedClients(initialMcpClients, mcp.clients);
-  const [ideSelection, setIDESelection] = import_react125.useState(undefined);
-  const [ideToInstallExtension, setIDEToInstallExtension] = import_react125.useState(null);
-  const [ideInstallationStatus, setIDEInstallationStatus] = import_react125.useState(null);
-  const [showIdeOnboarding, setShowIdeOnboarding] = import_react125.useState(false);
-  const [showModelSwitchCallout, setShowModelSwitchCallout] = import_react125.useState(() => {
+  const [ideSelection, setIDESelection] = import_react132.useState(undefined);
+  const [ideToInstallExtension, setIDEToInstallExtension] = import_react132.useState(null);
+  const [ideInstallationStatus, setIDEInstallationStatus] = import_react132.useState(null);
+  const [showIdeOnboarding, setShowIdeOnboarding] = import_react132.useState(false);
+  const [showModelSwitchCallout, setShowModelSwitchCallout] = import_react132.useState(() => {
     if (process.env.USER_TYPE === "ant") {
       return shouldShowAntModelSwitch();
     }
     return false;
   });
-  const [showEffortCallout, setShowEffortCallout] = import_react125.useState(() => shouldShowEffortCallout(mainLoopModel));
+  const [showEffortCallout, setShowEffortCallout] = import_react132.useState(() => shouldShowEffortCallout(mainLoopModel));
   const showRemoteCallout = useAppState((s) => s.showRemoteCallout);
-  const [showDesktopUpsellStartup, setShowDesktopUpsellStartup] = import_react125.useState(() => shouldShowDesktopUpsellStartup());
+  const [showDesktopUpsellStartup, setShowDesktopUpsellStartup] = import_react132.useState(() => shouldShowDesktopUpsellStartup());
   useModelMigrationNotifications();
   useCanSwitchToExistingSubscription();
   useIDEStatusIndicator({ ideSelection, mcpClients, ideInstallationStatus });
@@ -32584,12 +33347,12 @@ function REPL({
   useTeammateLifecycleNotification();
   const { recommendation: lspRecommendation, handleResponse: handleLspResponse } = useLspPluginRecommendation();
   const { recommendation: hintRecommendation, handleResponse: handleHintResponse } = useClaudeCodeHintRecommendation();
-  const combinedInitialTools = import_react125.useMemo(() => {
+  const combinedInitialTools = import_react132.useMemo(() => {
     return [...localTools, ...initialTools];
   }, [localTools, initialTools]);
   useManagePlugins({ enabled: !isRemoteSession });
   const tasksV2 = useTasksV2WithCollapseEffect();
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (isRemoteSession)
       return;
     performStartupChecks(setAppState);
@@ -32599,7 +33362,7 @@ function REPL({
     enabled: !isRemoteSession
   });
   const mergedTools = useMergedTools(combinedInitialTools, mcp.tools, toolPermissionContext);
-  const { tools, allowedAgentTypes } = import_react125.useMemo(() => {
+  const { tools, allowedAgentTypes } = import_react132.useMemo(() => {
     if (!mainThreadAgentDefinition) {
       return {
         tools: mergedTools,
@@ -32614,15 +33377,15 @@ function REPL({
   }, [mainThreadAgentDefinition, mergedTools]);
   const commandsWithPlugins = useMergedCommands(localCommands, plugins.commands);
   const mergedCommands = useMergedCommands(commandsWithPlugins, mcp.commands);
-  const commands = import_react125.useMemo(() => disableSlashCommands ? [] : mergedCommands, [disableSlashCommands, mergedCommands]);
+  const commands = import_react132.useMemo(() => disableSlashCommands ? [] : mergedCommands, [disableSlashCommands, mergedCommands]);
   useIdeLogging(isRemoteSession ? EMPTY_MCP_CLIENTS2 : mcp.clients);
   useIdeSelection(isRemoteSession ? EMPTY_MCP_CLIENTS2 : mcp.clients, setIDESelection);
-  const [streamMode, setStreamMode] = import_react125.useState("responding");
-  const streamModeRef = import_react125.useRef(streamMode);
+  const [streamMode, setStreamMode] = import_react132.useState("responding");
+  const streamModeRef = import_react132.useRef(streamMode);
   streamModeRef.current = streamMode;
-  const [streamingToolUses, setStreamingToolUses] = import_react125.useState([]);
-  const [streamingThinking, setStreamingThinking] = import_react125.useState(null);
-  import_react125.useEffect(() => {
+  const [streamingToolUses, setStreamingToolUses] = import_react132.useState([]);
+  const [streamingThinking, setStreamingThinking] = import_react132.useState(null);
+  import_react132.useEffect(() => {
     if (streamingThinking && !streamingThinking.isStreaming && streamingThinking.streamingEndedAt) {
       const elapsed = Date.now() - streamingThinking.streamingEndedAt;
       const remaining = 30000 - elapsed;
@@ -32634,14 +33397,14 @@ function REPL({
       }
     }
   }, [streamingThinking]);
-  const [abortController, setAbortController] = import_react125.useState(null);
-  const abortControllerRef = import_react125.useRef(null);
+  const [abortController, setAbortController] = import_react132.useState(null);
+  const abortControllerRef = import_react132.useRef(null);
   abortControllerRef.current = abortController;
-  const sendBridgeResultRef = import_react125.useRef(() => {});
-  const restoreMessageSyncRef = import_react125.useRef(() => {});
-  const scrollRef = import_react125.useRef(null);
-  const modalScrollRef = import_react125.useRef(null);
-  const lastUserScrollTsRef = import_react125.useRef(0);
+  const sendBridgeResultRef = import_react132.useRef(() => {});
+  const restoreMessageSyncRef = import_react132.useRef(() => {});
+  const scrollRef = import_react132.useRef(null);
+  const modalScrollRef = import_react132.useRef(null);
+  const lastUserScrollTsRef = import_react132.useRef(0);
   const queryGuard = React47.useRef(new QueryGuard).current;
   const isQueryActive = React47.useSyncExternalStore(queryGuard.subscribe, queryGuard.getSnapshot);
   const [isExternalLoading, setIsExternalLoadingRaw] = React47.useState(remoteSessionConfig?.hasInitialPrompt ?? false);
@@ -32672,8 +33435,8 @@ function REPL({
   const focusedInputDialogRef = React47.useRef(undefined);
   const PROMPT_SUPPRESSION_MS = 1500;
   const [isPromptInputActive, setIsPromptInputActive] = React47.useState(false);
-  const [autoUpdaterResult, setAutoUpdaterResult] = import_react125.useState(null);
-  import_react125.useEffect(() => {
+  const [autoUpdaterResult, setAutoUpdaterResult] = import_react132.useState(null);
+  import_react132.useEffect(() => {
     if (autoUpdaterResult?.notifications) {
       autoUpdaterResult.notifications.forEach((notification) => {
         addNotification({
@@ -32684,7 +33447,7 @@ function REPL({
       });
     }
   }, [autoUpdaterResult, addNotification]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (isFullscreenEnvEnabled()) {
       maybeGetTmuxMouseHint().then((hint) => {
         if (hint) {
@@ -32697,22 +33460,22 @@ function REPL({
       });
     }
   }, []);
-  const [showUndercoverCallout, setShowUndercoverCallout] = import_react125.useState(false);
-  import_react125.useEffect(() => {
+  const [showUndercoverCallout, setShowUndercoverCallout] = import_react132.useState(false);
+  import_react132.useEffect(() => {
     if (process.env.USER_TYPE === "ant") {
       (async () => {
-        const { isInternalModelRepo } = await import("./chunk-brjsspt6.js");
+        const { isInternalModelRepo } = await import("./chunk-4qzt1dqf.js");
         await isInternalModelRepo();
-        const { shouldShowUndercoverAutoNotice } = await import("./chunk-pzzr97ff.js");
+        const { shouldShowUndercoverAutoNotice } = await import("./chunk-9w4zt45w.js");
         if (shouldShowUndercoverAutoNotice()) {
           setShowUndercoverCallout(true);
         }
       })();
     }
   }, []);
-  const [toolJSX, setToolJSXInternal] = import_react125.useState(null);
-  const localJSXCommandRef = import_react125.useRef(null);
-  const setToolJSX = import_react125.useCallback((args) => {
+  const [toolJSX, setToolJSXInternal] = import_react132.useState(null);
+  const localJSXCommandRef = import_react132.useRef(null);
+  const setToolJSX = import_react132.useCallback((args) => {
     if (args?.isLocalJSXCommand) {
       const { clearLocalJSX: _, ...rest } = args;
       localJSXCommandRef.current = { ...rest, isLocalJSXCommand: true };
@@ -32733,21 +33496,21 @@ function REPL({
     }
     setToolJSXInternal(args);
   }, []);
-  const [toolUseConfirmQueue, setToolUseConfirmQueue] = import_react125.useState([]);
-  const [permissionStickyFooter, setPermissionStickyFooter] = import_react125.useState(null);
-  const [sandboxPermissionRequestQueue, setSandboxPermissionRequestQueue] = import_react125.useState([]);
-  const [promptQueue, setPromptQueue] = import_react125.useState([]);
-  const sandboxBridgeCleanupRef = import_react125.useRef(new Map);
+  const [toolUseConfirmQueue, setToolUseConfirmQueue] = import_react132.useState([]);
+  const [permissionStickyFooter, setPermissionStickyFooter] = import_react132.useState(null);
+  const [sandboxPermissionRequestQueue, setSandboxPermissionRequestQueue] = import_react132.useState([]);
+  const [promptQueue, setPromptQueue] = import_react132.useState([]);
+  const sandboxBridgeCleanupRef = import_react132.useRef(new Map);
   const terminalTitleFromRename = useAppState((s) => s.settings.terminalTitleFromRename) !== false;
   const sessionTitle = terminalTitleFromRename ? getCurrentSessionTitle(getSessionId()) : undefined;
-  const [haikuTitle, setHaikuTitle] = import_react125.useState();
-  const haikuTitleAttemptedRef = import_react125.useRef((initialMessages?.length ?? 0) > 0);
+  const [haikuTitle, setHaikuTitle] = import_react132.useState();
+  const haikuTitleAttemptedRef = import_react132.useRef((initialMessages?.length ?? 0) > 0);
   const agentTitle = mainThreadAgentDefinition?.agentType;
   const terminalTitle = sessionTitle ?? agentTitle ?? haikuTitle ?? "Claude Code";
   const isWaitingForApproval = toolUseConfirmQueue.length > 0 || promptQueue.length > 0 || pendingWorkerRequest || pendingSandboxRequest;
   const isShowingLocalJSXCommand = toolJSX?.isLocalJSXCommand === true && toolJSX?.jsx != null;
   const titleIsAnimating = isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand;
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand) {
       startPreventSleep();
       return () => stopPreventSleep();
@@ -32755,7 +33518,7 @@ function REPL({
   }, [isLoading, isWaitingForApproval, isShowingLocalJSXCommand]);
   const sessionStatus = isWaitingForApproval || isShowingLocalJSXCommand ? "waiting" : isLoading ? "busy" : "idle";
   const waitingFor = sessionStatus !== "waiting" ? undefined : toolUseConfirmQueue.length > 0 ? `approve ${toolUseConfirmQueue[0].tool.name}` : pendingWorkerRequest ? "worker request" : pendingSandboxRequest ? "sandbox request" : isShowingLocalJSXCommand ? "dialog open" : "input needed";
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (true) {
       updateSessionActivity({ status: sessionStatus, waitingFor });
     }
@@ -32763,14 +33526,14 @@ function REPL({
   const tabStatusGateEnabled = getFeatureValue_CACHED_MAY_BE_STALE("tengu_terminal_sidebar", false);
   const showStatusInTerminalTab = tabStatusGateEnabled && (getGlobalConfig().showStatusInTerminalTab ?? false);
   useTabStatus(titleDisabled || !showStatusInTerminalTab ? null : sessionStatus);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     registerLeaderToolUseConfirmQueue(setToolUseConfirmQueue);
     return () => unregisterLeaderToolUseConfirmQueue();
   }, [setToolUseConfirmQueue]);
-  const [messages, rawSetMessages] = import_react125.useState(initialMessages ?? []);
-  const messagesRef = import_react125.useRef(messages);
-  const idleHintShownRef = import_react125.useRef(false);
-  const setMessages = import_react125.useCallback((action) => {
+  const [messages, rawSetMessages] = import_react132.useState(initialMessages ?? []);
+  const messagesRef = import_react132.useRef(messages);
+  const idleHintShownRef = import_react132.useRef(false);
+  const setMessages = import_react132.useCallback((action) => {
     const prev = messagesRef.current;
     const next = typeof action === "function" ? action(messagesRef.current) : action;
     messagesRef.current = next;
@@ -32787,7 +33550,7 @@ function REPL({
     }
     rawSetMessages(next);
   }, []);
-  const setUserInputOnProcessing = import_react125.useCallback((input) => {
+  const setUserInputOnProcessing = import_react132.useCallback((input) => {
     if (input !== undefined) {
       userInputBaselineRef.current = messagesRef.current.length;
       userMessagePendingRef.current = true;
@@ -32800,17 +33563,17 @@ function REPL({
   if (true) {
     useAwaySummary(messages, setMessages, isLoading);
   }
-  const [cursor, setCursor] = import_react125.useState(null);
-  const cursorNavRef = import_react125.useRef(null);
-  const unseenDivider = import_react125.useMemo(() => computeUnseenDivider(messages, dividerIndex), [dividerIndex, messages.length]);
-  const repinScroll = import_react125.useCallback(() => {
+  const [cursor, setCursor] = import_react132.useState(null);
+  const cursorNavRef = import_react132.useRef(null);
+  const unseenDivider = import_react132.useMemo(() => computeUnseenDivider(messages, dividerIndex), [dividerIndex, messages.length]);
+  const repinScroll = import_react132.useCallback(() => {
     scrollRef.current?.scrollToBottom();
     onRepin();
     setCursor(null);
   }, [onRepin, setCursor]);
   const lastMsg = messages.at(-1);
   const lastMsgIsHuman = lastMsg != null && isHumanTurn(lastMsg);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (lastMsgIsHuman) {
       repinScroll();
     }
@@ -32821,7 +33584,7 @@ function REPL({
     scrollRef,
     onPrepend: shiftDivider
   });
-  const composedOnScroll = import_react125.useCallback((sticky, handle) => {
+  const composedOnScroll = import_react132.useCallback((sticky, handle) => {
     lastUserScrollTsRef.current = Date.now();
     if (sticky) {
       onRepin();
@@ -32835,17 +33598,17 @@ function REPL({
     }
   }, [onRepin, onScrollAway, maybeLoadOlder, setAppState]);
   const awaitPendingHooks = useDeferredHookMessages(pendingHookMessages, setMessages);
-  const deferredMessages = import_react125.useDeferredValue(messages);
+  const deferredMessages = import_react132.useDeferredValue(messages);
   const deferredBehind = messages.length - deferredMessages.length;
   if (deferredBehind > 0) {
     logForDebugging(`[useDeferredValue] Messages deferred by ${deferredBehind} (${deferredMessages.length}\u2192${messages.length})`);
   }
-  const [frozenTranscriptState, setFrozenTranscriptState] = import_react125.useState(null);
-  const [inputValue, setInputValueRaw] = import_react125.useState(() => consumeEarlyInput());
-  const inputValueRef = import_react125.useRef(inputValue);
+  const [frozenTranscriptState, setFrozenTranscriptState] = import_react132.useState(null);
+  const [inputValue, setInputValueRaw] = import_react132.useState(() => consumeEarlyInput());
+  const inputValueRef = import_react132.useRef(inputValue);
   inputValueRef.current = inputValue;
-  const insertTextRef = import_react125.useRef(null);
-  const setInputValue = import_react125.useCallback((value) => {
+  const insertTextRef = import_react132.useRef(null);
+  const setInputValue = import_react132.useCallback((value) => {
     if (trySuggestBgPRIntercept(inputValueRef.current, value))
       return;
     if (inputValueRef.current === "" && value !== "" && Date.now() - lastUserScrollTsRef.current >= RECENT_SCROLL_REPIN_WINDOW_MS) {
@@ -32855,20 +33618,20 @@ function REPL({
     setInputValueRaw(value);
     setIsPromptInputActive(value.trim().length > 0);
   }, [setIsPromptInputActive, repinScroll, trySuggestBgPRIntercept]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (inputValue.trim().length === 0)
       return;
     const timer = setTimeout(setIsPromptInputActive, PROMPT_SUPPRESSION_MS, false);
     return () => clearTimeout(timer);
   }, [inputValue]);
-  const [inputMode, setInputMode] = import_react125.useState("prompt");
-  const [stashedPrompt, setStashedPrompt] = import_react125.useState();
-  const handleRemoteInit = import_react125.useCallback((remoteSlashCommands) => {
+  const [inputMode, setInputMode] = import_react132.useState("prompt");
+  const [stashedPrompt, setStashedPrompt] = import_react132.useState();
+  const handleRemoteInit = import_react132.useCallback((remoteSlashCommands) => {
     const remoteCommandSet = new Set(remoteSlashCommands);
     setLocalCommands((prev) => prev.filter((cmd) => remoteCommandSet.has(cmd.name) || REMOTE_SAFE_COMMANDS.has(cmd)));
   }, [setLocalCommands]);
-  const [inProgressToolUseIDs, setInProgressToolUseIDs] = import_react125.useState(new Set);
-  const hasInterruptibleToolInProgressRef = import_react125.useRef(false);
+  const [inProgressToolUseIDs, setInProgressToolUseIDs] = import_react132.useState(new Set);
+  const hasInterruptibleToolInProgressRef = import_react132.useRef(false);
   const remoteSession = useRemoteSession({
     config: remoteSessionConfig,
     setMessages,
@@ -32895,11 +33658,11 @@ function REPL({
     tools: combinedInitialTools
   });
   const activeRemote = sshRemote.isRemoteMode ? sshRemote : directConnect.isRemoteMode ? directConnect : remoteSession;
-  const [pastedContents, setPastedContents] = import_react125.useState({});
-  const [submitCount, setSubmitCount] = import_react125.useState(0);
-  const responseLengthRef = import_react125.useRef(0);
-  const apiMetricsRef = import_react125.useRef([]);
-  const setResponseLength = import_react125.useCallback((f) => {
+  const [pastedContents, setPastedContents] = import_react132.useState({});
+  const [submitCount, setSubmitCount] = import_react132.useState(0);
+  const responseLengthRef = import_react132.useRef(0);
+  const apiMetricsRef = import_react132.useRef([]);
+  const setResponseLength = import_react132.useCallback((f) => {
     const prev = responseLengthRef.current;
     responseLengthRef.current = f(prev);
     if (responseLengthRef.current > prev) {
@@ -32911,47 +33674,47 @@ function REPL({
       }
     }
   }, []);
-  const [streamingText, setStreamingText] = import_react125.useState(null);
+  const [streamingText, setStreamingText] = import_react132.useState(null);
   const reducedMotion = useAppState((s) => s.settings.prefersReducedMotion) ?? false;
   const showStreamingText = !reducedMotion && !hasCursorUpViewportYankBug();
-  const onStreamingText = import_react125.useCallback((f) => {
+  const onStreamingText = import_react132.useCallback((f) => {
     if (!showStreamingText)
       return;
     setStreamingText(f);
   }, [showStreamingText]);
   const visibleStreamingText = streamingText && showStreamingText ? streamingText.substring(0, streamingText.lastIndexOf(`
 `) + 1) || null : null;
-  const [lastQueryCompletionTime, setLastQueryCompletionTime] = import_react125.useState(0);
-  const [spinnerMessage, setSpinnerMessage] = import_react125.useState(null);
-  const [spinnerColor, setSpinnerColor] = import_react125.useState(null);
-  const [spinnerShimmerColor, setSpinnerShimmerColor] = import_react125.useState(null);
-  const [isMessageSelectorVisible, setIsMessageSelectorVisible] = import_react125.useState(false);
-  const [messageSelectorPreselect, setMessageSelectorPreselect] = import_react125.useState(undefined);
-  const [showCostDialog, setShowCostDialog] = import_react125.useState(false);
-  const [conversationId, setConversationId] = import_react125.useState(randomUUID11());
-  const [idleReturnPending, setIdleReturnPending] = import_react125.useState(null);
-  const skipIdleCheckRef = import_react125.useRef(false);
-  const lastQueryCompletionTimeRef = import_react125.useRef(lastQueryCompletionTime);
+  const [lastQueryCompletionTime, setLastQueryCompletionTime] = import_react132.useState(0);
+  const [spinnerMessage, setSpinnerMessage] = import_react132.useState(null);
+  const [spinnerColor, setSpinnerColor] = import_react132.useState(null);
+  const [spinnerShimmerColor, setSpinnerShimmerColor] = import_react132.useState(null);
+  const [isMessageSelectorVisible, setIsMessageSelectorVisible] = import_react132.useState(false);
+  const [messageSelectorPreselect, setMessageSelectorPreselect] = import_react132.useState(undefined);
+  const [showCostDialog, setShowCostDialog] = import_react132.useState(false);
+  const [conversationId, setConversationId] = import_react132.useState(randomUUID11());
+  const [idleReturnPending, setIdleReturnPending] = import_react132.useState(null);
+  const skipIdleCheckRef = import_react132.useRef(false);
+  const lastQueryCompletionTimeRef = import_react132.useRef(lastQueryCompletionTime);
   lastQueryCompletionTimeRef.current = lastQueryCompletionTime;
-  const [contentReplacementStateRef] = import_react125.useState(() => ({
+  const [contentReplacementStateRef] = import_react132.useState(() => ({
     current: provisionContentReplacementState(initialMessages, initialContentReplacements)
   }));
-  const [haveShownCostDialog, setHaveShownCostDialog] = import_react125.useState(getGlobalConfig().hasAcknowledgedCostThreshold);
-  const [vimMode, setVimMode] = import_react125.useState("INSERT");
-  const [showBashesDialog, setShowBashesDialog] = import_react125.useState(false);
-  const [isSearchingHistory, setIsSearchingHistory] = import_react125.useState(false);
-  const [isHelpOpen, setIsHelpOpen] = import_react125.useState(false);
-  import_react125.useEffect(() => {
+  const [haveShownCostDialog, setHaveShownCostDialog] = import_react132.useState(getGlobalConfig().hasAcknowledgedCostThreshold);
+  const [vimMode, setVimMode] = import_react132.useState("INSERT");
+  const [showBashesDialog, setShowBashesDialog] = import_react132.useState(false);
+  const [isSearchingHistory, setIsSearchingHistory] = import_react132.useState(false);
+  const [isHelpOpen, setIsHelpOpen] = import_react132.useState(false);
+  import_react132.useEffect(() => {
     if (ultraplanPendingChoice && showBashesDialog) {
       setShowBashesDialog(false);
     }
   }, [ultraplanPendingChoice, showBashesDialog]);
   const isTerminalFocused = useTerminalFocus();
-  const terminalFocusRef = import_react125.useRef(isTerminalFocused);
+  const terminalFocusRef = import_react132.useRef(isTerminalFocused);
   terminalFocusRef.current = isTerminalFocused;
   const [theme] = useTheme();
   const tipPickedThisTurnRef = React47.useRef(false);
-  const pickNewSpinnerTip = import_react125.useCallback(() => {
+  const pickNewSpinnerTip = import_react132.useCallback(() => {
     if (tipPickedThisTurnRef.current)
       return;
     tipPickedThisTurnRef.current = true;
@@ -32981,7 +33744,7 @@ function REPL({
       }
     });
   }, [setAppState, theme]);
-  const resetLoadingState = import_react125.useCallback(() => {
+  const resetLoadingState = import_react132.useCallback(() => {
     setIsExternalLoading(false);
     setUserInputOnProcessing(undefined);
     responseLengthRef.current = 0;
@@ -32995,8 +33758,8 @@ function REPL({
     endInteractionSpan();
     clearSpeculativeChecks();
   }, [pickNewSpinnerTip]);
-  const hasRunningTeammates = import_react125.useMemo(() => getAllInProcessTeammateTasks(tasks).some((t) => t.status === "running"), [tasks]);
-  import_react125.useEffect(() => {
+  const hasRunningTeammates = import_react132.useMemo(() => getAllInProcessTeammateTasks(tasks).some((t) => t.status === "running"), [tasks]);
+  import_react132.useEffect(() => {
     if (!hasRunningTeammates && swarmStartTimeRef.current !== null) {
       const totalMs = Date.now() - swarmStartTimeRef.current;
       const deferredBudget = swarmBudgetInfoRef.current;
@@ -33008,8 +33771,8 @@ function REPL({
       ]);
     }
   }, [hasRunningTeammates, setMessages]);
-  const safeYoloMessageShownRef = import_react125.useRef(false);
-  import_react125.useEffect(() => {
+  const safeYoloMessageShownRef = import_react132.useRef(false);
+  import_react132.useEffect(() => {
     if (true) {
       if (toolPermissionContext.mode !== "auto") {
         safeYoloMessageShownRef.current = false;
@@ -33037,8 +33800,8 @@ function REPL({
       return () => clearTimeout(timer);
     }
   }, [toolPermissionContext.mode, setMessages]);
-  const worktreeTipShownRef = import_react125.useRef(false);
-  import_react125.useEffect(() => {
+  const worktreeTipShownRef = import_react132.useRef(false);
+  import_react132.useEffect(() => {
     if (worktreeTipShownRef.current)
       return;
     const wt = getCurrentWorktreeSession();
@@ -33053,7 +33816,7 @@ function REPL({
       createSystemMessage(`Worktree creation took ${secs}s. For large repos, set \`worktree.sparsePaths\` in .claude/settings.json to check out only the directories you need \u2014 e.g. \`{"worktree": {"sparsePaths": ["src", "packages/foo"]}}\`.`, "info")
     ]);
   }, [setMessages]);
-  const onlySleepToolActive = import_react125.useMemo(() => {
+  const onlySleepToolActive = import_react132.useMemo(() => {
     const lastAssistant = messages.findLast((m) => m.type === "assistant");
     if (lastAssistant?.type !== "assistant")
       return false;
@@ -33078,7 +33841,7 @@ function REPL({
   const feedbackSurveyOriginal = useFeedbackSurvey(messages, isLoading, submitCount, "session", hasActivePrompt);
   const skillImprovementSurvey = useSkillImprovementSurvey(setMessages);
   const showIssueFlagBanner = useIssueFlagBanner(messages, submitCount);
-  const feedbackSurvey = import_react125.useMemo(() => ({
+  const feedbackSurvey = import_react132.useMemo(() => ({
     ...feedbackSurveyOriginal,
     handleSelect: (selected) => {
       didAutoRunIssueRef.current = false;
@@ -33105,7 +33868,7 @@ function REPL({
     ...prev,
     fileHistory: fileHistoryState
   })));
-  const resume = import_react125.useCallback(async (sessionId, log, entrypoint) => {
+  const resume = import_react132.useCallback(async (sessionId, log, entrypoint) => {
     const resumeStart = performance.now();
     try {
       const messages2 = deserializeMessages(log.messages);
@@ -33165,7 +33928,7 @@ function REPL({
       saveCurrentSessionCosts();
       resetCostState();
       switchSession(asSessionId(sessionId), log.fullPath ? dirname(log.fullPath) : null);
-      const { renameRecordingForSession } = await import("./chunk-fta35khb.js");
+      const { renameRecordingForSession } = await import("./chunk-yezeptjf.js");
       await renameRecordingForSession();
       await resetSessionFilePointer();
       clearSessionMetadata();
@@ -33213,20 +33976,20 @@ function REPL({
       throw error;
     }
   }, [resetLoadingState, setAppState]);
-  const [initialReadFileState] = import_react125.useState(() => createFileStateCacheWithSizeLimit(READ_FILE_STATE_CACHE_SIZE));
-  const readFileState = import_react125.useRef(initialReadFileState);
-  const bashTools = import_react125.useRef(new Set);
-  const bashToolsProcessedIdx = import_react125.useRef(0);
-  const discoveredSkillNamesRef = import_react125.useRef(new Set);
-  const loadedNestedMemoryPathsRef = import_react125.useRef(new Set);
-  const restoreReadFileState = import_react125.useCallback((messages2, cwd) => {
+  const [initialReadFileState] = import_react132.useState(() => createFileStateCacheWithSizeLimit(READ_FILE_STATE_CACHE_SIZE));
+  const readFileState = import_react132.useRef(initialReadFileState);
+  const bashTools = import_react132.useRef(new Set);
+  const bashToolsProcessedIdx = import_react132.useRef(0);
+  const discoveredSkillNamesRef = import_react132.useRef(new Set);
+  const loadedNestedMemoryPathsRef = import_react132.useRef(new Set);
+  const restoreReadFileState = import_react132.useCallback((messages2, cwd) => {
     const extracted = extractReadFilesFromMessages(messages2, cwd, READ_FILE_STATE_CACHE_SIZE);
     readFileState.current = mergeFileStateCaches(readFileState.current, extracted);
     for (const tool of extractBashToolsFromMessages(messages2)) {
       bashTools.current.add(tool);
     }
   }, []);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (initialMessages && initialMessages.length > 0) {
       restoreReadFileState(initialMessages, getOriginalCwd());
       restoreRemoteAgentTasks({
@@ -33237,10 +34000,10 @@ function REPL({
     }
   }, []);
   const { status: apiKeyStatus, reverify } = useApiKeyVerification();
-  const [autoRunIssueReason, setAutoRunIssueReason] = import_react125.useState(null);
-  const didAutoRunIssueRef = import_react125.useRef(false);
-  const [exitFlow, setExitFlow] = import_react125.useState(null);
-  const [isExiting, setIsExiting] = import_react125.useState(false);
+  const [autoRunIssueReason, setAutoRunIssueReason] = import_react132.useState(null);
+  const didAutoRunIssueRef = import_react132.useRef(false);
+  const [exitFlow, setExitFlow] = import_react132.useState(null);
+  const [isExiting, setIsExiting] = import_react132.useState(false);
   const showingCostDialog = !isLoading && showCostDialog;
   function getFocusedInputDialog() {
     if (isExiting || exitFlow)
@@ -33289,7 +34052,7 @@ function REPL({
   const focusedInputDialog = getFocusedInputDialog();
   const hasSuppressedDialogs = isPromptInputActive && (sandboxPermissionRequestQueue[0] || toolUseConfirmQueue[0] || promptQueue[0] || workerSandboxPermissions.queue[0] || elicitation.queue[0] || showingCostDialog);
   focusedInputDialogRef.current = focusedInputDialog;
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (!isLoading)
       return;
     const isPaused = focusedInputDialog === "tool-permission";
@@ -33301,8 +34064,8 @@ function REPL({
       pauseStartTimeRef.current = null;
     }
   }, [focusedInputDialog, isLoading]);
-  const prevDialogRef = import_react125.useRef(focusedInputDialog);
-  import_react125.useLayoutEffect(() => {
+  const prevDialogRef = import_react132.useRef(focusedInputDialog);
+  import_react132.useLayoutEffect(() => {
     const was = prevDialogRef.current === "tool-permission";
     const now = focusedInputDialog === "tool-permission";
     if (was !== now)
@@ -33343,7 +34106,7 @@ function REPL({
     setAbortController(null);
     mrOnTurnComplete(messagesRef.current, true);
   }
-  const handleQueuedCommandOnCancel = import_react125.useCallback(() => {
+  const handleQueuedCommandOnCancel = import_react132.useCallback(() => {
     const result = popAllEditable(inputValue, 0);
     if (!result)
       return;
@@ -33375,7 +34138,7 @@ function REPL({
     inputValue,
     streamMode
   };
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     const totalCost = getTotalCostUSD();
     if (totalCost >= 5 && !showCostDialog && !haveShownCostDialog) {
       logEvent("tengu_cost_threshold_reached", {});
@@ -33385,7 +34148,7 @@ function REPL({
       }
     }
   }, [messages, showCostDialog, haveShownCostDialog]);
-  const sandboxAskCallback = import_react125.useCallback(async (hostPattern) => {
+  const sandboxAskCallback = import_react132.useCallback(async (hostPattern) => {
     if (isAgentSwarmsEnabled() && isSwarmWorker()) {
       const requestId = generateSandboxRequestId();
       const sent = await sendSandboxPermissionRequestViaMailbox(hostPattern.host, requestId);
@@ -33460,7 +34223,7 @@ function REPL({
       }
     });
   }, [setAppState, store]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     const reason = SandboxManager.getSandboxUnavailableReason();
     if (!reason)
       return;
@@ -33499,7 +34262,7 @@ Error: sandbox required but unavailable: ${reason}
       gracefulShutdownSync(1, "other");
     });
   }
-  const setToolPermissionContext = import_react125.useCallback((context, options) => {
+  const setToolPermissionContext = import_react132.useCallback((context, options) => {
     setAppState((prev) => ({
       ...prev,
       toolPermissionContext: {
@@ -33516,15 +34279,15 @@ Error: sandbox required but unavailable: ${reason}
       });
     }, setToolUseConfirmQueue);
   }, [setAppState, setToolUseConfirmQueue]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     registerLeaderSetToolPermissionContext(setToolPermissionContext);
     return () => unregisterLeaderSetToolPermissionContext();
   }, [setToolPermissionContext]);
   const canUseTool = useCanUseTool_default(setToolUseConfirmQueue, setToolPermissionContext);
-  const requestPrompt = import_react125.useCallback((title, toolInputSummary) => (request) => new Promise((resolve, reject) => {
+  const requestPrompt = import_react132.useCallback((title, toolInputSummary) => (request) => new Promise((resolve, reject) => {
     setPromptQueue((prev) => [...prev, { request, title, toolInputSummary, resolve, reject }]);
   }), []);
-  const getToolUseContext = import_react125.useCallback((messages2, newMessages, abortController2, mainLoopModel2) => {
+  const getToolUseContext = import_react132.useCallback((messages2, newMessages, abortController2, mainLoopModel2) => {
     const s = store.getState();
     const computeTools = () => {
       const state = store.getState();
@@ -33655,7 +34418,7 @@ Error: sandbox required but unavailable: ${reason}
     appendSystemPrompt,
     setConversationId
   ]);
-  const handleBackgroundQuery = import_react125.useCallback(() => {
+  const handleBackgroundQuery = import_react132.useCallback(() => {
     abortController?.abort("background");
     const removedNotifications = removeByFilter((cmd) => cmd.mode === "task-notification");
     (async () => {
@@ -33715,7 +34478,7 @@ Error: sandbox required but unavailable: ${reason}
     setAbortController,
     onBackgroundQuery: handleBackgroundQuery
   });
-  const onQueryEvent = import_react125.useCallback((event) => {
+  const onQueryEvent = import_react132.useCallback((event) => {
     handleMessageFromStream(event, (newMessage) => {
       if (isCompactBoundaryMessage(newMessage)) {
         if (isFullscreenEnvEnabled()) {
@@ -33754,7 +34517,33 @@ Error: sandbox required but unavailable: ${reason}
           proactiveModule3?.setContextBlocked(false);
         }
       }
-      if (false) {}
+      if (newMessage.type === "assistant") {
+        const msg = newMessage.message;
+        const contentBlocks = msg?.content ?? newMessage.content ?? [];
+        const textParts = [];
+        if (Array.isArray(contentBlocks)) {
+          for (const block of contentBlocks) {
+            if (typeof block === "string") {
+              textParts.push(block);
+            } else if (block?.type === "text" && block.text) {
+              textParts.push(block.text);
+            }
+          }
+        } else if (typeof contentBlocks === "string") {
+          textParts.push(contentBlocks);
+        }
+        const text = textParts.join(`
+`).trim();
+        if ("isApiErrorMessage" in newMessage && newMessage.isApiErrorMessage) {
+          pipeReturnHadErrorRef.current = true;
+          relayPipeMessage({
+            type: "error",
+            data: text || "Slave request failed"
+          });
+        } else if (text) {
+          relayPipeMessage({ type: "stream", data: text });
+        }
+      }
     }, (newContent) => {
       setResponseLength((length) => length + newContent.length);
     }, setStreamMode, setStreamingToolUses, (tombstonedMessage) => {
@@ -33772,7 +34561,7 @@ Error: sandbox required but unavailable: ${reason}
       });
     }, onStreamingText);
   }, [setMessages, setResponseLength, setStreamMode, setStreamingToolUses, setStreamingThinking, onStreamingText]);
-  const onQueryImpl = import_react125.useCallback(async (messagesIncludingNewMessages, newMessages, abortController2, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort) => {
+  const onQueryImpl = import_react132.useCallback(async (messagesIncludingNewMessages, newMessages, abortController2, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort) => {
     if (shouldQuery) {
       const freshClients = mergeClients(initialMcpClients, store.getState().mcp.clients);
       diagnosticTracker.handleQueryStart(freshClients);
@@ -33877,7 +34666,15 @@ Error: sandbox required but unavailable: ${reason}
       _fireCompanionObserver(messagesRef.current, (reaction) => setAppState((prev) => prev.companionReaction === reaction ? prev : { ...prev, companionReaction: reaction }));
     }
     queryCheckpoint("query_end");
-    if (false) {}
+    if (true) {
+      if (abortController2.signal.aborted) {
+        pipeReturnHadErrorRef.current = true;
+        relayPipeMessage({
+          type: "error",
+          data: "Slave request was interrupted before completion."
+        });
+      }
+    }
     if (process.env.USER_TYPE === "ant" && apiMetricsRef.current.length > 0) {
       const entries = apiMetricsRef.current;
       const ttfts = entries.map((e) => e.ttftMs);
@@ -33929,7 +34726,7 @@ Error: sandbox required but unavailable: ${reason}
     sessionTitle,
     titleDisabled
   ]);
-  const onQuery = import_react125.useCallback(async (newMessages, abortController2, shouldQuery, additionalAllowedTools, mainLoopModelParam, onBeforeQueryCallback, input, effort) => {
+  const onQuery = import_react132.useCallback(async (newMessages, abortController2, shouldQuery, additionalAllowedTools, mainLoopModelParam, onBeforeQueryCallback, input, effort) => {
     if (isAgentSwarmsEnabled()) {
       const teamName = getTeamName();
       const agentName = getAgentName();
@@ -33973,7 +34770,13 @@ Error: sandbox required but unavailable: ${reason}
       try {
         await onQueryImpl(latestMessages, newMessages, abortController2, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort);
       } catch (error) {
-        if (false) {}
+        if (true) {
+          pipeReturnHadErrorRef.current = true;
+          relayPipeMessage({
+            type: "error",
+            data: error instanceof Error ? error.message : String(error)
+          });
+        }
         throw error;
       }
     } finally {
@@ -33982,7 +34785,12 @@ Error: sandbox required but unavailable: ${reason}
         skipIdleCheckRef.current = false;
         resetLoadingState();
         await mrOnTurnComplete(messagesRef.current, abortController2.signal.aborted);
-        if (false) {}
+        if (!pipeReturnHadErrorRef.current) {
+          relayPipeMessage({
+            type: "done",
+            data: ""
+          });
+        }
         sendBridgeResultRef.current();
         if (process.env.USER_TYPE === "ant" && !abortController2.signal.aborted) {
           setAppState((prev) => {
@@ -34036,8 +34844,8 @@ Error: sandbox required but unavailable: ${reason}
       }
     }
   }, [onQueryImpl, setAppState, resetLoadingState, queryGuard, mrOnBeforeQuery, mrOnTurnComplete]);
-  const initialMessageRef = import_react125.useRef(false);
-  import_react125.useEffect(() => {
+  const initialMessageRef = import_react132.useRef(false);
+  import_react132.useEffect(() => {
     const pending = initialMessage;
     if (!pending || isLoading || initialMessageRef.current)
       return;
@@ -34045,7 +34853,7 @@ Error: sandbox required but unavailable: ${reason}
     async function processInitialMessage(initialMsg) {
       if (initialMsg.clearContext) {
         const oldPlanSlug = initialMsg.message.planContent ? getPlanSlug() : undefined;
-        const { clearConversation: clearConversation2 } = await import("./chunk-pkbsek0t.js");
+        const { clearConversation: clearConversation2 } = await import("./chunk-zyptmnvp.js");
         await clearConversation2({
           setMessages,
           readFileState: readFileState.current,
@@ -34105,7 +34913,7 @@ Error: sandbox required but unavailable: ${reason}
     }
     processInitialMessage(pending);
   }, [initialMessage, isLoading, setMessages, setAppState, onQuery, mainLoopModel, tools]);
-  const onSubmit = import_react125.useCallback(async (input, helpers, speculationAccept, options) => {
+  const onSubmit = import_react132.useCallback(async (input, helpers, speculationAccept, options) => {
     repinScroll();
     if (true) {
       proactiveModule3?.resumeProactive();
@@ -34259,7 +35067,16 @@ Error: sandbox required but unavailable: ${reason}
         setUserInputOnProcessing(input);
         resetTimingRefs();
       }
-      if (false) {}
+      if (true) {
+        setAppState((prev) => ({
+          ...prev,
+          attribution: incrementPromptCount(prev.attribution, (snapshot) => {
+            recordAttributionSnapshot(snapshot).catch((error) => {
+              logForDebugging(`Attribution: Failed to save snapshot: ${error}`);
+            });
+          })
+        }));
+      }
     }
     if (speculationAccept) {
       const { queryRequired } = await handleSpeculationAccept(speculationAccept.state, speculationAccept.speculationSessionTimeSavedMs, speculationAccept.setAppState, input, {
@@ -34383,7 +35200,7 @@ Error: sandbox required but unavailable: ${reason}
     awaitPendingHooks,
     repinScroll
   ]);
-  const onAgentSubmit = import_react125.useCallback(async (input, task, helpers) => {
+  const onAgentSubmit = import_react132.useCallback(async (input, task, helpers) => {
     if (isLocalAgentTask(task)) {
       appendMessageToLocalAgent(task.id, createUserMessage({ content: input }), setAppState);
       if (task.status === "running") {
@@ -34416,7 +35233,7 @@ Error: sandbox required but unavailable: ${reason}
     helpers.setCursorOffset(0);
     helpers.clearBuffer();
   }, [setAppState, setInputValue, getToolUseContext, canUseTool, mainLoopModel, addNotification]);
-  const handleAutoRunIssue = import_react125.useCallback(() => {
+  const handleAutoRunIssue = import_react132.useCallback(() => {
     const command = autoRunIssueReason ? getAutoRunCommand(autoRunIssueReason) : "/issue";
     setAutoRunIssueReason(null);
     onSubmit(command, {
@@ -34427,10 +35244,10 @@ Error: sandbox required but unavailable: ${reason}
       logForDebugging(`Auto-run ${command} failed: ${errorMessage(err)}`);
     });
   }, [onSubmit, autoRunIssueReason]);
-  const handleCancelAutoRunIssue = import_react125.useCallback(() => {
+  const handleCancelAutoRunIssue = import_react132.useCallback(() => {
     setAutoRunIssueReason(null);
   }, []);
-  const handleSurveyRequestFeedback = import_react125.useCallback(() => {
+  const handleSurveyRequestFeedback = import_react132.useCallback(() => {
     const command = process.env.USER_TYPE === "ant" ? "/issue" : "/feedback";
     onSubmit(command, {
       setCursorOffset: () => {},
@@ -34440,16 +35257,16 @@ Error: sandbox required but unavailable: ${reason}
       logForDebugging(`Survey feedback request failed: ${err instanceof Error ? err.message : String(err)}`);
     });
   }, [onSubmit]);
-  const onSubmitRef = import_react125.useRef(onSubmit);
+  const onSubmitRef = import_react132.useRef(onSubmit);
   onSubmitRef.current = onSubmit;
-  const handleOpenRateLimitOptions = import_react125.useCallback(() => {
+  const handleOpenRateLimitOptions = import_react132.useCallback(() => {
     onSubmitRef.current("/rate-limit-options", {
       setCursorOffset: () => {},
       clearBuffer: () => {},
       resetHistory: () => {}
     });
   }, []);
-  const handleExit = import_react125.useCallback(async () => {
+  const handleExit = import_react132.useCallback(async () => {
     setIsExiting(true);
     if (isBgSession()) {
       spawnSync("tmux", ["detach-client"], { stdio: "ignore" });
@@ -34475,10 +35292,10 @@ Error: sandbox required but unavailable: ${reason}
       setIsExiting(false);
     }
   }, []);
-  const handleShowMessageSelector = import_react125.useCallback(() => {
+  const handleShowMessageSelector = import_react132.useCallback(() => {
     setIsMessageSelectorVisible((prev) => !prev);
   }, []);
-  const rewindConversationTo = import_react125.useCallback((message) => {
+  const rewindConversationTo = import_react132.useCallback((message) => {
     const prev = messagesRef.current;
     const messageIndex = prev.lastIndexOf(message);
     if (messageIndex === -1)
@@ -34511,7 +35328,7 @@ Error: sandbox required but unavailable: ${reason}
       }
     }));
   }, [setMessages, setAppState]);
-  const restoreMessageSync = import_react125.useCallback((message) => {
+  const restoreMessageSync = import_react132.useCallback((message) => {
     rewindConversationTo(message);
     const r = textForResubmit(message);
     if (r) {
@@ -34538,7 +35355,7 @@ Error: sandbox required but unavailable: ${reason}
     }
   }, [rewindConversationTo, setInputValue]);
   restoreMessageSyncRef.current = restoreMessageSync;
-  const handleRestoreMessage = import_react125.useCallback(async (message) => {
+  const handleRestoreMessage = import_react132.useCallback(async (message) => {
     setImmediate((restore, message2) => restore(message2), restoreMessageSync, message);
   }, [restoreMessageSync]);
   const findRawIndex = (uuid) => {
@@ -34600,8 +35417,8 @@ ${fileList}`);
   const { sendBridgeResult } = useReplBridge(messages, setMessages, abortControllerRef, commands, mainLoopModel);
   sendBridgeResultRef.current = sendBridgeResult;
   useAfterFirstRender();
-  const hasCountedQueueUseRef = import_react125.useRef(false);
-  import_react125.useEffect(() => {
+  const hasCountedQueueUseRef = import_react132.useRef(false);
+  import_react132.useEffect(() => {
     if (queuedCommands.length < 1) {
       hasCountedQueueUseRef.current = false;
       return;
@@ -34614,7 +35431,7 @@ ${fileList}`);
       promptQueueUseCount: (current.promptQueueUseCount ?? 0) + 1
     }));
   }, [queuedCommands.length]);
-  const executeQueuedInput = import_react125.useCallback(async (queuedCommands2) => {
+  const executeQueuedInput = import_react132.useCallback(async (queuedCommands2) => {
     await handlePromptSubmit({
       helpers: {
         setCursorOffset: () => {},
@@ -34662,16 +35479,16 @@ ${fileList}`);
     hasActiveLocalJsxUI: isShowingLocalJSXCommand,
     queryGuard
   });
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     activityManager.recordUserActivity();
     updateLastInteractionTime(true);
   }, [inputValue, submitCount]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (submitCount === 1) {
       startBackgroundHousekeeping();
     }
   }, [submitCount]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (isLoading)
       return;
     if (submitCount === 0)
@@ -34693,7 +35510,7 @@ ${fileList}`);
     }, getGlobalConfig().messageIdleNotifThresholdMs, lastQueryCompletionTime, isLoading, toolJSX, focusedInputDialogRef, terminal);
     return () => clearTimeout(timer);
   }, [isLoading, toolJSX, submitCount, lastQueryCompletionTime, terminal]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (lastQueryCompletionTime === 0)
       return;
     if (isLoading)
@@ -34765,7 +35582,7 @@ ${fileList}`);
       idleHintShownRef.current = false;
     };
   }, [lastQueryCompletionTime, isLoading, addNotification, removeNotification]);
-  const handleIncomingPrompt = import_react125.useCallback((input, options) => {
+  const handleIncomingPrompt = import_react132.useCallback((input, options) => {
     if (queryGuard.isActive)
       return false;
     if (getCommandQueue().some((cmd) => cmd.mode === "prompt" || cmd.mode === "bash")) {
@@ -34810,7 +35627,7 @@ ${fileList}`);
     });
     return true;
   }, [onQuery, mainLoopModel, store]);
-  const { relayPipeMessage, pipeReturnHadErrorRef } = usePipeRelay();
+  const { relayPipeMessage, pipeReturnHadErrorRef } = usePipeRelay2();
   const voice = useVoiceIntegration2({ setInputValueRaw, inputValueRef, insertTextRef });
   useInboxPoller({
     enabled: isAgentSwarmsEnabled(),
@@ -34820,12 +35637,12 @@ ${fileList}`);
   });
   useMailboxBridge({ isLoading, onSubmitMessage: handleIncomingPrompt });
   useMasterMonitor();
-  useSlaveNotifications();
+  useSlaveNotifications2();
   const pipeIpcState = useAppState((s) => getPipeIpc(s));
-  usePipePermissionForward({ store, tools, setMessages, setToolUseConfirmQueue, getToolUseContext, mainLoopModel });
-  usePipeMuteSync({ setToolUseConfirmQueue });
-  usePipeIpc({ store, handleIncomingPrompt });
-  const { routeToSelectedPipes } = usePipeRouter({ store, setAppState, addNotification });
+  usePipePermissionForward2({ store, tools, setMessages, setToolUseConfirmQueue, getToolUseContext, mainLoopModel });
+  usePipeMuteSync2({ setToolUseConfirmQueue });
+  usePipeIpc2({ store, handleIncomingPrompt });
+  const { routeToSelectedPipes } = usePipeRouter2({ store, setAppState, addNotification });
   if (true) {
     const assistantMode = store.getState().kairosEnabled;
     useScheduledTasks2({ isLoading, assistantMode, setMessages });
@@ -34844,7 +35661,7 @@ ${fileList}`);
     isInPlanMode: toolPermissionContext.mode === "plan",
     onQueueTick: (command) => enqueue(command)
   });
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (!proactiveActive) {
       notifyAutomationStateChanged(null);
       return;
@@ -34876,20 +35693,20 @@ ${fileList}`);
     queuedCommands.length,
     toolPermissionContext.mode
   ]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (queuedCommands.some((cmd) => cmd.priority === "now")) {
       abortControllerRef.current?.abort("interrupt");
     }
   }, [queuedCommands]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     onInit();
     return () => {
       diagnosticTracker.shutdown();
     };
   }, []);
   const { internal_eventEmitter } = use_stdin_default();
-  const [remountKey, setRemountKey] = import_react125.useState(0);
-  import_react125.useEffect(() => {
+  const [remountKey, setRemountKey] = import_react132.useState(0);
+  import_react132.useEffect(() => {
     const handleSuspend = () => {
       process.stdout.write(`
 Claude Code has been suspended. Run \`fg\` to bring Claude Code back.
@@ -34906,7 +35723,7 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
       internal_eventEmitter?.off("resume", handleResume);
     };
   }, [internal_eventEmitter]);
-  const stopHookSpinnerSuffix = import_react125.useMemo(() => {
+  const stopHookSpinnerSuffix = import_react132.useMemo(() => {
     if (!isLoading)
       return null;
     const progressMsgs = messages.filter((m) => {
@@ -34943,22 +35760,22 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
     }
     return total === 1 ? `running ${hookType} hook` : `running stop hooks\u2026 ${completedCount}/${total}`;
   }, [messages, isLoading]);
-  const handleEnterTranscript = import_react125.useCallback(() => {
+  const handleEnterTranscript = import_react132.useCallback(() => {
     setFrozenTranscriptState({
       messagesLength: messages.length,
       streamingToolUsesLength: streamingToolUses.length
     });
   }, [messages.length, streamingToolUses.length]);
-  const handleExitTranscript = import_react125.useCallback(() => {
+  const handleExitTranscript = import_react132.useCallback(() => {
     setFrozenTranscriptState(null);
   }, []);
   const virtualScrollActive = isFullscreenEnvEnabled() && !disableVirtualScroll;
-  const jumpRef = import_react125.useRef(null);
-  const [searchOpen, setSearchOpen] = import_react125.useState(false);
-  const [searchQuery, setSearchQuery] = import_react125.useState("");
-  const [searchCount, setSearchCount] = import_react125.useState(0);
-  const [searchCurrent, setSearchCurrent] = import_react125.useState(0);
-  const onSearchMatchesChange = import_react125.useCallback((count2, current) => {
+  const jumpRef = import_react132.useRef(null);
+  const [searchOpen, setSearchOpen] = import_react132.useState(false);
+  const [searchQuery, setSearchQuery] = import_react132.useState("");
+  const [searchCount, setSearchCount] = import_react132.useState(0);
+  const [searchCurrent, setSearchCurrent] = import_react132.useState(0);
+  const onSearchMatchesChange = import_react132.useCallback((count2, current) => {
     setSearchCount(count2);
     setSearchCurrent(current);
   }, []);
@@ -35028,8 +35845,8 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
           const w = Math.max(80, (process.stdout.columns ?? 80) - 6);
           const raw = await renderMessagesToPlainText(deferredMessages, tools, w);
           const text = raw.replace(/[ \t]+$/gm, "");
-          const path2 = join6(tmpdir(), `cc-transcript-${Date.now()}.txt`);
-          await writeFile3(path2, text);
+          const path2 = join5(tmpdir(), `cc-transcript-${Date.now()}.txt`);
+          await writeFile2(path2, text);
           const opened = openFileInExternalEditor(path2);
           setStatus(opened ? `opening ${path2}` : `wrote ${path2} \xB7 no $VISUAL/$EDITOR set`);
         } catch (e) {
@@ -35043,7 +35860,7 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
     }
   }, { isActive: screen === "transcript" && virtualScrollActive && !searchOpen });
   const inTranscript = screen === "transcript" && virtualScrollActive;
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     if (!inTranscript) {
       setSearchQuery("");
       setSearchCount(0);
@@ -35055,7 +35872,7 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
       setEditorStatus("");
     }
   }, [inTranscript]);
-  import_react125.useEffect(() => {
+  import_react132.useEffect(() => {
     setHighlight(inTranscript ? searchQuery : "");
     if (!inTranscript)
       setPositions(null);
@@ -35310,7 +36127,6 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
                 children: toolJSX.jsx
               }, undefined, false, undefined, this),
               process.env.USER_TYPE === "ant" && /* @__PURE__ */ jsx_dev_runtime97.jsxDEV(TungstenLiveMonitor, {}, undefined, false, undefined, this),
-              null,
               /* @__PURE__ */ jsx_dev_runtime97.jsxDEV(ThemedBox_default, {
                 flexGrow: 1
               }, undefined, false, undefined, this),
@@ -35531,7 +36347,7 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
                         });
                       }
                       if (action === "clear") {
-                        const { clearConversation: clearConversation2 } = await import("./chunk-pkbsek0t.js");
+                        const { clearConversation: clearConversation2 } = await import("./chunk-zyptmnvp.js");
                         await clearConversation2({
                           setMessages,
                           readFileState: readFileState.current,
@@ -35708,7 +36524,7 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
                         inputValue,
                         setInputValue
                       }, undefined, false, undefined, this),
-                      process.env.USER_TYPE === "ant" && skillImprovementSurvey.suggestion && /* @__PURE__ */ jsx_dev_runtime97.jsxDEV(SkillImprovementSurvey, {
+                      skillImprovementSurvey.suggestion && /* @__PURE__ */ jsx_dev_runtime97.jsxDEV(SkillImprovementSurvey, {
                         isOpen: skillImprovementSurvey.isOpen,
                         skillName: skillImprovementSurvey.suggestion.skillName,
                         updates: skillImprovementSurvey.suggestion.updates,