@xortex/xcode 3.0.5 → 3.1.0

package/interactiveHelpers.tsx

@@ -0,0 +1,366 @@
+import { feature } from 'bun:bundle';
+import { appendFileSync } from 'fs';
+import React from 'react';
+import { logEvent } from 'src/services/analytics/index.js';
+import { gracefulShutdown, gracefulShutdownSync } from 'src/utils/gracefulShutdown.js';
+import { type ChannelEntry, getAllowedChannels, setAllowedChannels, setHasDevChannels, setSessionTrustAccepted, setStatsStore } from './bootstrap/state.js';
+import type { Command } from './commands.js';
+import { createStatsStore, type StatsStore } from './context/stats.js';
+import { getSystemContext } from './context.js';
+import { initializeTelemetryAfterTrust } from './entrypoints/init.js';
+import { isSynchronizedOutputSupported } from './ink/terminal.js';
+import type { RenderOptions, Root, TextProps } from './ink.js';
+import { KeybindingSetup } from './keybindings/KeybindingProviderSetup.js';
+import { startDeferredPrefetches } from './main.js';
+import { checkGate_CACHED_OR_BLOCKING, initializeGrowthBook, resetGrowthBook } from './services/analytics/growthbook.js';
+import { isQualifiedForGrove } from './services/api/grove.js';
+import { handleMcpjsonServerApprovals } from './services/mcpServerApproval.js';
+import { AppStateProvider } from './state/AppState.js';
+import { onChangeAppState } from './state/onChangeAppState.js';
+import { normalizeApiKeyForConfig } from './utils/authPortable.js';
+import { getExternalClaudeMdIncludes, getMemoryFiles, shouldShowClaudeMdExternalIncludesWarning } from './utils/claudemd.js';
+import { checkHasTrustDialogAccepted, getCustomApiKeyStatus, getGlobalConfig, saveGlobalConfig } from './utils/config.js';
+import { updateDeepLinkTerminalPreference } from './utils/deepLink/terminalPreference.js';
+import { isEnvTruthy, isRunningOnHomespace } from './utils/envUtils.js';
+import { type FpsMetrics, FpsTracker } from './utils/fpsTracker.js';
+import { updateGithubRepoPathMapping } from './utils/githubRepoPathMapping.js';
+import { applyConfigEnvironmentVariables } from './utils/managedEnv.js';
+import type { PermissionMode } from './utils/permissions/PermissionMode.js';
+import { getBaseRenderOptions } from './utils/renderOptions.js';
+import { getSettingsWithAllErrors } from './utils/settings/allErrors.js';
+import { hasAutoModeOptIn, hasSkipDangerousModePermissionPrompt } from './utils/settings/settings.js';
+export function completeOnboarding(): void {
+  saveGlobalConfig(current => ({
+    ...current,
+    hasCompletedOnboarding: true,
+    lastOnboardingVersion: MACRO.VERSION
+  }));
+}
+export function showDialog<T = void>(root: Root, renderer: (done: (result: T) => void) => React.ReactNode): Promise<T> {
+  return new Promise<T>(resolve => {
+    const done = (result: T): void => void resolve(result);
+    root.render(renderer(done));
+  });
+}
+
+/**
+ * Render an error message through Ink, then unmount and exit.
+ * Use this for fatal errors after the Ink root has been created —
+ * console.error is swallowed by Ink's patchConsole, so we render
+ * through the React tree instead.
+ */
+export async function exitWithError(root: Root, message: string, beforeExit?: () => Promise<void>): Promise<never> {
+  return exitWithMessage(root, message, {
+    color: 'error',
+    beforeExit
+  });
+}
+
+/**
+ * Render a message through Ink, then unmount and exit.
+ * Use this for messages after the Ink root has been created —
+ * console output is swallowed by Ink's patchConsole, so we render
+ * through the React tree instead.
+ */
+export async function exitWithMessage(root: Root, message: string, options?: {
+  color?: TextProps['color'];
+  exitCode?: number;
+  beforeExit?: () => Promise<void>;
+}): Promise<never> {
+  const {
+    Text
+  } = await import('./ink.js');
+  const color = options?.color;
+  const exitCode = options?.exitCode ?? 1;
+  root.render(color ? <Text color={color}>{message}</Text> : <Text>{message}</Text>);
+  root.unmount();
+  await options?.beforeExit?.();
+  // eslint-disable-next-line custom-rules/no-process-exit -- exit after Ink unmount
+  process.exit(exitCode);
+}
+
+/**
+ * Show a setup dialog wrapped in AppStateProvider + KeybindingSetup.
+ * Reduces boilerplate in showSetupScreens() where every dialog needs these wrappers.
+ */
+export function showSetupDialog<T = void>(root: Root, renderer: (done: (result: T) => void) => React.ReactNode, options?: {
+  onChangeAppState?: typeof onChangeAppState;
+}): Promise<T> {
+  return showDialog<T>(root, done => <AppStateProvider onChangeAppState={options?.onChangeAppState}>
+      <KeybindingSetup>{renderer(done)}</KeybindingSetup>
+    </AppStateProvider>);
+}
+
+/**
+ * Render the main UI into the root and wait for it to exit.
+ * Handles the common epilogue: start deferred prefetches, wait for exit, graceful shutdown.
+ */
+export async function renderAndRun(root: Root, element: React.ReactNode): Promise<void> {
+  root.render(element);
+  startDeferredPrefetches();
+  await root.waitUntilExit();
+  await gracefulShutdown(0);
+}
+export async function showSetupScreens(root: Root, permissionMode: PermissionMode, allowDangerouslySkipPermissions: boolean, commands?: Command[], claudeInChrome?: boolean, devChannels?: ChannelEntry[]): Promise<boolean> {
+  if ("production" === 'test' || isEnvTruthy(false) || process.env.IS_DEMO // Skip onboarding in demo mode
+  ) {
+    return false;
+  }
+  const config = getGlobalConfig();
+  let onboardingShown = false;
+  if (!config.theme || !config.hasCompletedOnboarding // always show onboarding at least once
+  ) {
+    onboardingShown = true;
+    const {
+      Onboarding
+    } = await import('./components/Onboarding.js');
+    await showSetupDialog(root, done => <Onboarding onDone={() => {
+      completeOnboarding();
+      void done();
+    }} />, {
+      onChangeAppState
+    });
+  }
+
+  // Always show the trust dialog in interactive sessions, regardless of permission mode.
+  // The trust dialog is the workspace trust boundary — it warns about untrusted repos
+  // and checks CLAUDE.md external includes. bypassPermissions mode
+  // only affects tool execution permissions, not workspace trust.
+  // Note: non-interactive sessions (CI/CD with -p) never reach showSetupScreens at all.
+  // Skip permission checks in claubbit
+  if (!isEnvTruthy(process.env.CLAUBBIT)) {
+    // Fast-path: skip TrustDialog import+render when CWD is already trusted.
+    // If it returns true, the TrustDialog would auto-resolve regardless of
+    // security features, so we can skip the dynamic import and render cycle.
+    if (!checkHasTrustDialogAccepted()) {
+      const {
+        TrustDialog
+      } = await import('./components/TrustDialog/TrustDialog.js');
+      await showSetupDialog(root, done => <TrustDialog commands={commands} onDone={done} />);
+    }
+
+    // Signal that trust has been verified for this session.
+    // GrowthBook checks this to decide whether to include auth headers.
+    setSessionTrustAccepted(true);
+
+    // Reset and reinitialize GrowthBook after trust is established.
+    // Defense for login/logout: clears any prior client so the next init
+    // picks up fresh auth headers.
+    resetGrowthBook();
+    void initializeGrowthBook();
+
+    // Now that trust is established, prefetch system context if it wasn't already
+    void getSystemContext();
+
+    // If settings are valid, check for any mcp.json servers that need approval
+    const {
+      errors: allErrors
+    } = getSettingsWithAllErrors();
+    if (allErrors.length === 0) {
+      await handleMcpjsonServerApprovals(root);
+    }
+
+    // Check for claude.md includes that need approval
+    if (await shouldShowClaudeMdExternalIncludesWarning()) {
+      const externalIncludes = getExternalClaudeMdIncludes(await getMemoryFiles(true));
+      const {
+        ClaudeMdExternalIncludesDialog
+      } = await import('./components/ClaudeMdExternalIncludesDialog.js');
+      await showSetupDialog(root, done => <ClaudeMdExternalIncludesDialog onDone={done} isStandaloneDialog externalIncludes={externalIncludes} />);
+    }
+  }
+
+  // Track current repo path for teleport directory switching (fire-and-forget)
+  // This must happen AFTER trust to prevent untrusted directories from poisoning the mapping
+  void updateGithubRepoPathMapping();
+  if (feature('LODESTONE')) {
+    updateDeepLinkTerminalPreference();
+  }
+
+  // Apply full environment variables after trust dialog is accepted OR in bypass mode
+  // In bypass mode (CI/CD, automation), we trust the environment so apply all variables
+  // In normal mode, this happens after the trust dialog is accepted
+  // This includes potentially dangerous environment variables from untrusted sources
+  applyConfigEnvironmentVariables();
+
+  // Initialize telemetry after env vars are applied so OTEL endpoint env vars and
+  // otelHeadersHelper (which requires trust to execute) are available.
+  // Defer to next tick so the OTel dynamic import resolves after first render
+  // instead of during the pre-render microtask queue.
+  setImmediate(() => initializeTelemetryAfterTrust());
+  if (await isQualifiedForGrove()) {
+    const {
+      GroveDialog
+    } = await import('src/components/grove/Grove.js');
+    const decision = await showSetupDialog<string>(root, done => <GroveDialog showIfAlreadyViewed={false} location={onboardingShown ? 'onboarding' : 'policy_update_modal'} onDone={done} />);
+    if (decision === 'escape') {
+      logEvent('tengu_grove_policy_exited', {});
+      gracefulShutdownSync(0);
+      return false;
+    }
+  }
+
+  // Check for custom API key
+  // On homespace, ANTHROPIC_API_KEY is preserved in process.env for child
+  // processes but ignored by Claude Code itself (see auth.ts).
+  if (process.env.ANTHROPIC_API_KEY && !isRunningOnHomespace()) {
+    const customApiKeyTruncated = normalizeApiKeyForConfig(process.env.ANTHROPIC_API_KEY);
+    const keyStatus = getCustomApiKeyStatus(customApiKeyTruncated);
+    if (keyStatus === 'new') {
+      const {
+        ApproveApiKey
+      } = await import('./components/ApproveApiKey.js');
+      await showSetupDialog<boolean>(root, done => <ApproveApiKey customApiKeyTruncated={customApiKeyTruncated} onDone={done} />, {
+        onChangeAppState
+      });
+    }
+  }
+  if ((permissionMode === 'bypassPermissions' || allowDangerouslySkipPermissions) && !hasSkipDangerousModePermissionPrompt()) {
+    const {
+      BypassPermissionsModeDialog
+    } = await import('./components/BypassPermissionsModeDialog.js');
+    await showSetupDialog(root, done => <BypassPermissionsModeDialog onAccept={done} />);
+  }
+  if (feature('TRANSCRIPT_CLASSIFIER')) {
+    // Only show the opt-in dialog if auto mode actually resolved — if the
+    // gate denied it (org not allowlisted, settings disabled), showing
+    // consent for an unavailable feature is pointless. The
+    // verifyAutoModeGateAccess notification will explain why instead.
+    if (permissionMode === 'auto' && !hasAutoModeOptIn()) {
+      const {
+        AutoModeOptInDialog
+      } = await import('./components/AutoModeOptInDialog.js');
+      await showSetupDialog(root, done => <AutoModeOptInDialog onAccept={done} onDecline={() => gracefulShutdownSync(1)} declineExits />);
+    }
+  }
+
+  // --dangerously-load-development-channels confirmation. On accept, append
+  // dev channels to any --channels list already set in main.tsx. Org policy
+  // is NOT bypassed — gateChannelServer() still runs; this flag only exists
+  // to sidestep the --channels approved-server allowlist.
+  if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
+    // gateChannelServer and ChannelsNotice read tengu_harbor after this
+    // function returns. A cold disk cache (fresh install, or first run after
+    // the flag was added server-side) defaults to false and silently drops
+    // channel notifications for the whole session — gh#37026.
+    // checkGate_CACHED_OR_BLOCKING returns immediately if disk already says
+    // true; only blocks on a cold/stale-false cache (awaits the same memoized
+    // initializeGrowthBook promise fired earlier). Also warms the
+    // isChannelsEnabled() check in the dev-channels dialog below.
+    if (getAllowedChannels().length > 0 || (devChannels?.length ?? 0) > 0) {
+      await checkGate_CACHED_OR_BLOCKING('tengu_harbor');
+    }
+    if (devChannels && devChannels.length > 0) {
+      const [{
+        isChannelsEnabled
+      }, {
+        getClaudeAIOAuthTokens
+      }] = await Promise.all([import('./services/mcp/channelAllowlist.js'), import('./utils/auth.js')]);
+      // Skip the dialog when channels are blocked (tengu_harbor off or no
+      // OAuth) — accepting then immediately seeing "not available" in
+      // ChannelsNotice is worse than no dialog. Append entries anyway so
+      // ChannelsNotice renders the blocked branch with the dev entries
+      // named. dev:true here is for the flag label in ChannelsNotice
+      // (hasNonDev check); the allowlist bypass it also grants is moot
+      // since the gate blocks upstream.
+      if (!isChannelsEnabled() || !getClaudeAIOAuthTokens()?.accessToken) {
+        setAllowedChannels([...getAllowedChannels(), ...devChannels.map(c => ({
+          ...c,
+          dev: true
+        }))]);
+        setHasDevChannels(true);
+      } else {
+        const {
+          DevChannelsDialog
+        } = await import('./components/DevChannelsDialog.js');
+        await showSetupDialog(root, done => <DevChannelsDialog channels={devChannels} onAccept={() => {
+          // Mark dev entries per-entry so the allowlist bypass doesn't leak
+          // to --channels entries when both flags are passed.
+          setAllowedChannels([...getAllowedChannels(), ...devChannels.map(c => ({
+            ...c,
+            dev: true
+          }))]);
+          setHasDevChannels(true);
+          void done();
+        }} />);
+      }
+    }
+  }
+
+  // Show Chrome onboarding for first-time Claude in Chrome users
+  if (claudeInChrome && !getGlobalConfig().hasCompletedClaudeInChromeOnboarding) {
+    const {
+      ClaudeInChromeOnboarding
+    } = await import('./components/ClaudeInChromeOnboarding.js');
+    await showSetupDialog(root, done => <ClaudeInChromeOnboarding onDone={done} />);
+  }
+  return onboardingShown;
+}
+export function getRenderContext(exitOnCtrlC: boolean): {
+  renderOptions: RenderOptions;
+  getFpsMetrics: () => FpsMetrics | undefined;
+  stats: StatsStore;
+} {
+  let lastFlickerTime = 0;
+  const baseOptions = getBaseRenderOptions(exitOnCtrlC);
+
+  // Log analytics event when stdin override is active
+  if (baseOptions.stdin) {
+    logEvent('tengu_stdin_interactive', {});
+  }
+  const fpsTracker = new FpsTracker();
+  const stats = createStatsStore();
+  setStatsStore(stats);
+
+  // Bench mode: when set, append per-frame phase timings as JSONL for
+  // offline analysis by bench/repl-scroll.ts. Captures the full TUI
+  // render pipeline (yoga → screen buffer → diff → optimize → stdout)
+  // so perf work on any phase can be validated against real user flows.
+  const frameTimingLogPath = process.env.CLAUDE_CODE_FRAME_TIMING_LOG;
+  return {
+    getFpsMetrics: () => fpsTracker.getMetrics(),
+    stats,
+    renderOptions: {
+      ...baseOptions,
+      onFrame: event => {
+        fpsTracker.record(event.durationMs);
+        stats.observe('frame_duration_ms', event.durationMs);
+        if (frameTimingLogPath && event.phases) {
+          // Bench-only env-var-gated path: sync write so no frames dropped
+          // on abrupt exit. ~100 bytes at ≤60fps is negligible. rss/cpu are
+          // single syscalls; cpu is cumulative — bench side computes delta.
+          const line =
+          // eslint-disable-next-line custom-rules/no-direct-json-operations -- tiny object, hot bench path
+          JSON.stringify({
+            total: event.durationMs,
+            ...event.phases,
+            rss: process.memoryUsage.rss(),
+            cpu: process.cpuUsage()
+          }) + '\n';
+          // eslint-disable-next-line custom-rules/no-sync-fs -- bench-only, sync so no frames dropped on exit
+          appendFileSync(frameTimingLogPath, line);
+        }
+        // Skip flicker reporting for terminals with synchronized output —
+        // DEC 2026 buffers between BSU/ESU so clear+redraw is atomic.
+        if (isSynchronizedOutputSupported()) {
+          return;
+        }
+        for (const flicker of event.flickers) {
+          if (flicker.reason === 'resize') {
+            continue;
+          }
+          const now = Date.now();
+          if (now - lastFlickerTime < 1000) {
+            logEvent('tengu_flicker', {
+              desiredHeight: flicker.desiredHeight,
+              actualHeight: flicker.availableHeight,
+              reason: flicker.reason
+            } as unknown as Record<string, boolean | number | undefined>);
+          }
+          lastFlickerTime = now;
+        }
+      }
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","appendFileSync","React","logEvent","gracefulShutdown","gracefulShutdownSync","ChannelEntry","getAllowedChannels","setAllowedChannels","setHasDevChannels","setSessionTrustAccepted","setStatsStore","Command","createStatsStore","StatsStore","getSystemContext","initializeTelemetryAfterTrust","isSynchronizedOutputSupported","RenderOptions","Root","TextProps","KeybindingSetup","startDeferredPrefetches","checkGate_CACHED_OR_BLOCKING","initializeGrowthBook","resetGrowthBook","isQualifiedForGrove","handleMcpjsonServerApprovals","AppStateProvider","onChangeAppState","normalizeApiKeyForConfig","getExternalClaudeMdIncludes","getMemoryFiles","shouldShowClaudeMdExternalIncludesWarning","checkHasTrustDialogAccepted","getCustomApiKeyStatus","getGlobalConfig","saveGlobalConfig","updateDeepLinkTerminalPreference","isEnvTruthy","isRunningOnHomespace","FpsMetrics","FpsTracker","updateGithubRepoPathMapping","applyConfigEnvironmentVariables","PermissionMode","getBaseRenderOptions","getSettingsWithAllErrors","hasAutoModeOptIn","hasSkipDangerousModePermissionPrompt","completeOnboarding","current","hasCompletedOnboarding","lastOnboardingVersion","MACRO","VERSION","showDialog","root","renderer","done","result","T","ReactNode","Promise","resolve","render","exitWithError","message","beforeExit","exitWithMessage","color","options","exitCode","Text","unmount","process","exit","showSetupDialog","renderAndRun","element","waitUntilExit","showSetupScreens","permissionMode","allowDangerouslySkipPermissions","commands","claudeInChrome","devChannels","env","IS_DEMO","config","onboardingShown","theme","Onboarding","CLAUBBIT","TrustDialog","errors","allErrors","length","externalIncludes","ClaudeMdExternalIncludesDialog","setImmediate","GroveDialog","decision","ANTHROPIC_API_KEY","customApiKeyTruncated","keyStatus","ApproveApiKey","BypassPermissionsModeDialog","AutoModeOptInDialog","isChannelsEnabled","getClaudeAIOAuthTokens","all","accessToken","map","c","dev","DevChannelsDialog","hasCompletedClaudeInChromeOnboarding","ClaudeInChromeOnboarding","getRenderContext","exitOnCtrlC","renderOptions","getFpsMetrics","stats","lastFlickerTime","baseOptions","stdin","fpsTracker","frameTimingLogPath","CLAUDE_CODE_FRAME_TIMING_LOG","getMetrics","onFrame","event","record","durationMs","observe","phases","line","JSON","stringify","total","rss","memoryUsage","cpu","cpuUsage","flicker","flickers","reason","now","Date","desiredHeight","actualHeight","availableHeight","Record"],"sources":["interactiveHelpers.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport { appendFileSync } from 'fs'\nimport React from 'react'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport {\n  gracefulShutdown,\n  gracefulShutdownSync,\n} from 'src/utils/gracefulShutdown.js'\nimport {\n  type ChannelEntry,\n  getAllowedChannels,\n  setAllowedChannels,\n  setHasDevChannels,\n  setSessionTrustAccepted,\n  setStatsStore,\n} from './bootstrap/state.js'\nimport type { Command } from './commands.js'\nimport { createStatsStore, type StatsStore } from './context/stats.js'\nimport { getSystemContext } from './context.js'\nimport { initializeTelemetryAfterTrust } from './entrypoints/init.js'\nimport { isSynchronizedOutputSupported } from './ink/terminal.js'\nimport type { RenderOptions, Root, TextProps } from './ink.js'\nimport { KeybindingSetup } from './keybindings/KeybindingProviderSetup.js'\nimport { startDeferredPrefetches } from './main.js'\nimport {\n  checkGate_CACHED_OR_BLOCKING,\n  initializeGrowthBook,\n  resetGrowthBook,\n} from './services/analytics/growthbook.js'\nimport { isQualifiedForGrove } from './services/api/grove.js'\nimport { handleMcpjsonServerApprovals } from './services/mcpServerApproval.js'\nimport { AppStateProvider } from './state/AppState.js'\nimport { onChangeAppState } from './state/onChangeAppState.js'\nimport { normalizeApiKeyForConfig } from './utils/authPortable.js'\nimport {\n  getExternalClaudeMdIncludes,\n  getMemoryFiles,\n  shouldShowClaudeMdExternalIncludesWarning,\n} from './utils/claudemd.js'\nimport {\n  checkHasTrustDialogAccepted,\n  getCustomApiKeyStatus,\n  getGlobalConfig,\n  saveGlobalConfig,\n} from './utils/config.js'\nimport { updateDeepLinkTerminalPreference } from './utils/deepLink/terminalPreference.js'\nimport { isEnvTruthy, isRunningOnHomespace } from './utils/envUtils.js'\nimport { type FpsMetrics, FpsTracker } from './utils/fpsTracker.js'\nimport { updateGithubRepoPathMapping } from './utils/githubRepoPathMapping.js'\nimport { applyConfigEnvironmentVariables } from './utils/managedEnv.js'\nimport type { PermissionMode } from './utils/permissions/PermissionMode.js'\nimport { getBaseRenderOptions } from './utils/renderOptions.js'\nimport { getSettingsWithAllErrors } from './utils/settings/allErrors.js'\nimport {\n  hasAutoModeOptIn,\n  hasSkipDangerousModePermissionPrompt,\n} from './utils/settings/settings.js'\n\nexport function completeOnboarding(): void {\n  saveGlobalConfig(current => ({\n    ...current,\n    hasCompletedOnboarding: true,\n    lastOnboardingVersion: MACRO.VERSION,\n  }))\n}\nexport function showDialog<T = void>(\n  root: Root,\n  renderer: (done: (result: T) => void) => React.ReactNode,\n): Promise<T> {\n  return new Promise<T>(resolve => {\n    const done = (result: T): void => void resolve(result)\n    root.render(renderer(done))\n  })\n}\n\n/**\n * Render an error message through Ink, then unmount and exit.\n * Use this for fatal errors after the Ink root has been created —\n * console.error is swallowed by Ink's patchConsole, so we render\n * through the React tree instead.\n */\nexport async function exitWithError(\n  root: Root,\n  message: string,\n  beforeExit?: () => Promise<void>,\n): Promise<never> {\n  return exitWithMessage(root, message, { color: 'error', beforeExit })\n}\n\n/**\n * Render a message through Ink, then unmount and exit.\n * Use this for messages after the Ink root has been created —\n * console output is swallowed by Ink's patchConsole, so we render\n * through the React tree instead.\n */\nexport async function exitWithMessage(\n  root: Root,\n  message: string,\n  options?: {\n    color?: TextProps['color']\n    exitCode?: number\n    beforeExit?: () => Promise<void>\n  },\n): Promise<never> {\n  const { Text } = await import('./ink.js')\n  const color = options?.color\n  const exitCode = options?.exitCode ?? 1\n  root.render(\n    color ? <Text color={color}>{message}</Text> : <Text>{message}</Text>,\n  )\n  root.unmount()\n  await options?.beforeExit?.()\n  // eslint-disable-next-line custom-rules/no-process-exit -- exit after Ink unmount\n  process.exit(exitCode)\n}\n\n/**\n * Show a setup dialog wrapped in AppStateProvider + KeybindingSetup.\n * Reduces boilerplate in showSetupScreens() where every dialog needs these wrappers.\n */\nexport function showSetupDialog<T = void>(\n  root: Root,\n  renderer: (done: (result: T) => void) => React.ReactNode,\n  options?: { onChangeAppState?: typeof onChangeAppState },\n): Promise<T> {\n  return showDialog<T>(root, done => (\n    <AppStateProvider onChangeAppState={options?.onChangeAppState}>\n      <KeybindingSetup>{renderer(done)}</KeybindingSetup>\n    </AppStateProvider>\n  ))\n}\n\n/**\n * Render the main UI into the root and wait for it to exit.\n * Handles the common epilogue: start deferred prefetches, wait for exit, graceful shutdown.\n */\nexport async function renderAndRun(\n  root: Root,\n  element: React.ReactNode,\n): Promise<void> {\n  root.render(element)\n  startDeferredPrefetches()\n  await root.waitUntilExit()\n  await gracefulShutdown(0)\n}\n\nexport async function showSetupScreens(\n  root: Root,\n  permissionMode: PermissionMode,\n  allowDangerouslySkipPermissions: boolean,\n  commands?: Command[],\n  claudeInChrome?: boolean,\n  devChannels?: ChannelEntry[],\n): Promise<boolean> {\n  if (\n    \"production\" === 'test' ||\n    isEnvTruthy(false) ||\n    process.env.IS_DEMO // Skip onboarding in demo mode\n  ) {\n    return false\n  }\n\n  const config = getGlobalConfig()\n  let onboardingShown = false\n  if (\n    !config.theme ||\n    !config.hasCompletedOnboarding // always show onboarding at least once\n  ) {\n    onboardingShown = true\n    const { Onboarding } = await import('./components/Onboarding.js')\n    await showSetupDialog(\n      root,\n      done => (\n        <Onboarding\n          onDone={() => {\n            completeOnboarding()\n            void done()\n          }}\n        />\n      ),\n      { onChangeAppState },\n    )\n  }\n\n  // Always show the trust dialog in interactive sessions, regardless of permission mode.\n  // The trust dialog is the workspace trust boundary — it warns about untrusted repos\n  // and checks CLAUDE.md external includes. bypassPermissions mode\n  // only affects tool execution permissions, not workspace trust.\n  // Note: non-interactive sessions (CI/CD with -p) never reach showSetupScreens at all.\n  // Skip permission checks in claubbit\n  if (!isEnvTruthy(process.env.CLAUBBIT)) {\n    // Fast-path: skip TrustDialog import+render when CWD is already trusted.\n    // If it returns true, the TrustDialog would auto-resolve regardless of\n    // security features, so we can skip the dynamic import and render cycle.\n    if (!checkHasTrustDialogAccepted()) {\n      const { TrustDialog } = await import(\n        './components/TrustDialog/TrustDialog.js'\n      )\n      await showSetupDialog(root, done => (\n        <TrustDialog commands={commands} onDone={done} />\n      ))\n    }\n\n    // Signal that trust has been verified for this session.\n    // GrowthBook checks this to decide whether to include auth headers.\n    setSessionTrustAccepted(true)\n\n    // Reset and reinitialize GrowthBook after trust is established.\n    // Defense for login/logout: clears any prior client so the next init\n    // picks up fresh auth headers.\n    resetGrowthBook()\n    void initializeGrowthBook()\n\n    // Now that trust is established, prefetch system context if it wasn't already\n    void getSystemContext()\n\n    // If settings are valid, check for any mcp.json servers that need approval\n    const { errors: allErrors } = getSettingsWithAllErrors()\n    if (allErrors.length === 0) {\n      await handleMcpjsonServerApprovals(root)\n    }\n\n    // Check for claude.md includes that need approval\n    if (await shouldShowClaudeMdExternalIncludesWarning()) {\n      const externalIncludes = getExternalClaudeMdIncludes(\n        await getMemoryFiles(true),\n      )\n      const { ClaudeMdExternalIncludesDialog } = await import(\n        './components/ClaudeMdExternalIncludesDialog.js'\n      )\n      await showSetupDialog(root, done => (\n        <ClaudeMdExternalIncludesDialog\n          onDone={done}\n          isStandaloneDialog\n          externalIncludes={externalIncludes}\n        />\n      ))\n    }\n  }\n\n  // Track current repo path for teleport directory switching (fire-and-forget)\n  // This must happen AFTER trust to prevent untrusted directories from poisoning the mapping\n  void updateGithubRepoPathMapping()\n  if (feature('LODESTONE')) {\n    updateDeepLinkTerminalPreference()\n  }\n\n  // Apply full environment variables after trust dialog is accepted OR in bypass mode\n  // In bypass mode (CI/CD, automation), we trust the environment so apply all variables\n  // In normal mode, this happens after the trust dialog is accepted\n  // This includes potentially dangerous environment variables from untrusted sources\n  applyConfigEnvironmentVariables()\n\n  // Initialize telemetry after env vars are applied so OTEL endpoint env vars and\n  // otelHeadersHelper (which requires trust to execute) are available.\n  // Defer to next tick so the OTel dynamic import resolves after first render\n  // instead of during the pre-render microtask queue.\n  setImmediate(() => initializeTelemetryAfterTrust())\n\n  if (await isQualifiedForGrove()) {\n    const { GroveDialog } = await import('src/components/grove/Grove.js')\n    const decision = await showSetupDialog<string>(root, done => (\n      <GroveDialog\n        showIfAlreadyViewed={false}\n        location={onboardingShown ? 'onboarding' : 'policy_update_modal'}\n        onDone={done}\n      />\n    ))\n    if (decision === 'escape') {\n      logEvent('tengu_grove_policy_exited', {})\n      gracefulShutdownSync(0)\n      return false\n    }\n  }\n\n  // Check for custom API key\n  // On homespace, ANTHROPIC_API_KEY is preserved in process.env for child\n  // processes but ignored by Claude Code itself (see auth.ts).\n  if (process.env.ANTHROPIC_API_KEY && !isRunningOnHomespace()) {\n    const customApiKeyTruncated = normalizeApiKeyForConfig(\n      process.env.ANTHROPIC_API_KEY,\n    )\n    const keyStatus = getCustomApiKeyStatus(customApiKeyTruncated)\n    if (keyStatus === 'new') {\n      const { ApproveApiKey } = await import('./components/ApproveApiKey.js')\n      await showSetupDialog<boolean>(\n        root,\n        done => (\n          <ApproveApiKey\n            customApiKeyTruncated={customApiKeyTruncated}\n            onDone={done}\n          />\n        ),\n        { onChangeAppState },\n      )\n    }\n  }\n\n  if (\n    (permissionMode === 'bypassPermissions' ||\n      allowDangerouslySkipPermissions) &&\n    !hasSkipDangerousModePermissionPrompt()\n  ) {\n    const { BypassPermissionsModeDialog } = await import(\n      './components/BypassPermissionsModeDialog.js'\n    )\n    await showSetupDialog(root, done => (\n      <BypassPermissionsModeDialog onAccept={done} />\n    ))\n  }\n\n  if (feature('TRANSCRIPT_CLASSIFIER')) {\n    // Only show the opt-in dialog if auto mode actually resolved — if the\n    // gate denied it (org not allowlisted, settings disabled), showing\n    // consent for an unavailable feature is pointless. The\n    // verifyAutoModeGateAccess notification will explain why instead.\n    if (permissionMode === 'auto' && !hasAutoModeOptIn()) {\n      const { AutoModeOptInDialog } = await import(\n        './components/AutoModeOptInDialog.js'\n      )\n      await showSetupDialog(root, done => (\n        <AutoModeOptInDialog\n          onAccept={done}\n          onDecline={() => gracefulShutdownSync(1)}\n          declineExits\n        />\n      ))\n    }\n  }\n\n  // --dangerously-load-development-channels confirmation. On accept, append\n  // dev channels to any --channels list already set in main.tsx. Org policy\n  // is NOT bypassed — gateChannelServer() still runs; this flag only exists\n  // to sidestep the --channels approved-server allowlist.\n  if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {\n    // gateChannelServer and ChannelsNotice read tengu_harbor after this\n    // function returns. A cold disk cache (fresh install, or first run after\n    // the flag was added server-side) defaults to false and silently drops\n    // channel notifications for the whole session — gh#37026.\n    // checkGate_CACHED_OR_BLOCKING returns immediately if disk already says\n    // true; only blocks on a cold/stale-false cache (awaits the same memoized\n    // initializeGrowthBook promise fired earlier). Also warms the\n    // isChannelsEnabled() check in the dev-channels dialog below.\n    if (getAllowedChannels().length > 0 || (devChannels?.length ?? 0) > 0) {\n      await checkGate_CACHED_OR_BLOCKING('tengu_harbor')\n    }\n\n    if (devChannels && devChannels.length > 0) {\n      const [{ isChannelsEnabled }, { getClaudeAIOAuthTokens }] =\n        await Promise.all([\n          import('./services/mcp/channelAllowlist.js'),\n          import('./utils/auth.js'),\n        ])\n      // Skip the dialog when channels are blocked (tengu_harbor off or no\n      // OAuth) — accepting then immediately seeing \"not available\" in\n      // ChannelsNotice is worse than no dialog. Append entries anyway so\n      // ChannelsNotice renders the blocked branch with the dev entries\n      // named. dev:true here is for the flag label in ChannelsNotice\n      // (hasNonDev check); the allowlist bypass it also grants is moot\n      // since the gate blocks upstream.\n      if (!isChannelsEnabled() || !getClaudeAIOAuthTokens()?.accessToken) {\n        setAllowedChannels([\n          ...getAllowedChannels(),\n          ...devChannels.map(c => ({ ...c, dev: true })),\n        ])\n        setHasDevChannels(true)\n      } else {\n        const { DevChannelsDialog } = await import(\n          './components/DevChannelsDialog.js'\n        )\n        await showSetupDialog(root, done => (\n          <DevChannelsDialog\n            channels={devChannels}\n            onAccept={() => {\n              // Mark dev entries per-entry so the allowlist bypass doesn't leak\n              // to --channels entries when both flags are passed.\n              setAllowedChannels([\n                ...getAllowedChannels(),\n                ...devChannels.map(c => ({ ...c, dev: true })),\n              ])\n              setHasDevChannels(true)\n              void done()\n            }}\n          />\n        ))\n      }\n    }\n  }\n\n  // Show Chrome onboarding for first-time Claude in Chrome users\n  if (\n    claudeInChrome &&\n    !getGlobalConfig().hasCompletedClaudeInChromeOnboarding\n  ) {\n    const { ClaudeInChromeOnboarding } = await import(\n      './components/ClaudeInChromeOnboarding.js'\n    )\n    await showSetupDialog(root, done => (\n      <ClaudeInChromeOnboarding onDone={done} />\n    ))\n  }\n\n  return onboardingShown\n}\n\nexport function getRenderContext(exitOnCtrlC: boolean): {\n  renderOptions: RenderOptions\n  getFpsMetrics: () => FpsMetrics | undefined\n  stats: StatsStore\n} {\n  let lastFlickerTime = 0\n  const baseOptions = getBaseRenderOptions(exitOnCtrlC)\n\n  // Log analytics event when stdin override is active\n  if (baseOptions.stdin) {\n    logEvent('tengu_stdin_interactive', {})\n  }\n\n  const fpsTracker = new FpsTracker()\n  const stats = createStatsStore()\n  setStatsStore(stats)\n\n  // Bench mode: when set, append per-frame phase timings as JSONL for\n  // offline analysis by bench/repl-scroll.ts. Captures the full TUI\n  // render pipeline (yoga → screen buffer → diff → optimize → stdout)\n  // so perf work on any phase can be validated against real user flows.\n  const frameTimingLogPath = process.env.CLAUDE_CODE_FRAME_TIMING_LOG\n  return {\n    getFpsMetrics: () => fpsTracker.getMetrics(),\n    stats,\n    renderOptions: {\n      ...baseOptions,\n      onFrame: event => {\n        fpsTracker.record(event.durationMs)\n        stats.observe('frame_duration_ms', event.durationMs)\n        if (frameTimingLogPath && event.phases) {\n          // Bench-only env-var-gated path: sync write so no frames dropped\n          // on abrupt exit. ~100 bytes at ≤60fps is negligible. rss/cpu are\n          // single syscalls; cpu is cumulative — bench side computes delta.\n          const line =\n            // eslint-disable-next-line custom-rules/no-direct-json-operations -- tiny object, hot bench path\n            JSON.stringify({\n              total: event.durationMs,\n              ...event.phases,\n              rss: process.memoryUsage.rss(),\n              cpu: process.cpuUsage(),\n            }) + '\\n'\n          // eslint-disable-next-line custom-rules/no-sync-fs -- bench-only, sync so no frames dropped on exit\n          appendFileSync(frameTimingLogPath, line)\n        }\n        // Skip flicker reporting for terminals with synchronized output —\n        // DEC 2026 buffers between BSU/ESU so clear+redraw is atomic.\n        if (isSynchronizedOutputSupported()) {\n          return\n        }\n        for (const flicker of event.flickers) {\n          if (flicker.reason === 'resize') {\n            continue\n          }\n          const now = Date.now()\n          if (now - lastFlickerTime < 1000) {\n            logEvent('tengu_flicker', {\n              desiredHeight: flicker.desiredHeight,\n              actualHeight: flicker.availableHeight,\n              reason: flicker.reason,\n            } as unknown as Record<string, boolean | number | undefined>)\n          }\n          lastFlickerTime = now\n        }\n      },\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/macro.ts

@@ -1,7 +1,7 @@
 // Build-time macros - stubbed for development
 
 export const MACRO = {
-  VERSION: '3.0.5',
+  VERSION: '3.1.0',
   VERSION_CHANGELOG: '',
   NATIVE_PACKAGE_URL: '@anthropic-ai/claude-code-native',
   CLI_BIN_PATH: './cli.tsx',

package/memdir/findRelevantMemories.ts

@@ -0,0 +1,141 @@
+import { feature } from 'bun:bundle'
+import { logForDebugging } from '../utils/debug.js'
+import { errorMessage } from '../utils/errors.js'
+import { getDefaultSonnetModel } from '../utils/model/model.js'
+import { sideQuery } from '../utils/sideQuery.js'
+import { jsonParse } from '../utils/slowOperations.js'
+import {
+  formatMemoryManifest,
+  type MemoryHeader,
+  scanMemoryFiles,
+} from './memoryScan.js'
+
+export type RelevantMemory = {
+  path: string
+  mtimeMs: number
+}
+
+const SELECT_MEMORIES_SYSTEM_PROMPT = `You are selecting memories that will be useful to Claude Code as it processes a user's query. You will be given the user's query and a list of available memory files with their filenames and descriptions.
+
+Return a list of filenames for the memories that will clearly be useful to Claude Code as it processes the user's query (up to 5). Only include memories that you are certain will be helpful based on their name and description.
+- If you are unsure if a memory will be useful in processing the user's query, then do not include it in your list. Be selective and discerning.
+- If there are no memories in the list that would clearly be useful, feel free to return an empty list.
+- If a list of recently-used tools is provided, do not select memories that are usage reference or API documentation for those tools (Claude Code is already exercising them). DO still select memories containing warnings, gotchas, or known issues about those tools — active use is exactly when those matter.
+`
+
+/**
+ * Find memory files relevant to a query by scanning memory file headers
+ * and asking Sonnet to select the most relevant ones.
+ *
+ * Returns absolute file paths + mtime of the most relevant memories
+ * (up to 5). Excludes MEMORY.md (already loaded in system prompt).
+ * mtime is threaded through so callers can surface freshness to the
+ * main model without a second stat.
+ *
+ * `alreadySurfaced` filters paths shown in prior turns before the
+ * Sonnet call, so the selector spends its 5-slot budget on fresh
+ * candidates instead of re-picking files the caller will discard.
+ */
+export async function findRelevantMemories(
+  query: string,
+  memoryDir: string,
+  signal: AbortSignal,
+  recentTools: readonly string[] = [],
+  alreadySurfaced: ReadonlySet<string> = new Set(),
+): Promise<RelevantMemory[]> {
+  const memories = (await scanMemoryFiles(memoryDir, signal)).filter(
+    m => !alreadySurfaced.has(m.filePath),
+  )
+  if (memories.length === 0) {
+    return []
+  }
+
+  const selectedFilenames = await selectRelevantMemories(
+    query,
+    memories,
+    signal,
+    recentTools,
+  )
+  const byFilename = new Map(memories.map(m => [m.filename, m]))
+  const selected = selectedFilenames
+    .map(filename => byFilename.get(filename))
+    .filter((m): m is MemoryHeader => m !== undefined)
+
+  // Fires even on empty selection: selection-rate needs the denominator,
+  // and -1 ages distinguish "ran, picked nothing" from "never ran".
+  if (feature('MEMORY_SHAPE_TELEMETRY')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { logMemoryRecallShape } =
+      require('./memoryShapeTelemetry.js') as typeof import('./memoryShapeTelemetry.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    logMemoryRecallShape(memories, selected)
+  }
+
+  return selected.map(m => ({ path: m.filePath, mtimeMs: m.mtimeMs }))
+}
+
+async function selectRelevantMemories(
+  query: string,
+  memories: MemoryHeader[],
+  signal: AbortSignal,
+  recentTools: readonly string[],
+): Promise<string[]> {
+  const validFilenames = new Set(memories.map(m => m.filename))
+
+  const manifest = formatMemoryManifest(memories)
+
+  // When Claude Code is actively using a tool (e.g. mcp__X__spawn),
+  // surfacing that tool's reference docs is noise — the conversation
+  // already contains working usage.  The selector otherwise matches
+  // on keyword overlap ("spawn" in query + "spawn" in a memory
+  // description → false positive).
+  const toolsSection =
+    recentTools.length > 0
+      ? `\n\nRecently used tools: ${recentTools.join(', ')}`
+      : ''
+
+  try {
+    const result = await sideQuery({
+      model: getDefaultSonnetModel(),
+      system: SELECT_MEMORIES_SYSTEM_PROMPT,
+      skipSystemPromptPrefix: true,
+      messages: [
+        {
+          role: 'user',
+          content: `Query: ${query}\n\nAvailable memories:\n${manifest}${toolsSection}`,
+        },
+      ],
+      max_tokens: 256,
+      output_format: {
+        type: 'json_schema',
+        schema: {
+          type: 'object',
+          properties: {
+            selected_memories: { type: 'array', items: { type: 'string' } },
+          },
+          required: ['selected_memories'],
+          additionalProperties: false,
+        },
+      },
+      signal,
+      querySource: 'memdir_relevance',
+    })
+
+    const textBlock = result.content.find(block => block.type === 'text')
+    if (!textBlock || textBlock.type !== 'text') {
+      return []
+    }
+
+    const parsed: { selected_memories: string[] } = jsonParse(textBlock.text)
+    return parsed.selected_memories.filter(f => validFilenames.has(f))
+  } catch (e) {
+    if (signal.aborted) {
+      return []
+    }
+    logForDebugging(
+      `[memdir] selectRelevantMemories failed: ${errorMessage(e)}`,
+      { level: 'warn' },
+    )
+    return []
+  }
+}