Add files using upload-large-folder tool

src/cli/handlers/auth.ts

@@ -0,0 +1,330 @@
+/* eslint-disable custom-rules/no-process-exit -- CLI subcommand handler intentionally exits */
+
+import {
+  clearAuthRelatedCaches,
+  performLogout,
+} from '../../commands/logout/logout.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import { getSSLErrorHint } from '../../services/api/errorUtils.js'
+import { fetchAndStoreClaudeCodeFirstTokenDate } from '../../services/api/firstTokenDate.js'
+import {
+  createAndStoreApiKey,
+  fetchAndStoreUserRoles,
+  refreshOAuthToken,
+  shouldUseClaudeAIAuth,
+  storeOAuthAccountInfo,
+} from '../../services/oauth/client.js'
+import { getOauthProfileFromOauthToken } from '../../services/oauth/getOauthProfile.js'
+import { OAuthService } from '../../services/oauth/index.js'
+import type { OAuthTokens } from '../../services/oauth/types.js'
+import {
+  clearOAuthTokenCache,
+  getAnthropicApiKeyWithSource,
+  getAuthTokenSource,
+  getOauthAccountInfo,
+  getSubscriptionType,
+  isUsing3PServices,
+  saveOAuthTokensIfNeeded,
+  validateForceLoginOrg,
+} from '../../utils/auth.js'
+import { saveGlobalConfig } from '../../utils/config.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { isRunningOnHomespace } from '../../utils/envUtils.js'
+import { errorMessage } from '../../utils/errors.js'
+import { logError } from '../../utils/log.js'
+import { getAPIProvider } from '../../utils/model/providers.js'
+import { getInitialSettings } from '../../utils/settings/settings.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import {
+  buildAccountProperties,
+  buildAPIProviderProperties,
+} from '../../utils/status.js'
+
+/**
+ * Shared post-token-acquisition logic. Saves tokens, fetches profile/roles,
+ * and sets up the local auth state.
+ */
+export async function installOAuthTokens(tokens: OAuthTokens): Promise<void> {
+  // Clear old state before saving new credentials
+  await performLogout({ clearOnboarding: false })
+
+  // Reuse pre-fetched profile if available, otherwise fetch fresh
+  const profile =
+    tokens.profile ?? (await getOauthProfileFromOauthToken(tokens.accessToken))
+  if (profile) {
+    storeOAuthAccountInfo({
+      accountUuid: profile.account.uuid,
+      emailAddress: profile.account.email,
+      organizationUuid: profile.organization.uuid,
+      displayName: profile.account.display_name || undefined,
+      hasExtraUsageEnabled:
+        profile.organization.has_extra_usage_enabled ?? undefined,
+      billingType: profile.organization.billing_type ?? undefined,
+      subscriptionCreatedAt:
+        profile.organization.subscription_created_at ?? undefined,
+      accountCreatedAt: profile.account.created_at,
+    })
+  } else if (tokens.tokenAccount) {
+    // Fallback to token exchange account data when profile endpoint fails
+    storeOAuthAccountInfo({
+      accountUuid: tokens.tokenAccount.uuid,
+      emailAddress: tokens.tokenAccount.emailAddress,
+      organizationUuid: tokens.tokenAccount.organizationUuid,
+    })
+  }
+
+  const storageResult = saveOAuthTokensIfNeeded(tokens)
+  clearOAuthTokenCache()
+
+  if (storageResult.warning) {
+    logEvent('tengu_oauth_storage_warning', {
+      warning:
+        storageResult.warning as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+  }
+
+  // Roles and first-token-date may fail for limited-scope tokens (e.g.
+  // inference-only from setup-token). They're not required for core auth.
+  await fetchAndStoreUserRoles(tokens.accessToken).catch(err =>
+    logForDebugging(String(err), { level: 'error' }),
+  )
+
+  if (shouldUseClaudeAIAuth(tokens.scopes)) {
+    await fetchAndStoreClaudeCodeFirstTokenDate().catch(err =>
+      logForDebugging(String(err), { level: 'error' }),
+    )
+  } else {
+    // API key creation is critical for Console users — let it throw.
+    const apiKey = await createAndStoreApiKey(tokens.accessToken)
+    if (!apiKey) {
+      throw new Error(
+        'Unable to create API key. The server accepted the request but did not return a key.',
+      )
+    }
+  }
+
+  await clearAuthRelatedCaches()
+}
+
+export async function authLogin({
+  email,
+  sso,
+  console: useConsole,
+  claudeai,
+}: {
+  email?: string
+  sso?: boolean
+  console?: boolean
+  claudeai?: boolean
+}): Promise<void> {
+  if (useConsole && claudeai) {
+    process.stderr.write(
+      'Error: --console and --claudeai cannot be used together.\n',
+    )
+    process.exit(1)
+  }
+
+  const settings = getInitialSettings()
+  // forceLoginMethod is a hard constraint (enterprise setting) — matches ConsoleOAuthFlow behavior.
+  // Without it, --console selects Console; --claudeai (or no flag) selects claude.ai.
+  const loginWithClaudeAi = settings.forceLoginMethod
+    ? settings.forceLoginMethod === 'claudeai'
+    : !useConsole
+  const orgUUID = settings.forceLoginOrgUUID
+
+  // Fast path: if a refresh token is provided via env var, skip the browser
+  // OAuth flow and exchange it directly for tokens.
+  const envRefreshToken = process.env.CLAUDE_CODE_OAUTH_REFRESH_TOKEN
+  if (envRefreshToken) {
+    const envScopes = process.env.CLAUDE_CODE_OAUTH_SCOPES
+    if (!envScopes) {
+      process.stderr.write(
+        'CLAUDE_CODE_OAUTH_SCOPES is required when using CLAUDE_CODE_OAUTH_REFRESH_TOKEN.\n' +
+          'Set it to the space-separated scopes the refresh token was issued with\n' +
+          '(e.g. "user:inference" or "user:profile user:inference user:sessions:claude_code user:mcp_servers").\n',
+      )
+      process.exit(1)
+    }
+
+    const scopes = envScopes.split(/\s+/).filter(Boolean)
+
+    try {
+      logEvent('tengu_login_from_refresh_token', {})
+
+      const tokens = await refreshOAuthToken(envRefreshToken, { scopes })
+      await installOAuthTokens(tokens)
+
+      const orgResult = await validateForceLoginOrg()
+      if (!orgResult.valid) {
+        process.stderr.write(orgResult.message + '\n')
+        process.exit(1)
+      }
+
+      // Mark onboarding complete — interactive paths handle this via
+      // the Onboarding component, but the env var path skips it.
+      saveGlobalConfig(current => {
+        if (current.hasCompletedOnboarding) return current
+        return { ...current, hasCompletedOnboarding: true }
+      })
+
+      logEvent('tengu_oauth_success', {
+        loginWithClaudeAi: shouldUseClaudeAIAuth(tokens.scopes),
+      })
+      process.stdout.write('Login successful.\n')
+      process.exit(0)
+    } catch (err) {
+      logError(err)
+      const sslHint = getSSLErrorHint(err)
+      process.stderr.write(
+        `Login failed: ${errorMessage(err)}\n${sslHint ? sslHint + '\n' : ''}`,
+      )
+      process.exit(1)
+    }
+  }
+
+  const resolvedLoginMethod = sso ? 'sso' : undefined
+
+  const oauthService = new OAuthService()
+
+  try {
+    logEvent('tengu_oauth_flow_start', { loginWithClaudeAi })
+
+    const result = await oauthService.startOAuthFlow(
+      async url => {
+        process.stdout.write('Opening browser to sign in…\n')
+        process.stdout.write(`If the browser didn't open, visit: ${url}\n`)
+      },
+      {
+        loginWithClaudeAi,
+        loginHint: email,
+        loginMethod: resolvedLoginMethod,
+        orgUUID,
+      },
+    )
+
+    await installOAuthTokens(result)
+
+    const orgResult = await validateForceLoginOrg()
+    if (!orgResult.valid) {
+      process.stderr.write(orgResult.message + '\n')
+      process.exit(1)
+    }
+
+    logEvent('tengu_oauth_success', { loginWithClaudeAi })
+
+    process.stdout.write('Login successful.\n')
+    process.exit(0)
+  } catch (err) {
+    logError(err)
+    const sslHint = getSSLErrorHint(err)
+    process.stderr.write(
+      `Login failed: ${errorMessage(err)}\n${sslHint ? sslHint + '\n' : ''}`,
+    )
+    process.exit(1)
+  } finally {
+    oauthService.cleanup()
+  }
+}
+
+export async function authStatus(opts: {
+  json?: boolean
+  text?: boolean
+}): Promise<void> {
+  const { source: authTokenSource, hasToken } = getAuthTokenSource()
+  const { source: apiKeySource } = getAnthropicApiKeyWithSource()
+  const hasApiKeyEnvVar =
+    !!process.env.ANTHROPIC_API_KEY && !isRunningOnHomespace()
+  const oauthAccount = getOauthAccountInfo()
+  const subscriptionType = getSubscriptionType()
+  const using3P = isUsing3PServices()
+  const loggedIn =
+    hasToken || apiKeySource !== 'none' || hasApiKeyEnvVar || using3P
+
+  // Determine auth method
+  let authMethod: string = 'none'
+  if (using3P) {
+    authMethod = 'third_party'
+  } else if (authTokenSource === 'claude.ai') {
+    authMethod = 'claude.ai'
+  } else if (authTokenSource === 'apiKeyHelper') {
+    authMethod = 'api_key_helper'
+  } else if (authTokenSource !== 'none') {
+    authMethod = 'oauth_token'
+  } else if (apiKeySource === 'ANTHROPIC_API_KEY' || hasApiKeyEnvVar) {
+    authMethod = 'api_key'
+  } else if (apiKeySource === '/login managed key') {
+    authMethod = 'claude.ai'
+  }
+
+  if (opts.text) {
+    const properties = [
+      ...buildAccountProperties(),
+      ...buildAPIProviderProperties(),
+    ]
+    let hasAuthProperty = false
+    for (const prop of properties) {
+      const value =
+        typeof prop.value === 'string'
+          ? prop.value
+          : Array.isArray(prop.value)
+            ? prop.value.join(', ')
+            : null
+      if (value === null || value === 'none') {
+        continue
+      }
+      hasAuthProperty = true
+      if (prop.label) {
+        process.stdout.write(`${prop.label}: ${value}\n`)
+      } else {
+        process.stdout.write(`${value}\n`)
+      }
+    }
+    if (!hasAuthProperty && hasApiKeyEnvVar) {
+      process.stdout.write('API key: ANTHROPIC_API_KEY\n')
+    }
+    if (!loggedIn) {
+      process.stdout.write(
+        'Not logged in. Run claude auth login to authenticate.\n',
+      )
+    }
+  } else {
+    const apiProvider = getAPIProvider()
+    const resolvedApiKeySource =
+      apiKeySource !== 'none'
+        ? apiKeySource
+        : hasApiKeyEnvVar
+          ? 'ANTHROPIC_API_KEY'
+          : null
+    const output: Record<string, string | boolean | null> = {
+      loggedIn,
+      authMethod,
+      apiProvider,
+    }
+    if (resolvedApiKeySource) {
+      output.apiKeySource = resolvedApiKeySource
+    }
+    if (authMethod === 'claude.ai') {
+      output.email = oauthAccount?.emailAddress ?? null
+      output.orgId = oauthAccount?.organizationUuid ?? null
+      output.orgName = oauthAccount?.organizationName ?? null
+      output.subscriptionType = subscriptionType ?? null
+    }
+
+    process.stdout.write(jsonStringify(output, null, 2) + '\n')
+  }
+  process.exit(loggedIn ? 0 : 1)
+}
+
+export async function authLogout(): Promise<void> {
+  try {
+    await performLogout({ clearOnboarding: false })
+  } catch {
+    process.stderr.write('Failed to log out.\n')
+    process.exit(1)
+  }
+  process.stdout.write('Successfully logged out from your Anthropic account.\n')
+  process.exit(0)
+}

src/cli/handlers/mcp.tsx

@@ -0,0 +1,362 @@
+/**
+ * MCP subcommand handlers — extracted from main.tsx for lazy loading.
+ * These are dynamically imported only when the corresponding `claude mcp *` command runs.
+ */
+
+import { stat } from 'fs/promises';
+import pMap from 'p-map';
+import { cwd } from 'process';
+import React from 'react';
+import { MCPServerDesktopImportDialog } from '../../components/MCPServerDesktopImportDialog.js';
+import { render } from '../../ink.js';
+import { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
+import { clearMcpClientConfig, clearServerTokensFromLocalStorage, getMcpClientConfig, readClientSecret, saveMcpClientSecret } from '../../services/mcp/auth.js';
+import { connectToServer, getMcpServerConnectionBatchSize } from '../../services/mcp/client.js';
+import { addMcpConfig, getAllMcpConfigs, getMcpConfigByName, getMcpConfigsByScope, removeMcpConfig } from '../../services/mcp/config.js';
+import type { ConfigScope, ScopedMcpServerConfig } from '../../services/mcp/types.js';
+import { describeMcpConfigFilePath, ensureConfigScope, getScopeLabel } from '../../services/mcp/utils.js';
+import { AppStateProvider } from '../../state/AppState.js';
+import { getCurrentProjectConfig, getGlobalConfig, saveCurrentProjectConfig } from '../../utils/config.js';
+import { isFsInaccessible } from '../../utils/errors.js';
+import { gracefulShutdown } from '../../utils/gracefulShutdown.js';
+import { safeParseJSON } from '../../utils/json.js';
+import { getPlatform } from '../../utils/platform.js';
+import { cliError, cliOk } from '../exit.js';
+async function checkMcpServerHealth(name: string, server: ScopedMcpServerConfig): Promise<string> {
+  try {
+    const result = await connectToServer(name, server);
+    if (result.type === 'connected') {
+      return '✓ Connected';
+    } else if (result.type === 'needs-auth') {
+      return '! Needs authentication';
+    } else {
+      return '✗ Failed to connect';
+    }
+  } catch (_error) {
+    return '✗ Connection error';
+  }
+}
+
+// mcp serve (lines 4512–4532)
+export async function mcpServeHandler({
+  debug,
+  verbose
+}: {
+  debug?: boolean;
+  verbose?: boolean;
+}): Promise<void> {
+  const providedCwd = cwd();
+  logEvent('tengu_mcp_start', {});
+  try {
+    await stat(providedCwd);
+  } catch (error) {
+    if (isFsInaccessible(error)) {
+      cliError(`Error: Directory ${providedCwd} does not exist`);
+    }
+    throw error;
+  }
+  try {
+    const {
+      setup
+    } = await import('../../setup.js');
+    await setup(providedCwd, 'default', false, false, undefined, false);
+    const {
+      startMCPServer
+    } = await import('../../entrypoints/mcp.js');
+    await startMCPServer(providedCwd, debug ?? false, verbose ?? false);
+  } catch (error) {
+    cliError(`Error: Failed to start MCP server: ${error}`);
+  }
+}
+
+// mcp remove (lines 4545–4635)
+export async function mcpRemoveHandler(name: string, options: {
+  scope?: string;
+}): Promise<void> {
+  // Look up config before removing so we can clean up secure storage
+  const serverBeforeRemoval = getMcpConfigByName(name);
+  const cleanupSecureStorage = () => {
+    if (serverBeforeRemoval && (serverBeforeRemoval.type === 'sse' || serverBeforeRemoval.type === 'http')) {
+      clearServerTokensFromLocalStorage(name, serverBeforeRemoval);
+      clearMcpClientConfig(name, serverBeforeRemoval);
+    }
+  };
+  try {
+    if (options.scope) {
+      const scope = ensureConfigScope(options.scope);
+      logEvent('tengu_mcp_delete', {
+        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        scope: scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      await removeMcpConfig(name, scope);
+      cleanupSecureStorage();
+      process.stdout.write(`Removed MCP server ${name} from ${scope} config\n`);
+      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`);
+    }
+
+    // If no scope specified, check where the server exists
+    const projectConfig = getCurrentProjectConfig();
+    const globalConfig = getGlobalConfig();
+
+    // Check if server exists in project scope (.mcp.json)
+    const {
+      servers: projectServers
+    } = getMcpConfigsByScope('project');
+    const mcpJsonExists = !!projectServers[name];
+
+    // Count how many scopes contain this server
+    const scopes: Array<Exclude<ConfigScope, 'dynamic'>> = [];
+    if (projectConfig.mcpServers?.[name]) scopes.push('local');
+    if (mcpJsonExists) scopes.push('project');
+    if (globalConfig.mcpServers?.[name]) scopes.push('user');
+    if (scopes.length === 0) {
+      cliError(`No MCP server found with name: "${name}"`);
+    } else if (scopes.length === 1) {
+      // Server exists in only one scope, remove it
+      const scope = scopes[0]!;
+      logEvent('tengu_mcp_delete', {
+        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        scope: scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      await removeMcpConfig(name, scope);
+      cleanupSecureStorage();
+      process.stdout.write(`Removed MCP server "${name}" from ${scope} config\n`);
+      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`);
+    } else {
+      // Server exists in multiple scopes
+      process.stderr.write(`MCP server "${name}" exists in multiple scopes:\n`);
+      scopes.forEach(scope => {
+        process.stderr.write(`  - ${getScopeLabel(scope)} (${describeMcpConfigFilePath(scope)})\n`);
+      });
+      process.stderr.write('\nTo remove from a specific scope, use:\n');
+      scopes.forEach(scope => {
+        process.stderr.write(`  claude mcp remove "${name}" -s ${scope}\n`);
+      });
+      cliError();
+    }
+  } catch (error) {
+    cliError((error as Error).message);
+  }
+}
+
+// mcp list (lines 4641–4688)
+export async function mcpListHandler(): Promise<void> {
+  logEvent('tengu_mcp_list', {});
+  const {
+    servers: configs
+  } = await getAllMcpConfigs();
+  if (Object.keys(configs).length === 0) {
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log('No MCP servers configured. Use `claude mcp add` to add a server.');
+  } else {
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log('Checking MCP server health...\n');
+
+    // Check servers concurrently
+    const entries = Object.entries(configs);
+    const results = await pMap(entries, async ([name, server]) => ({
+      name,
+      server,
+      status: await checkMcpServerHealth(name, server)
+    }), {
+      concurrency: getMcpServerConnectionBatchSize()
+    });
+    for (const {
+      name,
+      server,
+      status
+    } of results) {
+      // Intentionally excluding sse-ide servers here since they're internal
+      if (server.type === 'sse') {
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${name}: ${server.url} (SSE) - ${status}`);
+      } else if (server.type === 'http') {
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${name}: ${server.url} (HTTP) - ${status}`);
+      } else if (server.type === 'claudeai-proxy') {
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${name}: ${server.url} - ${status}`);
+      } else if (!server.type || server.type === 'stdio') {
+        const args = Array.isArray(server.args) ? server.args : [];
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${name}: ${server.command} ${args.join(' ')} - ${status}`);
+      }
+    }
+  }
+  // Use gracefulShutdown to properly clean up MCP server connections
+  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)
+  await gracefulShutdown(0);
+}
+
+// mcp get (lines 4694–4786)
+export async function mcpGetHandler(name: string): Promise<void> {
+  logEvent('tengu_mcp_get', {
+    name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+  });
+  const server = getMcpConfigByName(name);
+  if (!server) {
+    cliError(`No MCP server found with name: ${name}`);
+  }
+
+  // biome-ignore lint/suspicious/noConsole:: intentional console output
+  console.log(`${name}:`);
+  // biome-ignore lint/suspicious/noConsole:: intentional console output
+  console.log(`  Scope: ${getScopeLabel(server.scope)}`);
+
+  // Check server health
+  const status = await checkMcpServerHealth(name, server);
+  // biome-ignore lint/suspicious/noConsole:: intentional console output
+  console.log(`  Status: ${status}`);
+
+  // Intentionally excluding sse-ide servers here since they're internal
+  if (server.type === 'sse') {
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`  Type: sse`);
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`  URL: ${server.url}`);
+    if (server.headers) {
+      // biome-ignore lint/suspicious/noConsole:: intentional console output
+      console.log('  Headers:');
+      for (const [key, value] of Object.entries(server.headers)) {
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`    ${key}: ${value}`);
+      }
+    }
+    if (server.oauth?.clientId || server.oauth?.callbackPort) {
+      const parts: string[] = [];
+      if (server.oauth.clientId) {
+        parts.push('client_id configured');
+        const clientConfig = getMcpClientConfig(name, server);
+        if (clientConfig?.clientSecret) parts.push('client_secret configured');
+      }
+      if (server.oauth.callbackPort) parts.push(`callback_port ${server.oauth.callbackPort}`);
+      // biome-ignore lint/suspicious/noConsole:: intentional console output
+      console.log(`  OAuth: ${parts.join(', ')}`);
+    }
+  } else if (server.type === 'http') {
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`  Type: http`);
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`  URL: ${server.url}`);
+    if (server.headers) {
+      // biome-ignore lint/suspicious/noConsole:: intentional console output
+      console.log('  Headers:');
+      for (const [key, value] of Object.entries(server.headers)) {
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`    ${key}: ${value}`);
+      }
+    }
+    if (server.oauth?.clientId || server.oauth?.callbackPort) {
+      const parts: string[] = [];
+      if (server.oauth.clientId) {
+        parts.push('client_id configured');
+        const clientConfig = getMcpClientConfig(name, server);
+        if (clientConfig?.clientSecret) parts.push('client_secret configured');
+      }
+      if (server.oauth.callbackPort) parts.push(`callback_port ${server.oauth.callbackPort}`);
+      // biome-ignore lint/suspicious/noConsole:: intentional console output
+      console.log(`  OAuth: ${parts.join(', ')}`);
+    }
+  } else if (server.type === 'stdio') {
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`  Type: stdio`);
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`  Command: ${server.command}`);
+    const args = Array.isArray(server.args) ? server.args : [];
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.log(`  Args: ${args.join(' ')}`);
+    if (server.env) {
+      // biome-ignore lint/suspicious/noConsole:: intentional console output
+      console.log('  Environment:');
+      for (const [key, value] of Object.entries(server.env)) {
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`    ${key}=${value}`);
+      }
+    }
+  }
+  // biome-ignore lint/suspicious/noConsole:: intentional console output
+  console.log(`\nTo remove this server, run: claude mcp remove "${name}" -s ${server.scope}`);
+  // Use gracefulShutdown to properly clean up MCP server connections
+  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)
+  await gracefulShutdown(0);
+}
+
+// mcp add-json (lines 4801–4870)
+export async function mcpAddJsonHandler(name: string, json: string, options: {
+  scope?: string;
+  clientSecret?: true;
+}): Promise<void> {
+  try {
+    const scope = ensureConfigScope(options.scope);
+    const parsedJson = safeParseJSON(json);
+
+    // Read secret before writing config so cancellation doesn't leave partial state
+    const needsSecret = options.clientSecret && parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson && (parsedJson.type === 'sse' || parsedJson.type === 'http') && 'url' in parsedJson && typeof parsedJson.url === 'string' && 'oauth' in parsedJson && parsedJson.oauth && typeof parsedJson.oauth === 'object' && 'clientId' in parsedJson.oauth;
+    const clientSecret = needsSecret ? await readClientSecret() : undefined;
+    await addMcpConfig(name, parsedJson, scope);
+    const transportType = parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson ? String(parsedJson.type || 'stdio') : 'stdio';
+    if (clientSecret && parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson && (parsedJson.type === 'sse' || parsedJson.type === 'http') && 'url' in parsedJson && typeof parsedJson.url === 'string') {
+      saveMcpClientSecret(name, {
+        type: parsedJson.type,
+        url: parsedJson.url
+      }, clientSecret);
+    }
+    logEvent('tengu_mcp_add', {
+      scope: scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      source: 'json' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      type: transportType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    cliOk(`Added ${transportType} MCP server ${name} to ${scope} config`);
+  } catch (error) {
+    cliError((error as Error).message);
+  }
+}
+
+// mcp add-from-claude-desktop (lines 4881–4927)
+export async function mcpAddFromDesktopHandler(options: {
+  scope?: string;
+}): Promise<void> {
+  try {
+    const scope = ensureConfigScope(options.scope);
+    const platform = getPlatform();
+    logEvent('tengu_mcp_add', {
+      scope: scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      platform: platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      source: 'desktop' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    const {
+      readClaudeDesktopMcpServers
+    } = await import('../../utils/claudeDesktop.js');
+    const servers = await readClaudeDesktopMcpServers();
+    if (Object.keys(servers).length === 0) {
+      cliOk('No MCP servers found in Claude Desktop configuration or configuration file does not exist.');
+    }
+    const {
+      unmount
+    } = await render(<AppStateProvider>
+        <KeybindingSetup>
+          <MCPServerDesktopImportDialog servers={servers} scope={scope} onDone={() => {
+          unmount();
+        }} />
+        </KeybindingSetup>
+      </AppStateProvider>, {
+      exitOnCtrlC: true
+    });
+  } catch (error) {
+    cliError((error as Error).message);
+  }
+}
+
+// mcp reset-project-choices (lines 4935–4952)
+export async function mcpResetChoicesHandler(): Promise<void> {
+  logEvent('tengu_mcp_reset_mcpjson_choices', {});
+  saveCurrentProjectConfig(current => ({
+    ...current,
+    enabledMcpjsonServers: [],
+    disabledMcpjsonServers: [],
+    enableAllProjectMcpServers: false
+  }));
+  cliOk('All project-scoped (.mcp.json) server approvals and rejections have been reset.\n' + 'You will be prompted for approval next time you start Claude Code.');
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stat","pMap","cwd","React","MCPServerDesktopImportDialog","render","KeybindingSetup","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearMcpClientConfig","clearServerTokensFromLocalStorage","getMcpClientConfig","readClientSecret","saveMcpClientSecret","connectToServer","getMcpServerConnectionBatchSize","addMcpConfig","getAllMcpConfigs","getMcpConfigByName","getMcpConfigsByScope","removeMcpConfig","ConfigScope","ScopedMcpServerConfig","describeMcpConfigFilePath","ensureConfigScope","getScopeLabel","AppStateProvider","getCurrentProjectConfig","getGlobalConfig","saveCurrentProjectConfig","isFsInaccessible","gracefulShutdown","safeParseJSON","getPlatform","cliError","cliOk","checkMcpServerHealth","name","server","Promise","result","type","_error","mcpServeHandler","debug","verbose","providedCwd","error","setup","undefined","startMCPServer","mcpRemoveHandler","options","scope","serverBeforeRemoval","cleanupSecureStorage","process","stdout","write","projectConfig","globalConfig","servers","projectServers","mcpJsonExists","scopes","Array","Exclude","mcpServers","push","length","stderr","forEach","Error","message","mcpListHandler","configs","Object","keys","console","log","entries","results","status","concurrency","url","args","isArray","command","join","mcpGetHandler","headers","key","value","oauth","clientId","callbackPort","parts","clientConfig","clientSecret","env","mcpAddJsonHandler","json","parsedJson","needsSecret","transportType","String","source","mcpAddFromDesktopHandler","platform","readClaudeDesktopMcpServers","unmount","exitOnCtrlC","mcpResetChoicesHandler","current","enabledMcpjsonServers","disabledMcpjsonServers","enableAllProjectMcpServers"],"sources":["mcp.tsx"],"sourcesContent":["/**\n * MCP subcommand handlers — extracted from main.tsx for lazy loading.\n * These are dynamically imported only when the corresponding `claude mcp *` command runs.\n */\n\nimport { stat } from 'fs/promises'\nimport pMap from 'p-map'\nimport { cwd } from 'process'\nimport React from 'react'\nimport { MCPServerDesktopImportDialog } from '../../components/MCPServerDesktopImportDialog.js'\nimport { render } from '../../ink.js'\nimport { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport {\n  clearMcpClientConfig,\n  clearServerTokensFromLocalStorage,\n  getMcpClientConfig,\n  readClientSecret,\n  saveMcpClientSecret,\n} from '../../services/mcp/auth.js'\nimport {\n  connectToServer,\n  getMcpServerConnectionBatchSize,\n} from '../../services/mcp/client.js'\nimport {\n  addMcpConfig,\n  getAllMcpConfigs,\n  getMcpConfigByName,\n  getMcpConfigsByScope,\n  removeMcpConfig,\n} from '../../services/mcp/config.js'\nimport type {\n  ConfigScope,\n  ScopedMcpServerConfig,\n} from '../../services/mcp/types.js'\nimport {\n  describeMcpConfigFilePath,\n  ensureConfigScope,\n  getScopeLabel,\n} from '../../services/mcp/utils.js'\nimport { AppStateProvider } from '../../state/AppState.js'\nimport {\n  getCurrentProjectConfig,\n  getGlobalConfig,\n  saveCurrentProjectConfig,\n} from '../../utils/config.js'\nimport { isFsInaccessible } from '../../utils/errors.js'\nimport { gracefulShutdown } from '../../utils/gracefulShutdown.js'\nimport { safeParseJSON } from '../../utils/json.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { cliError, cliOk } from '../exit.js'\n\nasync function checkMcpServerHealth(\n  name: string,\n  server: ScopedMcpServerConfig,\n): Promise<string> {\n  try {\n    const result = await connectToServer(name, server)\n    if (result.type === 'connected') {\n      return '✓ Connected'\n    } else if (result.type === 'needs-auth') {\n      return '! Needs authentication'\n    } else {\n      return '✗ Failed to connect'\n    }\n  } catch (_error) {\n    return '✗ Connection error'\n  }\n}\n\n// mcp serve (lines 4512–4532)\nexport async function mcpServeHandler({\n  debug,\n  verbose,\n}: {\n  debug?: boolean\n  verbose?: boolean\n}): Promise<void> {\n  const providedCwd = cwd()\n  logEvent('tengu_mcp_start', {})\n\n  try {\n    await stat(providedCwd)\n  } catch (error) {\n    if (isFsInaccessible(error)) {\n      cliError(`Error: Directory ${providedCwd} does not exist`)\n    }\n    throw error\n  }\n\n  try {\n    const { setup } = await import('../../setup.js')\n    await setup(providedCwd, 'default', false, false, undefined, false)\n    const { startMCPServer } = await import('../../entrypoints/mcp.js')\n    await startMCPServer(providedCwd, debug ?? false, verbose ?? false)\n  } catch (error) {\n    cliError(`Error: Failed to start MCP server: ${error}`)\n  }\n}\n\n// mcp remove (lines 4545–4635)\nexport async function mcpRemoveHandler(\n  name: string,\n  options: { scope?: string },\n): Promise<void> {\n  // Look up config before removing so we can clean up secure storage\n  const serverBeforeRemoval = getMcpConfigByName(name)\n\n  const cleanupSecureStorage = () => {\n    if (\n      serverBeforeRemoval &&\n      (serverBeforeRemoval.type === 'sse' ||\n        serverBeforeRemoval.type === 'http')\n    ) {\n      clearServerTokensFromLocalStorage(name, serverBeforeRemoval)\n      clearMcpClientConfig(name, serverBeforeRemoval)\n    }\n  }\n\n  try {\n    if (options.scope) {\n      const scope = ensureConfigScope(options.scope)\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(`Removed MCP server ${name} from ${scope} config\\n`)\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    }\n\n    // If no scope specified, check where the server exists\n    const projectConfig = getCurrentProjectConfig()\n    const globalConfig = getGlobalConfig()\n\n    // Check if server exists in project scope (.mcp.json)\n    const { servers: projectServers } = getMcpConfigsByScope('project')\n    const mcpJsonExists = !!projectServers[name]\n\n    // Count how many scopes contain this server\n    const scopes: Array<Exclude<ConfigScope, 'dynamic'>> = []\n    if (projectConfig.mcpServers?.[name]) scopes.push('local')\n    if (mcpJsonExists) scopes.push('project')\n    if (globalConfig.mcpServers?.[name]) scopes.push('user')\n\n    if (scopes.length === 0) {\n      cliError(`No MCP server found with name: \"${name}\"`)\n    } else if (scopes.length === 1) {\n      // Server exists in only one scope, remove it\n      const scope = scopes[0]!\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(\n        `Removed MCP server \"${name}\" from ${scope} config\\n`,\n      )\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    } else {\n      // Server exists in multiple scopes\n      process.stderr.write(`MCP server \"${name}\" exists in multiple scopes:\\n`)\n      scopes.forEach(scope => {\n        process.stderr.write(\n          `  - ${getScopeLabel(scope)} (${describeMcpConfigFilePath(scope)})\\n`,\n        )\n      })\n      process.stderr.write('\\nTo remove from a specific scope, use:\\n')\n      scopes.forEach(scope => {\n        process.stderr.write(`  claude mcp remove \"${name}\" -s ${scope}\\n`)\n      })\n      cliError()\n    }\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp list (lines 4641–4688)\nexport async function mcpListHandler(): Promise<void> {\n  logEvent('tengu_mcp_list', {})\n  const { servers: configs } = await getAllMcpConfigs()\n  if (Object.keys(configs).length === 0) {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(\n      'No MCP servers configured. Use `claude mcp add` to add a server.',\n    )\n  } else {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log('Checking MCP server health...\\n')\n\n    // Check servers concurrently\n    const entries = Object.entries(configs)\n    const results = await pMap(\n      entries,\n      async ([name, server]) => ({\n        name,\n        server,\n        status: await checkMcpServerHealth(name, server),\n      }),\n      { concurrency: getMcpServerConnectionBatchSize() },\n    )\n\n    for (const { name, server, status } of results) {\n      // Intentionally excluding sse-ide servers here since they're internal\n      if (server.type === 'sse') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (SSE) - ${status}`)\n      } else if (server.type === 'http') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (HTTP) - ${status}`)\n      } else if (server.type === 'claudeai-proxy') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} - ${status}`)\n      } else if (!server.type || server.type === 'stdio') {\n        const args = Array.isArray(server.args) ? server.args : []\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.command} ${args.join(' ')} - ${status}`)\n      }\n    }\n  }\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp get (lines 4694–4786)\nexport async function mcpGetHandler(name: string): Promise<void> {\n  logEvent('tengu_mcp_get', {\n    name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  const server = getMcpConfigByName(name)\n  if (!server) {\n    cliError(`No MCP server found with name: ${name}`)\n  }\n\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`${name}:`)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Scope: ${getScopeLabel(server.scope)}`)\n\n  // Check server health\n  const status = await checkMcpServerHealth(name, server)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Status: ${status}`)\n\n  // Intentionally excluding sse-ide servers here since they're internal\n  if (server.type === 'sse') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: sse`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'http') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: http`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'stdio') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: stdio`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Command: ${server.command}`)\n    const args = Array.isArray(server.args) ? server.args : []\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Args: ${args.join(' ')}`)\n    if (server.env) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Environment:')\n      for (const [key, value] of Object.entries(server.env)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}=${value}`)\n      }\n    }\n  }\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(\n    `\\nTo remove this server, run: claude mcp remove \"${name}\" -s ${server.scope}`,\n  )\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp add-json (lines 4801–4870)\nexport async function mcpAddJsonHandler(\n  name: string,\n  json: string,\n  options: { scope?: string; clientSecret?: true },\n): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const parsedJson = safeParseJSON(json)\n\n    // Read secret before writing config so cancellation doesn't leave partial state\n    const needsSecret =\n      options.clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string' &&\n      'oauth' in parsedJson &&\n      parsedJson.oauth &&\n      typeof parsedJson.oauth === 'object' &&\n      'clientId' in parsedJson.oauth\n    const clientSecret = needsSecret ? await readClientSecret() : undefined\n\n    await addMcpConfig(name, parsedJson, scope)\n\n    const transportType =\n      parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson\n        ? String(parsedJson.type || 'stdio')\n        : 'stdio'\n\n    if (\n      clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string'\n    ) {\n      saveMcpClientSecret(\n        name,\n        { type: parsedJson.type, url: parsedJson.url },\n        clientSecret,\n      )\n    }\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'json' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      type: transportType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    cliOk(`Added ${transportType} MCP server ${name} to ${scope} config`)\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp add-from-claude-desktop (lines 4881–4927)\nexport async function mcpAddFromDesktopHandler(options: {\n  scope?: string\n}): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const platform = getPlatform()\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      platform:\n        platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'desktop' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    const { readClaudeDesktopMcpServers } = await import(\n      '../../utils/claudeDesktop.js'\n    )\n    const servers = await readClaudeDesktopMcpServers()\n\n    if (Object.keys(servers).length === 0) {\n      cliOk(\n        'No MCP servers found in Claude Desktop configuration or configuration file does not exist.',\n      )\n    }\n\n    const { unmount } = await render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <MCPServerDesktopImportDialog\n            servers={servers}\n            scope={scope}\n            onDone={() => {\n              unmount()\n            }}\n          />\n        </KeybindingSetup>\n      </AppStateProvider>,\n      { exitOnCtrlC: true },\n    )\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp reset-project-choices (lines 4935–4952)\nexport async function mcpResetChoicesHandler(): Promise<void> {\n  logEvent('tengu_mcp_reset_mcpjson_choices', {})\n  saveCurrentProjectConfig(current => ({\n    ...current,\n    enabledMcpjsonServers: [],\n    disabledMcpjsonServers: [],\n    enableAllProjectMcpServers: false,\n  }))\n  cliOk(\n    'All project-scoped (.mcp.json) server approvals and rejections have been reset.\\n' +\n      'You will be prompted for approval next time you start Claude Code.',\n  )\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;;AAEA,SAASA,IAAI,QAAQ,aAAa;AAClC,OAAOC,IAAI,MAAM,OAAO;AACxB,SAASC,GAAG,QAAQ,SAAS;AAC7B,OAAOC,KAAK,MAAM,OAAO;AACzB,SAASC,4BAA4B,QAAQ,kDAAkD;AAC/F,SAASC,MAAM,QAAQ,cAAc;AACrC,SAASC,eAAe,QAAQ,8CAA8C;AAC9E,SACE,KAAKC,0DAA0D,EAC/DC,QAAQ,QACH,mCAAmC;AAC1C,SACEC,oBAAoB,EACpBC,iCAAiC,EACjCC,kBAAkB,EAClBC,gBAAgB,EAChBC,mBAAmB,QACd,4BAA4B;AACnC,SACEC,eAAe,EACfC,+BAA+B,QAC1B,8BAA8B;AACrC,SACEC,YAAY,EACZC,gBAAgB,EAChBC,kBAAkB,EAClBC,oBAAoB,EACpBC,eAAe,QACV,8BAA8B;AACrC,cACEC,WAAW,EACXC,qBAAqB,QAChB,6BAA6B;AACpC,SACEC,yBAAyB,EACzBC,iBAAiB,EACjBC,aAAa,QACR,6BAA6B;AACpC,SAASC,gBAAgB,QAAQ,yBAAyB;AAC1D,SACEC,uBAAuB,EACvBC,eAAe,EACfC,wBAAwB,QACnB,uBAAuB;AAC9B,SAASC,gBAAgB,QAAQ,uBAAuB;AACxD,SAASC,gBAAgB,QAAQ,iCAAiC;AAClE,SAASC,aAAa,QAAQ,qBAAqB;AACnD,SAASC,WAAW,QAAQ,yBAAyB;AACrD,SAASC,QAAQ,EAAEC,KAAK,QAAQ,YAAY;AAE5C,eAAeC,oBAAoBA,CACjCC,IAAI,EAAE,MAAM,EACZC,MAAM,EAAEhB,qBAAqB,CAC9B,EAAEiB,OAAO,CAAC,MAAM,CAAC,CAAC;EACjB,IAAI;IACF,MAAMC,MAAM,GAAG,MAAM1B,eAAe,CAACuB,IAAI,EAAEC,MAAM,CAAC;IAClD,IAAIE,MAAM,CAACC,IAAI,KAAK,WAAW,EAAE;MAC/B,OAAO,aAAa;IACtB,CAAC,MAAM,IAAID,MAAM,CAACC,IAAI,KAAK,YAAY,EAAE;MACvC,OAAO,wBAAwB;IACjC,CAAC,MAAM;MACL,OAAO,qBAAqB;IAC9B;EACF,CAAC,CAAC,OAAOC,MAAM,EAAE;IACf,OAAO,oBAAoB;EAC7B;AACF;;AAEA;AACA,OAAO,eAAeC,eAAeA,CAAC;EACpCC,KAAK;EACLC;AAIF,CAHC,EAAE;EACDD,KAAK,CAAC,EAAE,OAAO;EACfC,OAAO,CAAC,EAAE,OAAO;AACnB,CAAC,CAAC,EAAEN,OAAO,CAAC,IAAI,CAAC,CAAC;EAChB,MAAMO,WAAW,GAAG5C,GAAG,CAAC,CAAC;EACzBM,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;EAE/B,IAAI;IACF,MAAMR,IAAI,CAAC8C,WAAW,CAAC;EACzB,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,IAAIjB,gBAAgB,CAACiB,KAAK,CAAC,EAAE;MAC3Bb,QAAQ,CAAC,oBAAoBY,WAAW,iBAAiB,CAAC;IAC5D;IACA,MAAMC,KAAK;EACb;EAEA,IAAI;IACF,MAAM;MAAEC;IAAM,CAAC,GAAG,MAAM,MAAM,CAAC,gBAAgB,CAAC;IAChD,MAAMA,KAAK,CAACF,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAEG,SAAS,EAAE,KAAK,CAAC;IACnE,MAAM;MAAEC;IAAe,CAAC,GAAG,MAAM,MAAM,CAAC,0BAA0B,CAAC;IACnE,MAAMA,cAAc,CAACJ,WAAW,EAAEF,KAAK,IAAI,KAAK,EAAEC,OAAO,IAAI,KAAK,CAAC;EACrE,CAAC,CAAC,OAAOE,KAAK,EAAE;IACdb,QAAQ,CAAC,sCAAsCa,KAAK,EAAE,CAAC;EACzD;AACF;;AAEA;AACA,OAAO,eAAeI,gBAAgBA,CACpCd,IAAI,EAAE,MAAM,EACZe,OAAO,EAAE;EAAEC,KAAK,CAAC,EAAE,MAAM;AAAC,CAAC,CAC5B,EAAEd,OAAO,CAAC,IAAI,CAAC,CAAC;EACf;EACA,MAAMe,mBAAmB,GAAGpC,kBAAkB,CAACmB,IAAI,CAAC;EAEpD,MAAMkB,oBAAoB,GAAGA,CAAA,KAAM;IACjC,IACED,mBAAmB,KAClBA,mBAAmB,CAACb,IAAI,KAAK,KAAK,IACjCa,mBAAmB,CAACb,IAAI,KAAK,MAAM,CAAC,EACtC;MACA/B,iCAAiC,CAAC2B,IAAI,EAAEiB,mBAAmB,CAAC;MAC5D7C,oBAAoB,CAAC4B,IAAI,EAAEiB,mBAAmB,CAAC;IACjD;EACF,CAAC;EAED,IAAI;IACF,IAAIF,OAAO,CAACC,KAAK,EAAE;MACjB,MAAMA,KAAK,GAAG7B,iBAAiB,CAAC4B,OAAO,CAACC,KAAK,CAAC;MAC9C7C,QAAQ,CAAC,kBAAkB,EAAE;QAC3B6B,IAAI,EAAEA,IAAI,IAAI9B,0DAA0D;QACxE8C,KAAK,EACHA,KAAK,IAAI9C;MACb,CAAC,CAAC;MAEF,MAAMa,eAAe,CAACiB,IAAI,EAAEgB,KAAK,CAAC;MAClCE,oBAAoB,CAAC,CAAC;MACtBC,OAAO,CAACC,MAAM,CAACC,KAAK,CAAC,sBAAsBrB,IAAI,SAASgB,KAAK,WAAW,CAAC;MACzElB,KAAK,CAAC,kBAAkBZ,yBAAyB,CAAC8B,KAAK,CAAC,EAAE,CAAC;IAC7D;;IAEA;IACA,MAAMM,aAAa,GAAGhC,uBAAuB,CAAC,CAAC;IAC/C,MAAMiC,YAAY,GAAGhC,eAAe,CAAC,CAAC;;IAEtC;IACA,MAAM;MAAEiC,OAAO,EAAEC;IAAe,CAAC,GAAG3C,oBAAoB,CAAC,SAAS,CAAC;IACnE,MAAM4C,aAAa,GAAG,CAAC,CAACD,cAAc,CAACzB,IAAI,CAAC;;IAE5C;IACA,MAAM2B,MAAM,EAAEC,KAAK,CAACC,OAAO,CAAC7C,WAAW,EAAE,SAAS,CAAC,CAAC,GAAG,EAAE;IACzD,IAAIsC,aAAa,CAACQ,UAAU,GAAG9B,IAAI,CAAC,EAAE2B,MAAM,CAACI,IAAI,CAAC,OAAO,CAAC;IAC1D,IAAIL,aAAa,EAAEC,MAAM,CAACI,IAAI,CAAC,SAAS,CAAC;IACzC,IAAIR,YAAY,CAACO,UAAU,GAAG9B,IAAI,CAAC,EAAE2B,MAAM,CAACI,IAAI,CAAC,MAAM,CAAC;IAExD,IAAIJ,MAAM,CAACK,MAAM,KAAK,CAAC,EAAE;MACvBnC,QAAQ,CAAC,mCAAmCG,IAAI,GAAG,CAAC;IACtD,CAAC,MAAM,IAAI2B,MAAM,CAACK,MAAM,KAAK,CAAC,EAAE;MAC9B;MACA,MAAMhB,KAAK,GAAGW,MAAM,CAAC,CAAC,CAAC,CAAC;MACxBxD,QAAQ,CAAC,kBAAkB,EAAE;QAC3B6B,IAAI,EAAEA,IAAI,IAAI9B,0DAA0D;QACxE8C,KAAK,EACHA,KAAK,IAAI9C;MACb,CAAC,CAAC;MAEF,MAAMa,eAAe,CAACiB,IAAI,EAAEgB,KAAK,CAAC;MAClCE,oBAAoB,CAAC,CAAC;MACtBC,OAAO,CAACC,MAAM,CAACC,KAAK,CAClB,uBAAuBrB,IAAI,UAAUgB,KAAK,WAC5C,CAAC;MACDlB,KAAK,CAAC,kBAAkBZ,yBAAyB,CAAC8B,KAAK,CAAC,EAAE,CAAC;IAC7D,CAAC,MAAM;MACL;MACAG,OAAO,CAACc,MAAM,CAACZ,KAAK,CAAC,eAAerB,IAAI,gCAAgC,CAAC;MACzE2B,MAAM,CAACO,OAAO,CAAClB,KAAK,IAAI;QACtBG,OAAO,CAACc,MAAM,CAACZ,KAAK,CAClB,OAAOjC,aAAa,CAAC4B,KAAK,CAAC,KAAK9B,yBAAyB,CAAC8B,KAAK,CAAC,KAClE,CAAC;MACH,CAAC,CAAC;MACFG,OAAO,CAACc,MAAM,CAACZ,KAAK,CAAC,2CAA2C,CAAC;MACjEM,MAAM,CAACO,OAAO,CAAClB,KAAK,IAAI;QACtBG,OAAO,CAACc,MAAM,CAACZ,KAAK,CAAC,wBAAwBrB,IAAI,QAAQgB,KAAK,IAAI,CAAC;MACrE,CAAC,CAAC;MACFnB,QAAQ,CAAC,CAAC;IACZ;EACF,CAAC,CAAC,OAAOa,KAAK,EAAE;IACdb,QAAQ,CAAC,CAACa,KAAK,IAAIyB,KAAK,EAAEC,OAAO,CAAC;EACpC;AACF;;AAEA;AACA,OAAO,eAAeC,cAAcA,CAAA,CAAE,EAAEnC,OAAO,CAAC,IAAI,CAAC,CAAC;EACpD/B,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;EAC9B,MAAM;IAAEqD,OAAO,EAAEc;EAAQ,CAAC,GAAG,MAAM1D,gBAAgB,CAAC,CAAC;EACrD,IAAI2D,MAAM,CAACC,IAAI,CAACF,OAAO,CAAC,CAACN,MAAM,KAAK,CAAC,EAAE;IACrC;IACAS,OAAO,CAACC,GAAG,CACT,kEACF,CAAC;EACH,CAAC,MAAM;IACL;IACAD,OAAO,CAACC,GAAG,CAAC,iCAAiC,CAAC;;IAE9C;IACA,MAAMC,OAAO,GAAGJ,MAAM,CAACI,OAAO,CAACL,OAAO,CAAC;IACvC,MAAMM,OAAO,GAAG,MAAMhF,IAAI,CACxB+E,OAAO,EACP,OAAO,CAAC3C,IAAI,EAAEC,MAAM,CAAC,MAAM;MACzBD,IAAI;MACJC,MAAM;MACN4C,MAAM,EAAE,MAAM9C,oBAAoB,CAACC,IAAI,EAAEC,MAAM;IACjD,CAAC,CAAC,EACF;MAAE6C,WAAW,EAAEpE,+BAA+B,CAAC;IAAE,CACnD,CAAC;IAED,KAAK,MAAM;MAAEsB,IAAI;MAAEC,MAAM;MAAE4C;IAAO,CAAC,IAAID,OAAO,EAAE;MAC9C;MACA,IAAI3C,MAAM,CAACG,IAAI,KAAK,KAAK,EAAE;QACzB;QACAqC,OAAO,CAACC,GAAG,CAAC,GAAG1C,IAAI,KAAKC,MAAM,CAAC8C,GAAG,YAAYF,MAAM,EAAE,CAAC;MACzD,CAAC,MAAM,IAAI5C,MAAM,CAACG,IAAI,KAAK,MAAM,EAAE;QACjC;QACAqC,OAAO,CAACC,GAAG,CAAC,GAAG1C,IAAI,KAAKC,MAAM,CAAC8C,GAAG,aAAaF,MAAM,EAAE,CAAC;MAC1D,CAAC,MAAM,IAAI5C,MAAM,CAACG,IAAI,KAAK,gBAAgB,EAAE;QAC3C;QACAqC,OAAO,CAACC,GAAG,CAAC,GAAG1C,IAAI,KAAKC,MAAM,CAAC8C,GAAG,MAAMF,MAAM,EAAE,CAAC;MACnD,CAAC,MAAM,IAAI,CAAC5C,MAAM,CAACG,IAAI,IAAIH,MAAM,CAACG,IAAI,KAAK,OAAO,EAAE;QAClD,MAAM4C,IAAI,GAAGpB,KAAK,CAACqB,OAAO,CAAChD,MAAM,CAAC+C,IAAI,CAAC,GAAG/C,MAAM,CAAC+C,IAAI,GAAG,EAAE;QAC1D;QACAP,OAAO,CAACC,GAAG,CAAC,GAAG1C,IAAI,KAAKC,MAAM,CAACiD,OAAO,IAAIF,IAAI,CAACG,IAAI,CAAC,GAAG,CAAC,MAAMN,MAAM,EAAE,CAAC;MACzE;IACF;EACF;EACA;EACA;EACA,MAAMnD,gBAAgB,CAAC,CAAC,CAAC;AAC3B;;AAEA;AACA,OAAO,eAAe0D,aAAaA,CAACpD,IAAI,EAAE,MAAM,CAAC,EAAEE,OAAO,CAAC,IAAI,CAAC,CAAC;EAC/D/B,QAAQ,CAAC,eAAe,EAAE;IACxB6B,IAAI,EAAEA,IAAI,IAAI9B;EAChB,CAAC,CAAC;EACF,MAAM+B,MAAM,GAAGpB,kBAAkB,CAACmB,IAAI,CAAC;EACvC,IAAI,CAACC,MAAM,EAAE;IACXJ,QAAQ,CAAC,kCAAkCG,IAAI,EAAE,CAAC;EACpD;;EAEA;EACAyC,OAAO,CAACC,GAAG,CAAC,GAAG1C,IAAI,GAAG,CAAC;EACvB;EACAyC,OAAO,CAACC,GAAG,CAAC,YAAYtD,aAAa,CAACa,MAAM,CAACe,KAAK,CAAC,EAAE,CAAC;;EAEtD;EACA,MAAM6B,MAAM,GAAG,MAAM9C,oBAAoB,CAACC,IAAI,EAAEC,MAAM,CAAC;EACvD;EACAwC,OAAO,CAACC,GAAG,CAAC,aAAaG,MAAM,EAAE,CAAC;;EAElC;EACA,IAAI5C,MAAM,CAACG,IAAI,KAAK,KAAK,EAAE;IACzB;IACAqC,OAAO,CAACC,GAAG,CAAC,aAAa,CAAC;IAC1B;IACAD,OAAO,CAACC,GAAG,CAAC,UAAUzC,MAAM,CAAC8C,GAAG,EAAE,CAAC;IACnC,IAAI9C,MAAM,CAACoD,OAAO,EAAE;MAClB;MACAZ,OAAO,CAACC,GAAG,CAAC,YAAY,CAAC;MACzB,KAAK,MAAM,CAACY,GAAG,EAAEC,KAAK,CAAC,IAAIhB,MAAM,CAACI,OAAO,CAAC1C,MAAM,CAACoD,OAAO,CAAC,EAAE;QACzD;QACAZ,OAAO,CAACC,GAAG,CAAC,OAAOY,GAAG,KAAKC,KAAK,EAAE,CAAC;MACrC;IACF;IACA,IAAItD,MAAM,CAACuD,KAAK,EAAEC,QAAQ,IAAIxD,MAAM,CAACuD,KAAK,EAAEE,YAAY,EAAE;MACxD,MAAMC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE;MAC1B,IAAI1D,MAAM,CAACuD,KAAK,CAACC,QAAQ,EAAE;QACzBE,KAAK,CAAC5B,IAAI,CAAC,sBAAsB,CAAC;QAClC,MAAM6B,YAAY,GAAGtF,kBAAkB,CAAC0B,IAAI,EAAEC,MAAM,CAAC;QACrD,IAAI2D,YAAY,EAAEC,YAAY,EAAEF,KAAK,CAAC5B,IAAI,CAAC,0BAA0B,CAAC;MACxE;MACA,IAAI9B,MAAM,CAACuD,KAAK,CAACE,YAAY,EAC3BC,KAAK,CAAC5B,IAAI,CAAC,iBAAiB9B,MAAM,CAACuD,KAAK,CAACE,YAAY,EAAE,CAAC;MAC1D;MACAjB,OAAO,CAACC,GAAG,CAAC,YAAYiB,KAAK,CAACR,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAC7C;EACF,CAAC,MAAM,IAAIlD,MAAM,CAACG,IAAI,KAAK,MAAM,EAAE;IACjC;IACAqC,OAAO,CAACC,GAAG,CAAC,cAAc,CAAC;IAC3B;IACAD,OAAO,CAACC,GAAG,CAAC,UAAUzC,MAAM,CAAC8C,GAAG,EAAE,CAAC;IACnC,IAAI9C,MAAM,CAACoD,OAAO,EAAE;MAClB;MACAZ,OAAO,CAACC,GAAG,CAAC,YAAY,CAAC;MACzB,KAAK,MAAM,CAACY,GAAG,EAAEC,KAAK,CAAC,IAAIhB,MAAM,CAACI,OAAO,CAAC1C,MAAM,CAACoD,OAAO,CAAC,EAAE;QACzD;QACAZ,OAAO,CAACC,GAAG,CAAC,OAAOY,GAAG,KAAKC,KAAK,EAAE,CAAC;MACrC;IACF;IACA,IAAItD,MAAM,CAACuD,KAAK,EAAEC,QAAQ,IAAIxD,MAAM,CAACuD,KAAK,EAAEE,YAAY,EAAE;MACxD,MAAMC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE;MAC1B,IAAI1D,MAAM,CAACuD,KAAK,CAACC,QAAQ,EAAE;QACzBE,KAAK,CAAC5B,IAAI,CAAC,sBAAsB,CAAC;QAClC,MAAM6B,YAAY,GAAGtF,kBAAkB,CAAC0B,IAAI,EAAEC,MAAM,CAAC;QACrD,IAAI2D,YAAY,EAAEC,YAAY,EAAEF,KAAK,CAAC5B,IAAI,CAAC,0BAA0B,CAAC;MACxE;MACA,IAAI9B,MAAM,CAACuD,KAAK,CAACE,YAAY,EAC3BC,KAAK,CAAC5B,IAAI,CAAC,iBAAiB9B,MAAM,CAACuD,KAAK,CAACE,YAAY,EAAE,CAAC;MAC1D;MACAjB,OAAO,CAACC,GAAG,CAAC,YAAYiB,KAAK,CAACR,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAC7C;EACF,CAAC,MAAM,IAAIlD,MAAM,CAACG,IAAI,KAAK,OAAO,EAAE;IAClC;IACAqC,OAAO,CAACC,GAAG,CAAC,eAAe,CAAC;IAC5B;IACAD,OAAO,CAACC,GAAG,CAAC,cAAczC,MAAM,CAACiD,OAAO,EAAE,CAAC;IAC3C,MAAMF,IAAI,GAAGpB,KAAK,CAACqB,OAAO,CAAChD,MAAM,CAAC+C,IAAI,CAAC,GAAG/C,MAAM,CAAC+C,IAAI,GAAG,EAAE;IAC1D;IACAP,OAAO,CAACC,GAAG,CAAC,WAAWM,IAAI,CAACG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;IACxC,IAAIlD,MAAM,CAAC6D,GAAG,EAAE;MACd;MACArB,OAAO,CAACC,GAAG,CAAC,gBAAgB,CAAC;MAC7B,KAAK,MAAM,CAACY,GAAG,EAAEC,KAAK,CAAC,IAAIhB,MAAM,CAACI,OAAO,CAAC1C,MAAM,CAAC6D,GAAG,CAAC,EAAE;QACrD;QACArB,OAAO,CAACC,GAAG,CAAC,OAAOY,GAAG,IAAIC,KAAK,EAAE,CAAC;MACpC;IACF;EACF;EACA;EACAd,OAAO,CAACC,GAAG,CACT,oDAAoD1C,IAAI,QAAQC,MAAM,CAACe,KAAK,EAC9E,CAAC;EACD;EACA;EACA,MAAMtB,gBAAgB,CAAC,CAAC,CAAC;AAC3B;;AAEA;AACA,OAAO,eAAeqE,iBAAiBA,CACrC/D,IAAI,EAAE,MAAM,EACZgE,IAAI,EAAE,MAAM,EACZjD,OAAO,EAAE;EAAEC,KAAK,CAAC,EAAE,MAAM;EAAE6C,YAAY,CAAC,EAAE,IAAI;AAAC,CAAC,CACjD,EAAE3D,OAAO,CAAC,IAAI,CAAC,CAAC;EACf,IAAI;IACF,MAAMc,KAAK,GAAG7B,iBAAiB,CAAC4B,OAAO,CAACC,KAAK,CAAC;IAC9C,MAAMiD,UAAU,GAAGtE,aAAa,CAACqE,IAAI,CAAC;;IAEtC;IACA,MAAME,WAAW,GACfnD,OAAO,CAAC8C,YAAY,IACpBI,UAAU,IACV,OAAOA,UAAU,KAAK,QAAQ,IAC9B,MAAM,IAAIA,UAAU,KACnBA,UAAU,CAAC7D,IAAI,KAAK,KAAK,IAAI6D,UAAU,CAAC7D,IAAI,KAAK,MAAM,CAAC,IACzD,KAAK,IAAI6D,UAAU,IACnB,OAAOA,UAAU,CAAClB,GAAG,KAAK,QAAQ,IAClC,OAAO,IAAIkB,UAAU,IACrBA,UAAU,CAACT,KAAK,IAChB,OAAOS,UAAU,CAACT,KAAK,KAAK,QAAQ,IACpC,UAAU,IAAIS,UAAU,CAACT,KAAK;IAChC,MAAMK,YAAY,GAAGK,WAAW,GAAG,MAAM3F,gBAAgB,CAAC,CAAC,GAAGqC,SAAS;IAEvE,MAAMjC,YAAY,CAACqB,IAAI,EAAEiE,UAAU,EAAEjD,KAAK,CAAC;IAE3C,MAAMmD,aAAa,GACjBF,UAAU,IAAI,OAAOA,UAAU,KAAK,QAAQ,IAAI,MAAM,IAAIA,UAAU,GAChEG,MAAM,CAACH,UAAU,CAAC7D,IAAI,IAAI,OAAO,CAAC,GAClC,OAAO;IAEb,IACEyD,YAAY,IACZI,UAAU,IACV,OAAOA,UAAU,KAAK,QAAQ,IAC9B,MAAM,IAAIA,UAAU,KACnBA,UAAU,CAAC7D,IAAI,KAAK,KAAK,IAAI6D,UAAU,CAAC7D,IAAI,KAAK,MAAM,CAAC,IACzD,KAAK,IAAI6D,UAAU,IACnB,OAAOA,UAAU,CAAClB,GAAG,KAAK,QAAQ,EAClC;MACAvE,mBAAmB,CACjBwB,IAAI,EACJ;QAAEI,IAAI,EAAE6D,UAAU,CAAC7D,IAAI;QAAE2C,GAAG,EAAEkB,UAAU,CAAClB;MAAI,CAAC,EAC9Cc,YACF,CAAC;IACH;IAEA1F,QAAQ,CAAC,eAAe,EAAE;MACxB6C,KAAK,EACHA,KAAK,IAAI9C,0DAA0D;MACrEmG,MAAM,EACJ,MAAM,IAAInG,0DAA0D;MACtEkC,IAAI,EAAE+D,aAAa,IAAIjG;IACzB,CAAC,CAAC;IAEF4B,KAAK,CAAC,SAASqE,aAAa,eAAenE,IAAI,OAAOgB,KAAK,SAAS,CAAC;EACvE,CAAC,CAAC,OAAON,KAAK,EAAE;IACdb,QAAQ,CAAC,CAACa,KAAK,IAAIyB,KAAK,EAAEC,OAAO,CAAC;EACpC;AACF;;AAEA;AACA,OAAO,eAAekC,wBAAwBA,CAACvD,OAAO,EAAE;EACtDC,KAAK,CAAC,EAAE,MAAM;AAChB,CAAC,CAAC,EAAEd,OAAO,CAAC,IAAI,CAAC,CAAC;EAChB,IAAI;IACF,MAAMc,KAAK,GAAG7B,iBAAiB,CAAC4B,OAAO,CAACC,KAAK,CAAC;IAC9C,MAAMuD,QAAQ,GAAG3E,WAAW,CAAC,CAAC;IAE9BzB,QAAQ,CAAC,eAAe,EAAE;MACxB6C,KAAK,EACHA,KAAK,IAAI9C,0DAA0D;MACrEqG,QAAQ,EACNA,QAAQ,IAAIrG,0DAA0D;MACxEmG,MAAM,EACJ,SAAS,IAAInG;IACjB,CAAC,CAAC;IAEF,MAAM;MAAEsG;IAA4B,CAAC,GAAG,MAAM,MAAM,CAClD,8BACF,CAAC;IACD,MAAMhD,OAAO,GAAG,MAAMgD,2BAA2B,CAAC,CAAC;IAEnD,IAAIjC,MAAM,CAACC,IAAI,CAAChB,OAAO,CAAC,CAACQ,MAAM,KAAK,CAAC,EAAE;MACrClC,KAAK,CACH,4FACF,CAAC;IACH;IAEA,MAAM;MAAE2E;IAAQ,CAAC,GAAG,MAAMzG,MAAM,CAC9B,CAAC,gBAAgB;AACvB,QAAQ,CAAC,eAAe;AACxB,UAAU,CAAC,4BAA4B,CAC3B,OAAO,CAAC,CAACwD,OAAO,CAAC,CACjB,KAAK,CAAC,CAACR,KAAK,CAAC,CACb,MAAM,CAAC,CAAC,MAAM;UACZyD,OAAO,CAAC,CAAC;QACX,CAAC,CAAC;AAEd,QAAQ,EAAE,eAAe;AACzB,MAAM,EAAE,gBAAgB,CAAC,EACnB;MAAEC,WAAW,EAAE;IAAK,CACtB,CAAC;EACH,CAAC,CAAC,OAAOhE,KAAK,EAAE;IACdb,QAAQ,CAAC,CAACa,KAAK,IAAIyB,KAAK,EAAEC,OAAO,CAAC;EACpC;AACF;;AAEA;AACA,OAAO,eAAeuC,sBAAsBA,CAAA,CAAE,EAAEzE,OAAO,CAAC,IAAI,CAAC,CAAC;EAC5D/B,QAAQ,CAAC,iCAAiC,EAAE,CAAC,CAAC,CAAC;EAC/CqB,wBAAwB,CAACoF,OAAO,KAAK;IACnC,GAAGA,OAAO;IACVC,qBAAqB,EAAE,EAAE;IACzBC,sBAAsB,EAAE,EAAE;IAC1BC,0BAA0B,EAAE;EAC9B,CAAC,CAAC,CAAC;EACHjF,KAAK,CACH,mFAAmF,GACjF,oEACJ,CAAC;AACH","ignoreList":[]}

src/cli/handlers/util.tsx

@@ -0,0 +1,110 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Miscellaneous subcommand handlers — extracted from main.tsx for lazy loading.
+ * setup-token, doctor, install
+ */
+/* eslint-disable custom-rules/no-process-exit -- CLI subcommand handlers intentionally exit */
+
+import { cwd } from 'process';
+import React from 'react';
+import { WelcomeV2 } from '../../components/LogoV2/WelcomeV2.js';
+import { useManagePlugins } from '../../hooks/useManagePlugins.js';
+import type { Root } from '../../ink.js';
+import { Box, Text } from '../../ink.js';
+import { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { MCPConnectionManager } from '../../services/mcp/MCPConnectionManager.js';
+import { AppStateProvider } from '../../state/AppState.js';
+import { onChangeAppState } from '../../state/onChangeAppState.js';
+import { isAnthropicAuthEnabled } from '../../utils/auth.js';
+export async function setupTokenHandler(root: Root): Promise<void> {
+  logEvent('tengu_setup_token_command', {});
+  const showAuthWarning = !isAnthropicAuthEnabled();
+  const {
+    ConsoleOAuthFlow
+  } = await import('../../components/ConsoleOAuthFlow.js');
+  await new Promise<void>(resolve => {
+    root.render(<AppStateProvider onChangeAppState={onChangeAppState}>
+        <KeybindingSetup>
+          <Box flexDirection="column" gap={1}>
+            <WelcomeV2 />
+            {showAuthWarning && <Box flexDirection="column">
+                <Text color="warning">
+                  Warning: You already have authentication configured via
+                  environment variable or API key helper.
+                </Text>
+                <Text color="warning">
+                  The setup-token command will create a new OAuth token which
+                  you can use instead.
+                </Text>
+              </Box>}
+            <ConsoleOAuthFlow onDone={() => {
+            void resolve();
+          }} mode="setup-token" startingMessage="This will guide you through long-lived (1-year) auth token setup for your Claude account. Claude subscription required." />
+          </Box>
+        </KeybindingSetup>
+      </AppStateProvider>);
+  });
+  root.unmount();
+  process.exit(0);
+}
+
+// DoctorWithPlugins wrapper + doctor handler
+const DoctorLazy = React.lazy(() => import('../../screens/Doctor.js').then(m => ({
+  default: m.Doctor
+})));
+function DoctorWithPlugins(t0) {
+  const $ = _c(2);
+  const {
+    onDone
+  } = t0;
+  useManagePlugins();
+  let t1;
+  if ($[0] !== onDone) {
+    t1 = <React.Suspense fallback={null}><DoctorLazy onDone={onDone} /></React.Suspense>;
+    $[0] = onDone;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+export async function doctorHandler(root: Root): Promise<void> {
+  logEvent('tengu_doctor_command', {});
+  await new Promise<void>(resolve => {
+    root.render(<AppStateProvider>
+        <KeybindingSetup>
+          <MCPConnectionManager dynamicMcpConfig={undefined} isStrictMcpConfig={false}>
+            <DoctorWithPlugins onDone={() => {
+            void resolve();
+          }} />
+          </MCPConnectionManager>
+        </KeybindingSetup>
+      </AppStateProvider>);
+  });
+  root.unmount();
+  process.exit(0);
+}
+
+// install handler
+export async function installHandler(target: string | undefined, options: {
+  force?: boolean;
+}): Promise<void> {
+  const {
+    setup
+  } = await import('../../setup.js');
+  await setup(cwd(), 'default', false, false, undefined, false);
+  const {
+    install
+  } = await import('../../commands/install.js');
+  await new Promise<void>(resolve => {
+    const args: string[] = [];
+    if (target) args.push(target);
+    if (options.force) args.push('--force');
+    void install.call(result => {
+      void resolve();
+      process.exit(result.includes('failed') ? 1 : 0);
+    }, {}, args);
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["cwd","React","WelcomeV2","useManagePlugins","Root","Box","Text","KeybindingSetup","logEvent","MCPConnectionManager","AppStateProvider","onChangeAppState","isAnthropicAuthEnabled","setupTokenHandler","root","Promise","showAuthWarning","ConsoleOAuthFlow","resolve","render","unmount","process","exit","DoctorLazy","lazy","then","m","default","Doctor","DoctorWithPlugins","t0","$","_c","onDone","t1","doctorHandler","undefined","installHandler","target","options","force","setup","install","args","push","call","result","includes"],"sources":["util.tsx"],"sourcesContent":["/**\n * Miscellaneous subcommand handlers — extracted from main.tsx for lazy loading.\n * setup-token, doctor, install\n */\n/* eslint-disable custom-rules/no-process-exit -- CLI subcommand handlers intentionally exit */\n\nimport { cwd } from 'process'\nimport React from 'react'\nimport { WelcomeV2 } from '../../components/LogoV2/WelcomeV2.js'\nimport { useManagePlugins } from '../../hooks/useManagePlugins.js'\nimport type { Root } from '../../ink.js'\nimport { Box, Text } from '../../ink.js'\nimport { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport { MCPConnectionManager } from '../../services/mcp/MCPConnectionManager.js'\nimport { AppStateProvider } from '../../state/AppState.js'\nimport { onChangeAppState } from '../../state/onChangeAppState.js'\nimport { isAnthropicAuthEnabled } from '../../utils/auth.js'\n\nexport async function setupTokenHandler(root: Root): Promise<void> {\n  logEvent('tengu_setup_token_command', {})\n\n  const showAuthWarning = !isAnthropicAuthEnabled()\n  const { ConsoleOAuthFlow } = await import(\n    '../../components/ConsoleOAuthFlow.js'\n  )\n  await new Promise<void>(resolve => {\n    root.render(\n      <AppStateProvider onChangeAppState={onChangeAppState}>\n        <KeybindingSetup>\n          <Box flexDirection=\"column\" gap={1}>\n            <WelcomeV2 />\n            {showAuthWarning && (\n              <Box flexDirection=\"column\">\n                <Text color=\"warning\">\n                  Warning: You already have authentication configured via\n                  environment variable or API key helper.\n                </Text>\n                <Text color=\"warning\">\n                  The setup-token command will create a new OAuth token which\n                  you can use instead.\n                </Text>\n              </Box>\n            )}\n            <ConsoleOAuthFlow\n              onDone={() => {\n                void resolve()\n              }}\n              mode=\"setup-token\"\n              startingMessage=\"This will guide you through long-lived (1-year) auth token setup for your Claude account. Claude subscription required.\"\n            />\n          </Box>\n        </KeybindingSetup>\n      </AppStateProvider>,\n    )\n  })\n  root.unmount()\n  process.exit(0)\n}\n\n// DoctorWithPlugins wrapper + doctor handler\nconst DoctorLazy = React.lazy(() =>\n  import('../../screens/Doctor.js').then(m => ({ default: m.Doctor })),\n)\n\nfunction DoctorWithPlugins({\n  onDone,\n}: {\n  onDone: () => void\n}): React.ReactNode {\n  useManagePlugins()\n  return (\n    <React.Suspense fallback={null}>\n      <DoctorLazy onDone={onDone} />\n    </React.Suspense>\n  )\n}\n\nexport async function doctorHandler(root: Root): Promise<void> {\n  logEvent('tengu_doctor_command', {})\n\n  await new Promise<void>(resolve => {\n    root.render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <MCPConnectionManager\n            dynamicMcpConfig={undefined}\n            isStrictMcpConfig={false}\n          >\n            <DoctorWithPlugins\n              onDone={() => {\n                void resolve()\n              }}\n            />\n          </MCPConnectionManager>\n        </KeybindingSetup>\n      </AppStateProvider>,\n    )\n  })\n  root.unmount()\n  process.exit(0)\n}\n\n// install handler\nexport async function installHandler(\n  target: string | undefined,\n  options: { force?: boolean },\n): Promise<void> {\n  const { setup } = await import('../../setup.js')\n  await setup(cwd(), 'default', false, false, undefined, false)\n  const { install } = await import('../../commands/install.js')\n  await new Promise<void>(resolve => {\n    const args: string[] = []\n    if (target) args.push(target)\n    if (options.force) args.push('--force')\n\n    void install.call(\n      result => {\n        void resolve()\n        process.exit(result.includes('failed') ? 1 : 0)\n      },\n      {},\n      args,\n    )\n  })\n}\n"],"mappings":"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","ignoreList":[]}

src/cli/transports/SerialBatchEventUploader.ts

@@ -0,0 +1,275 @@
+import { jsonStringify } from '../../utils/slowOperations.js'
+
+/**
+ * Serial ordered event uploader with batching, retry, and backpressure.
+ *
+ * - enqueue() adds events to a pending buffer
+ * - At most 1 POST in-flight at a time
+ * - Drains up to maxBatchSize items per POST
+ * - New events accumulate while in-flight
+ * - On failure: exponential backoff (clamped), retries indefinitely
+ *   until success or close() — unless maxConsecutiveFailures is set,
+ *   in which case the failing batch is dropped and drain advances
+ * - flush() blocks until pending is empty and kicks drain if needed
+ * - Backpressure: enqueue() blocks when maxQueueSize is reached
+ */
+
+/**
+ * Throw from config.send() to make the uploader wait a server-supplied
+ * duration before retrying (e.g. 429 with Retry-After). When retryAfterMs
+ * is set, it overrides exponential backoff for that attempt — clamped to
+ * [baseDelayMs, maxDelayMs] and jittered so a misbehaving server can
+ * neither hot-loop nor stall the client, and many sessions sharing a rate
+ * limit don't all pounce at the same instant. Without retryAfterMs, behaves
+ * like any other thrown error (exponential backoff).
+ */
+export class RetryableError extends Error {
+  constructor(
+    message: string,
+    readonly retryAfterMs?: number,
+  ) {
+    super(message)
+  }
+}
+
+type SerialBatchEventUploaderConfig<T> = {
+  /** Max items per POST (1 = no batching) */
+  maxBatchSize: number
+  /**
+   * Max serialized bytes per POST. First item always goes in regardless of
+   * size; subsequent items only if cumulative JSON bytes stay under this.
+   * Undefined = no byte limit (count-only batching).
+   */
+  maxBatchBytes?: number
+  /** Max pending items before enqueue() blocks */
+  maxQueueSize: number
+  /** The actual HTTP call — caller controls payload format */
+  send: (batch: T[]) => Promise<void>
+  /** Base delay for exponential backoff (ms) */
+  baseDelayMs: number
+  /** Max delay cap (ms) */
+  maxDelayMs: number
+  /** Random jitter range added to retry delay (ms) */
+  jitterMs: number
+  /**
+   * After this many consecutive send() failures, drop the failing batch
+   * and move on to the next pending item with a fresh failure budget.
+   * Undefined = retry indefinitely (default).
+   */
+  maxConsecutiveFailures?: number
+  /** Called when a batch is dropped for hitting maxConsecutiveFailures. */
+  onBatchDropped?: (batchSize: number, failures: number) => void
+}
+
+export class SerialBatchEventUploader<T> {
+  private pending: T[] = []
+  private pendingAtClose = 0
+  private draining = false
+  private closed = false
+  private backpressureResolvers: Array<() => void> = []
+  private sleepResolve: (() => void) | null = null
+  private flushResolvers: Array<() => void> = []
+  private droppedBatches = 0
+  private readonly config: SerialBatchEventUploaderConfig<T>
+
+  constructor(config: SerialBatchEventUploaderConfig<T>) {
+    this.config = config
+  }
+
+  /**
+   * Monotonic count of batches dropped via maxConsecutiveFailures. Callers
+   * can snapshot before flush() and compare after to detect silent drops
+   * (flush() resolves normally even when batches were dropped).
+   */
+  get droppedBatchCount(): number {
+    return this.droppedBatches
+  }
+
+  /**
+   * Pending queue depth. After close(), returns the count at close time —
+   * close() clears the queue but shutdown diagnostics may read this after.
+   */
+  get pendingCount(): number {
+    return this.closed ? this.pendingAtClose : this.pending.length
+  }
+
+  /**
+   * Add events to the pending buffer. Returns immediately if space is
+   * available. Blocks (awaits) if the buffer is full — caller pauses
+   * until drain frees space.
+   */
+  async enqueue(events: T | T[]): Promise<void> {
+    if (this.closed) return
+    const items = Array.isArray(events) ? events : [events]
+    if (items.length === 0) return
+
+    // Backpressure: wait until there's space
+    while (
+      this.pending.length + items.length > this.config.maxQueueSize &&
+      !this.closed
+    ) {
+      await new Promise<void>(resolve => {
+        this.backpressureResolvers.push(resolve)
+      })
+    }
+
+    if (this.closed) return
+    this.pending.push(...items)
+    void this.drain()
+  }
+
+  /**
+   * Block until all pending events have been sent.
+   * Used at turn boundaries and graceful shutdown.
+   */
+  flush(): Promise<void> {
+    if (this.pending.length === 0 && !this.draining) {
+      return Promise.resolve()
+    }
+    void this.drain()
+    return new Promise<void>(resolve => {
+      this.flushResolvers.push(resolve)
+    })
+  }
+
+  /**
+   * Drop pending events and stop processing.
+   * Resolves any blocked enqueue() and flush() callers.
+   */
+  close(): void {
+    if (this.closed) return
+    this.closed = true
+    this.pendingAtClose = this.pending.length
+    this.pending = []
+    this.sleepResolve?.()
+    this.sleepResolve = null
+    for (const resolve of this.backpressureResolvers) resolve()
+    this.backpressureResolvers = []
+    for (const resolve of this.flushResolvers) resolve()
+    this.flushResolvers = []
+  }
+
+  /**
+   * Drain loop. At most one instance runs at a time (guarded by this.draining).
+   * Sends batches serially. On failure, backs off and retries indefinitely.
+   */
+  private async drain(): Promise<void> {
+    if (this.draining || this.closed) return
+    this.draining = true
+    let failures = 0
+
+    try {
+      while (this.pending.length > 0 && !this.closed) {
+        const batch = this.takeBatch()
+        if (batch.length === 0) continue
+
+        try {
+          await this.config.send(batch)
+          failures = 0
+        } catch (err) {
+          failures++
+          if (
+            this.config.maxConsecutiveFailures !== undefined &&
+            failures >= this.config.maxConsecutiveFailures
+          ) {
+            this.droppedBatches++
+            this.config.onBatchDropped?.(batch.length, failures)
+            failures = 0
+            this.releaseBackpressure()
+            continue
+          }
+          // Re-queue the failed batch at the front. Use concat (single
+          // allocation) instead of unshift(...batch) which shifts every
+          // pending item batch.length times. Only hit on failure path.
+          this.pending = batch.concat(this.pending)
+          const retryAfterMs =
+            err instanceof RetryableError ? err.retryAfterMs : undefined
+          await this.sleep(this.retryDelay(failures, retryAfterMs))
+          continue
+        }
+
+        // Release backpressure waiters if space opened up
+        this.releaseBackpressure()
+      }
+    } finally {
+      this.draining = false
+      // Notify flush waiters if queue is empty
+      if (this.pending.length === 0) {
+        for (const resolve of this.flushResolvers) resolve()
+        this.flushResolvers = []
+      }
+    }
+  }
+
+  /**
+   * Pull the next batch from pending. Respects both maxBatchSize and
+   * maxBatchBytes. The first item is always taken; subsequent items only
+   * if adding them keeps the cumulative JSON size under maxBatchBytes.
+   *
+   * Un-serializable items (BigInt, circular refs, throwing toJSON) are
+   * dropped in place — they can never be sent and leaving them at
+   * pending[0] would poison the queue and hang flush() forever.
+   */
+  private takeBatch(): T[] {
+    const { maxBatchSize, maxBatchBytes } = this.config
+    if (maxBatchBytes === undefined) {
+      return this.pending.splice(0, maxBatchSize)
+    }
+    let bytes = 0
+    let count = 0
+    while (count < this.pending.length && count < maxBatchSize) {
+      let itemBytes: number
+      try {
+        itemBytes = Buffer.byteLength(jsonStringify(this.pending[count]))
+      } catch {
+        this.pending.splice(count, 1)
+        continue
+      }
+      if (count > 0 && bytes + itemBytes > maxBatchBytes) break
+      bytes += itemBytes
+      count++
+    }
+    return this.pending.splice(0, count)
+  }
+
+  private retryDelay(failures: number, retryAfterMs?: number): number {
+    const jitter = Math.random() * this.config.jitterMs
+    if (retryAfterMs !== undefined) {
+      // Jitter on top of the server's hint prevents thundering herd when
+      // many sessions share a rate limit and all receive the same
+      // Retry-After. Clamp first, then spread — same shape as the
+      // exponential path (effective ceiling is maxDelayMs + jitterMs).
+      const clamped = Math.max(
+        this.config.baseDelayMs,
+        Math.min(retryAfterMs, this.config.maxDelayMs),
+      )
+      return clamped + jitter
+    }
+    const exponential = Math.min(
+      this.config.baseDelayMs * 2 ** (failures - 1),
+      this.config.maxDelayMs,
+    )
+    return exponential + jitter
+  }
+
+  private releaseBackpressure(): void {
+    const resolvers = this.backpressureResolvers
+    this.backpressureResolvers = []
+    for (const resolve of resolvers) resolve()
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => {
+      this.sleepResolve = resolve
+      setTimeout(
+        (self, resolve) => {
+          self.sleepResolve = null
+          resolve()
+        },
+        ms,
+        this,
+        resolve,
+      )
+    })
+  }
+}

src/cli/transports/transportUtils.ts

@@ -0,0 +1,45 @@
+import { URL } from 'url'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { HybridTransport } from './HybridTransport.js'
+import { SSETransport } from './SSETransport.js'
+import type { Transport } from './Transport.js'
+import { WebSocketTransport } from './WebSocketTransport.js'
+
+/**
+ * Helper function to get the appropriate transport for a URL.
+ *
+ * Transport selection priority:
+ * 1. SSETransport (SSE reads + POST writes) when CLAUDE_CODE_USE_CCR_V2 is set
+ * 2. HybridTransport (WS reads + POST writes) when CLAUDE_CODE_POST_FOR_SESSION_INGRESS_V2 is set
+ * 3. WebSocketTransport (WS reads + WS writes) — default
+ */
+export function getTransportForUrl(
+  url: URL,
+  headers: Record<string, string> = {},
+  sessionId?: string,
+  refreshHeaders?: () => Record<string, string>,
+): Transport {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_CCR_V2)) {
+    // v2: SSE for reads, HTTP POST for writes
+    // --sdk-url is the session URL (.../sessions/{id});
+    // derive the SSE stream URL by appending /worker/events/stream
+    const sseUrl = new URL(url.href)
+    if (sseUrl.protocol === 'wss:') {
+      sseUrl.protocol = 'https:'
+    } else if (sseUrl.protocol === 'ws:') {
+      sseUrl.protocol = 'http:'
+    }
+    sseUrl.pathname =
+      sseUrl.pathname.replace(/\/$/, '') + '/worker/events/stream'
+    return new SSETransport(sseUrl, headers, sessionId, refreshHeaders)
+  }
+
+  if (url.protocol === 'ws:' || url.protocol === 'wss:') {
+    if (isEnvTruthy(process.env.CLAUDE_CODE_POST_FOR_SESSION_INGRESS_V2)) {
+      return new HybridTransport(url, headers, sessionId, refreshHeaders)
+    }
+    return new WebSocketTransport(url, headers, sessionId, refreshHeaders)
+  } else {
+    throw new Error(`Unsupported protocol: ${url.protocol}`)
+  }
+}

src/commands/add-dir/validation.ts

@@ -0,0 +1,110 @@
+import chalk from 'chalk'
+import { stat } from 'fs/promises'
+import { dirname, resolve } from 'path'
+import type { ToolPermissionContext } from '../../Tool.js'
+import { getErrnoCode } from '../../utils/errors.js'
+import { expandPath } from '../../utils/path.js'
+import {
+  allWorkingDirectories,
+  pathInWorkingPath,
+} from '../../utils/permissions/filesystem.js'
+
+export type AddDirectoryResult =
+  | {
+      resultType: 'success'
+      absolutePath: string
+    }
+  | {
+      resultType: 'emptyPath'
+    }
+  | {
+      resultType: 'pathNotFound' | 'notADirectory'
+      directoryPath: string
+      absolutePath: string
+    }
+  | {
+      resultType: 'alreadyInWorkingDirectory'
+      directoryPath: string
+      workingDir: string
+    }
+
+export async function validateDirectoryForWorkspace(
+  directoryPath: string,
+  permissionContext: ToolPermissionContext,
+): Promise<AddDirectoryResult> {
+  if (!directoryPath) {
+    return {
+      resultType: 'emptyPath',
+    }
+  }
+
+  // resolve() strips the trailing slash expandPath can leave on absolute
+  // inputs, so /foo and /foo/ map to the same storage key (CC-33).
+  const absolutePath = resolve(expandPath(directoryPath))
+
+  // Check if path exists and is a directory (single syscall)
+  try {
+    const stats = await stat(absolutePath)
+    if (!stats.isDirectory()) {
+      return {
+        resultType: 'notADirectory',
+        directoryPath,
+        absolutePath,
+      }
+    }
+  } catch (e: unknown) {
+    const code = getErrnoCode(e)
+    // Match prior existsSync() semantics: treat any of these as "not found"
+    // rather than re-throwing. EACCES/EPERM in particular must not crash
+    // startup when a settings-configured additional directory is inaccessible.
+    if (
+      code === 'ENOENT' ||
+      code === 'ENOTDIR' ||
+      code === 'EACCES' ||
+      code === 'EPERM'
+    ) {
+      return {
+        resultType: 'pathNotFound',
+        directoryPath,
+        absolutePath,
+      }
+    }
+    throw e
+  }
+
+  // Get current permission context
+  const currentWorkingDirs = allWorkingDirectories(permissionContext)
+
+  // Check if already within an existing working directory
+  for (const workingDir of currentWorkingDirs) {
+    if (pathInWorkingPath(absolutePath, workingDir)) {
+      return {
+        resultType: 'alreadyInWorkingDirectory',
+        directoryPath,
+        workingDir,
+      }
+    }
+  }
+
+  return {
+    resultType: 'success',
+    absolutePath,
+  }
+}
+
+export function addDirHelpMessage(result: AddDirectoryResult): string {
+  switch (result.resultType) {
+    case 'emptyPath':
+      return 'Please provide a directory path.'
+    case 'pathNotFound':
+      return `Path ${chalk.bold(result.absolutePath)} was not found.`
+    case 'notADirectory': {
+      const parentDir = dirname(result.absolutePath)
+      return `${chalk.bold(result.directoryPath)} is not a directory. Did you mean to add the parent directory ${chalk.bold(parentDir)}?`
+    }
+    case 'alreadyInWorkingDirectory':
+      return `${chalk.bold(result.directoryPath)} is already accessible within the existing working directory ${chalk.bold(result.workingDir)}.`
+    case 'success':
+      return `Added ${chalk.bold(result.absolutePath)} as a working directory.`
+  }
+}

src/commands/bridge/bridge.tsx

@@ -0,0 +1,509 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import { toString as qrToString } from 'qrcode';
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { getBridgeAccessToken } from '../../bridge/bridgeConfig.js';
+import { checkBridgeMinVersion, getBridgeDisabledReason, isEnvLessBridgeEnabled } from '../../bridge/bridgeEnabled.js';
+import { checkEnvLessBridgeMinVersion } from '../../bridge/envLessBridgeConfig.js';
+import { BRIDGE_LOGIN_INSTRUCTION, REMOTE_CONTROL_DISCONNECTED_MSG } from '../../bridge/types.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { ListItem } from '../../components/design-system/ListItem.js';
+import { shouldShowRemoteCallout } from '../../components/RemoteCallout.js';
+import { useRegisterOverlay } from '../../context/overlayContext.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybindings } from '../../keybindings/useKeybinding.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
+import { useAppState, useSetAppState } from '../../state/AppState.js';
+import type { ToolUseContext } from '../../Tool.js';
+import type { LocalJSXCommandContext, LocalJSXCommandOnDone } from '../../types/command.js';
+import { logForDebugging } from '../../utils/debug.js';
+type Props = {
+  onDone: LocalJSXCommandOnDone;
+  name?: string;
+};
+
+/**
+ * /remote-control command — manages the bidirectional bridge connection.
+ *
+ * When enabled, sets replBridgeEnabled in AppState, which triggers
+ * useReplBridge in REPL.tsx to initialize the bridge connection.
+ * The bridge registers an environment, creates a session with the current
+ * conversation, polls for work, and connects an ingress WebSocket for
+ * bidirectional messaging between the CLI and claude.ai.
+ *
+ * Running /remote-control when already connected shows a dialog with the session
+ * URL and options to disconnect or continue.
+ */
+function BridgeToggle(t0) {
+  const $ = _c(10);
+  const {
+    onDone,
+    name
+  } = t0;
+  const setAppState = useSetAppState();
+  const replBridgeConnected = useAppState(_temp);
+  const replBridgeEnabled = useAppState(_temp2);
+  const replBridgeOutboundOnly = useAppState(_temp3);
+  const [showDisconnectDialog, setShowDisconnectDialog] = useState(false);
+  let t1;
+  if ($[0] !== name || $[1] !== onDone || $[2] !== replBridgeConnected || $[3] !== replBridgeEnabled || $[4] !== replBridgeOutboundOnly || $[5] !== setAppState) {
+    t1 = () => {
+      if ((replBridgeConnected || replBridgeEnabled) && !replBridgeOutboundOnly) {
+        setShowDisconnectDialog(true);
+        return;
+      }
+      let cancelled = false;
+      (async () => {
+        const error = await checkBridgePrerequisites();
+        if (cancelled) {
+          return;
+        }
+        if (error) {
+          logEvent("tengu_bridge_command", {
+            action: "preflight_failed" as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+          });
+          onDone(error, {
+            display: "system"
+          });
+          return;
+        }
+        if (shouldShowRemoteCallout()) {
+          setAppState(prev => {
+            if (prev.showRemoteCallout) {
+              return prev;
+            }
+            return {
+              ...prev,
+              showRemoteCallout: true,
+              replBridgeInitialName: name
+            };
+          });
+          onDone("", {
+            display: "system"
+          });
+          return;
+        }
+        logEvent("tengu_bridge_command", {
+          action: "connect" as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+        });
+        setAppState(prev_0 => {
+          if (prev_0.replBridgeEnabled && !prev_0.replBridgeOutboundOnly) {
+            return prev_0;
+          }
+          return {
+            ...prev_0,
+            replBridgeEnabled: true,
+            replBridgeExplicit: true,
+            replBridgeOutboundOnly: false,
+            replBridgeInitialName: name
+          };
+        });
+        onDone("Remote Control connecting\u2026", {
+          display: "system"
+        });
+      })();
+      return () => {
+        cancelled = true;
+      };
+    };
+    $[0] = name;
+    $[1] = onDone;
+    $[2] = replBridgeConnected;
+    $[3] = replBridgeEnabled;
+    $[4] = replBridgeOutboundOnly;
+    $[5] = setAppState;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  let t2;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = [];
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  useEffect(t1, t2);
+  if (showDisconnectDialog) {
+    let t3;
+    if ($[8] !== onDone) {
+      t3 = <BridgeDisconnectDialog onDone={onDone} />;
+      $[8] = onDone;
+      $[9] = t3;
+    } else {
+      t3 = $[9];
+    }
+    return t3;
+  }
+  return null;
+}
+
+/**
+ * Dialog shown when /remote-control is used while the bridge is already connected.
+ * Shows the session URL and lets the user disconnect or continue.
+ */
+function _temp3(s_1) {
+  return s_1.replBridgeOutboundOnly;
+}
+function _temp2(s_0) {
+  return s_0.replBridgeEnabled;
+}
+function _temp(s) {
+  return s.replBridgeConnected;
+}
+function BridgeDisconnectDialog(t0) {
+  const $ = _c(61);
+  const {
+    onDone
+  } = t0;
+  useRegisterOverlay("bridge-disconnect-dialog");
+  const setAppState = useSetAppState();
+  const sessionUrl = useAppState(_temp4);
+  const connectUrl = useAppState(_temp5);
+  const sessionActive = useAppState(_temp6);
+  const [focusIndex, setFocusIndex] = useState(2);
+  const [showQR, setShowQR] = useState(false);
+  const [qrText, setQrText] = useState("");
+  const displayUrl = sessionActive ? sessionUrl : connectUrl;
+  let t1;
+  let t2;
+  if ($[0] !== displayUrl || $[1] !== showQR) {
+    t1 = () => {
+      if (!showQR || !displayUrl) {
+        setQrText("");
+        return;
+      }
+      qrToString(displayUrl, {
+        type: "utf8",
+        errorCorrectionLevel: "L",
+        small: true
+      }).then(setQrText).catch(() => setQrText(""));
+    };
+    t2 = [showQR, displayUrl];
+    $[0] = displayUrl;
+    $[1] = showQR;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t1 = $[2];
+    t2 = $[3];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[4] !== onDone || $[5] !== setAppState) {
+    t3 = function handleDisconnect() {
+      setAppState(_temp7);
+      logEvent("tengu_bridge_command", {
+        action: "disconnect" as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      onDone(REMOTE_CONTROL_DISCONNECTED_MSG, {
+        display: "system"
+      });
+    };
+    $[4] = onDone;
+    $[5] = setAppState;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const handleDisconnect = t3;
+  let t4;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = function handleShowQR() {
+      setShowQR(_temp8);
+    };
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const handleShowQR = t4;
+  let t5;
+  if ($[8] !== onDone) {
+    t5 = function handleContinue() {
+      onDone(undefined, {
+        display: "skip"
+      });
+    };
+    $[8] = onDone;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  const handleContinue = t5;
+  let t6;
+  let t7;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = () => setFocusIndex(_temp9);
+    t7 = () => setFocusIndex(_temp0);
+    $[10] = t6;
+    $[11] = t7;
+  } else {
+    t6 = $[10];
+    t7 = $[11];
+  }
+  let t8;
+  if ($[12] !== focusIndex || $[13] !== handleContinue || $[14] !== handleDisconnect) {
+    t8 = {
+      "select:next": t6,
+      "select:previous": t7,
+      "select:accept": () => {
+        if (focusIndex === 0) {
+          handleDisconnect();
+        } else {
+          if (focusIndex === 1) {
+            handleShowQR();
+          } else {
+            handleContinue();
+          }
+        }
+      }
+    };
+    $[12] = focusIndex;
+    $[13] = handleContinue;
+    $[14] = handleDisconnect;
+    $[15] = t8;
+  } else {
+    t8 = $[15];
+  }
+  let t9;
+  if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = {
+      context: "Select"
+    };
+    $[16] = t9;
+  } else {
+    t9 = $[16];
+  }
+  useKeybindings(t8, t9);
+  let T0;
+  let T1;
+  let t10;
+  let t11;
+  let t12;
+  let t13;
+  let t14;
+  let t15;
+  let t16;
+  if ($[17] !== displayUrl || $[18] !== handleContinue || $[19] !== qrText || $[20] !== showQR) {
+    const qrLines = qrText ? qrText.split("\n").filter(_temp1) : [];
+    T1 = Dialog;
+    t14 = "Remote Control";
+    t15 = handleContinue;
+    t16 = true;
+    T0 = Box;
+    t10 = "column";
+    t11 = 1;
+    const t17 = displayUrl ? ` at ${displayUrl}` : "";
+    if ($[30] !== t17) {
+      t12 = <Text>This session is available via Remote Control{t17}.</Text>;
+      $[30] = t17;
+      $[31] = t12;
+    } else {
+      t12 = $[31];
+    }
+    t13 = showQR && qrLines.length > 0 && <Box flexDirection="column">{qrLines.map(_temp10)}</Box>;
+    $[17] = displayUrl;
+    $[18] = handleContinue;
+    $[19] = qrText;
+    $[20] = showQR;
+    $[21] = T0;
+    $[22] = T1;
+    $[23] = t10;
+    $[24] = t11;
+    $[25] = t12;
+    $[26] = t13;
+    $[27] = t14;
+    $[28] = t15;
+    $[29] = t16;
+  } else {
+    T0 = $[21];
+    T1 = $[22];
+    t10 = $[23];
+    t11 = $[24];
+    t12 = $[25];
+    t13 = $[26];
+    t14 = $[27];
+    t15 = $[28];
+    t16 = $[29];
+  }
+  const t17 = focusIndex === 0;
+  let t18;
+  if ($[32] === Symbol.for("react.memo_cache_sentinel")) {
+    t18 = <Text>Disconnect this session</Text>;
+    $[32] = t18;
+  } else {
+    t18 = $[32];
+  }
+  let t19;
+  if ($[33] !== t17) {
+    t19 = <ListItem isFocused={t17}>{t18}</ListItem>;
+    $[33] = t17;
+    $[34] = t19;
+  } else {
+    t19 = $[34];
+  }
+  const t20 = focusIndex === 1;
+  const t21 = showQR ? "Hide QR code" : "Show QR code";
+  let t22;
+  if ($[35] !== t21) {
+    t22 = <Text>{t21}</Text>;
+    $[35] = t21;
+    $[36] = t22;
+  } else {
+    t22 = $[36];
+  }
+  let t23;
+  if ($[37] !== t20 || $[38] !== t22) {
+    t23 = <ListItem isFocused={t20}>{t22}</ListItem>;
+    $[37] = t20;
+    $[38] = t22;
+    $[39] = t23;
+  } else {
+    t23 = $[39];
+  }
+  const t24 = focusIndex === 2;
+  let t25;
+  if ($[40] === Symbol.for("react.memo_cache_sentinel")) {
+    t25 = <Text>Continue</Text>;
+    $[40] = t25;
+  } else {
+    t25 = $[40];
+  }
+  let t26;
+  if ($[41] !== t24) {
+    t26 = <ListItem isFocused={t24}>{t25}</ListItem>;
+    $[41] = t24;
+    $[42] = t26;
+  } else {
+    t26 = $[42];
+  }
+  let t27;
+  if ($[43] !== t19 || $[44] !== t23 || $[45] !== t26) {
+    t27 = <Box flexDirection="column">{t19}{t23}{t26}</Box>;
+    $[43] = t19;
+    $[44] = t23;
+    $[45] = t26;
+    $[46] = t27;
+  } else {
+    t27 = $[46];
+  }
+  let t28;
+  if ($[47] === Symbol.for("react.memo_cache_sentinel")) {
+    t28 = <Text dimColor={true}>Enter to select · Esc to continue</Text>;
+    $[47] = t28;
+  } else {
+    t28 = $[47];
+  }
+  let t29;
+  if ($[48] !== T0 || $[49] !== t10 || $[50] !== t11 || $[51] !== t12 || $[52] !== t13 || $[53] !== t27) {
+    t29 = <T0 flexDirection={t10} gap={t11}>{t12}{t13}{t27}{t28}</T0>;
+    $[48] = T0;
+    $[49] = t10;
+    $[50] = t11;
+    $[51] = t12;
+    $[52] = t13;
+    $[53] = t27;
+    $[54] = t29;
+  } else {
+    t29 = $[54];
+  }
+  let t30;
+  if ($[55] !== T1 || $[56] !== t14 || $[57] !== t15 || $[58] !== t16 || $[59] !== t29) {
+    t30 = <T1 title={t14} onCancel={t15} hideInputGuide={t16}>{t29}</T1>;
+    $[55] = T1;
+    $[56] = t14;
+    $[57] = t15;
+    $[58] = t16;
+    $[59] = t29;
+    $[60] = t30;
+  } else {
+    t30 = $[60];
+  }
+  return t30;
+}
+
+/**
+ * Check bridge prerequisites. Returns an error message if a precondition
+ * fails, or null if all checks pass. Awaits GrowthBook init if the disk
+ * cache is stale, so a user who just became entitled (e.g. upgraded to Max,
+ * or the flag just launched) gets an accurate result on the first try.
+ */
+function _temp10(line, i_1) {
+  return <Text key={i_1}>{line}</Text>;
+}
+function _temp1(l) {
+  return l.length > 0;
+}
+function _temp0(i_0) {
+  return (i_0 - 1 + 3) % 3;
+}
+function _temp9(i) {
+  return (i + 1) % 3;
+}
+function _temp8(prev_0) {
+  return !prev_0;
+}
+function _temp7(prev) {
+  if (!prev.replBridgeEnabled) {
+    return prev;
+  }
+  return {
+    ...prev,
+    replBridgeEnabled: false,
+    replBridgeExplicit: false,
+    replBridgeOutboundOnly: false
+  };
+}
+function _temp6(s_1) {
+  return s_1.replBridgeSessionActive;
+}
+function _temp5(s_0) {
+  return s_0.replBridgeConnectUrl;
+}
+function _temp4(s) {
+  return s.replBridgeSessionUrl;
+}
+async function checkBridgePrerequisites(): Promise<string | null> {
+  // Check organization policy — remote control may be disabled
+  const {
+    waitForPolicyLimitsToLoad,
+    isPolicyAllowed
+  } = await import('../../services/policyLimits/index.js');
+  await waitForPolicyLimitsToLoad();
+  if (!isPolicyAllowed('allow_remote_control')) {
+    return "Remote Control is disabled by your organization's policy.";
+  }
+  const disabledReason = await getBridgeDisabledReason();
+  if (disabledReason) {
+    return disabledReason;
+  }
+
+  // Mirror the v1/v2 branching logic in initReplBridge: env-less (v2) is used
+  // only when the flag is on AND the session is not perpetual.  In assistant
+  // mode (KAIROS) useReplBridge sets perpetual=true, which forces
+  // initReplBridge onto the v1 path — so the prerequisite check must match.
+  let useV2 = isEnvLessBridgeEnabled();
+  if (feature('KAIROS') && useV2) {
+    const {
+      isAssistantMode
+    } = await import('../../assistant/index.js');
+    if (isAssistantMode()) {
+      useV2 = false;
+    }
+  }
+  const versionError = useV2 ? await checkEnvLessBridgeMinVersion() : checkBridgeMinVersion();
+  if (versionError) {
+    return versionError;
+  }
+  if (!getBridgeAccessToken()) {
+    return BRIDGE_LOGIN_INSTRUCTION;
+  }
+  logForDebugging('[bridge] Prerequisites passed, enabling bridge');
+  return null;
+}
+export async function call(onDone: LocalJSXCommandOnDone, _context: ToolUseContext & LocalJSXCommandContext, args: string): Promise<React.ReactNode> {
+  const name = args.trim() || undefined;
+  return <BridgeToggle onDone={onDone} name={name} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","toString","qrToString","React","useEffect","useState","getBridgeAccessToken","checkBridgeMinVersion","getBridgeDisabledReason","isEnvLessBridgeEnabled","checkEnvLessBridgeMinVersion","BRIDGE_LOGIN_INSTRUCTION","REMOTE_CONTROL_DISCONNECTED_MSG","Dialog","ListItem","shouldShowRemoteCallout","useRegisterOverlay","Box","Text","useKeybindings","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","useAppState","useSetAppState","ToolUseContext","LocalJSXCommandContext","LocalJSXCommandOnDone","logForDebugging","Props","onDone","name","BridgeToggle","t0","$","_c","setAppState","replBridgeConnected","_temp","replBridgeEnabled","_temp2","replBridgeOutboundOnly","_temp3","showDisconnectDialog","setShowDisconnectDialog","t1","cancelled","error","checkBridgePrerequisites","action","display","prev","showRemoteCallout","replBridgeInitialName","prev_0","replBridgeExplicit","t2","Symbol","for","t3","s_1","s","s_0","BridgeDisconnectDialog","sessionUrl","_temp4","connectUrl","_temp5","sessionActive","_temp6","focusIndex","setFocusIndex","showQR","setShowQR","qrText","setQrText","displayUrl","type","errorCorrectionLevel","small","then","catch","handleDisconnect","_temp7","t4","handleShowQR","_temp8","t5","handleContinue","undefined","t6","t7","_temp9","_temp0","t8","select:accept","t9","context","T0","T1","t10","t11","t12","t13","t14","t15","t16","qrLines","split","filter","_temp1","t17","length","map","_temp10","t18","t19","t20","t21","t22","t23","t24","t25","t26","t27","t28","t29","t30","line","i_1","i","l","i_0","replBridgeSessionActive","replBridgeConnectUrl","replBridgeSessionUrl","Promise","waitForPolicyLimitsToLoad","isPolicyAllowed","disabledReason","useV2","isAssistantMode","versionError","call","_context","args","ReactNode","trim"],"sources":["bridge.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport { toString as qrToString } from 'qrcode'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { getBridgeAccessToken } from '../../bridge/bridgeConfig.js'\nimport {\n  checkBridgeMinVersion,\n  getBridgeDisabledReason,\n  isEnvLessBridgeEnabled,\n} from '../../bridge/bridgeEnabled.js'\nimport { checkEnvLessBridgeMinVersion } from '../../bridge/envLessBridgeConfig.js'\nimport {\n  BRIDGE_LOGIN_INSTRUCTION,\n  REMOTE_CONTROL_DISCONNECTED_MSG,\n} from '../../bridge/types.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { ListItem } from '../../components/design-system/ListItem.js'\nimport { shouldShowRemoteCallout } from '../../components/RemoteCallout.js'\nimport { useRegisterOverlay } from '../../context/overlayContext.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybindings } from '../../keybindings/useKeybinding.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { useAppState, useSetAppState } from '../../state/AppState.js'\nimport type { ToolUseContext } from '../../Tool.js'\nimport type {\n  LocalJSXCommandContext,\n  LocalJSXCommandOnDone,\n} from '../../types/command.js'\nimport { logForDebugging } from '../../utils/debug.js'\n\ntype Props = {\n  onDone: LocalJSXCommandOnDone\n  name?: string\n}\n\n/**\n * /remote-control command — manages the bidirectional bridge connection.\n *\n * When enabled, sets replBridgeEnabled in AppState, which triggers\n * useReplBridge in REPL.tsx to initialize the bridge connection.\n * The bridge registers an environment, creates a session with the current\n * conversation, polls for work, and connects an ingress WebSocket for\n * bidirectional messaging between the CLI and claude.ai.\n *\n * Running /remote-control when already connected shows a dialog with the session\n * URL and options to disconnect or continue.\n */\nfunction BridgeToggle({ onDone, name }: Props): React.ReactNode {\n  const setAppState = useSetAppState()\n  const replBridgeConnected = useAppState(s => s.replBridgeConnected)\n  const replBridgeEnabled = useAppState(s => s.replBridgeEnabled)\n  const replBridgeOutboundOnly = useAppState(s => s.replBridgeOutboundOnly)\n  const [showDisconnectDialog, setShowDisconnectDialog] = useState(false)\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: bridge starts once, should not restart on state changes\n  useEffect(() => {\n    // If already connected or enabled in full bidirectional mode, show\n    // disconnect confirmation. Outbound-only (CCR mirror) doesn't count —\n    // /remote-control upgrades it to full RC instead.\n    if ((replBridgeConnected || replBridgeEnabled) && !replBridgeOutboundOnly) {\n      setShowDisconnectDialog(true)\n      return\n    }\n\n    let cancelled = false\n    void (async () => {\n      // Pre-flight checks before enabling (awaits GrowthBook init if disk\n      // cache is stale — so Max users don't get a false \"not enabled\" error)\n      const error = await checkBridgePrerequisites()\n      if (cancelled) return\n      if (error) {\n        logEvent('tengu_bridge_command', {\n          action:\n            'preflight_failed' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n        onDone(error, { display: 'system' })\n        return\n      }\n\n      // Show first-time remote dialog if not yet seen.\n      // Store the name now so it's in AppState when the callout handler later\n      // enables the bridge (the handler only sets replBridgeEnabled, not the name).\n      if (shouldShowRemoteCallout()) {\n        setAppState(prev => {\n          if (prev.showRemoteCallout) return prev\n          return {\n            ...prev,\n            showRemoteCallout: true,\n            replBridgeInitialName: name,\n          }\n        })\n        onDone('', { display: 'system' })\n        return\n      }\n\n      // Enable the bridge — useReplBridge in REPL.tsx handles the rest:\n      // registers environment, creates session with conversation, connects WebSocket\n      logEvent('tengu_bridge_command', {\n        action:\n          'connect' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      setAppState(prev => {\n        if (prev.replBridgeEnabled && !prev.replBridgeOutboundOnly) return prev\n        return {\n          ...prev,\n          replBridgeEnabled: true,\n          replBridgeExplicit: true,\n          replBridgeOutboundOnly: false,\n          replBridgeInitialName: name,\n        }\n      })\n      onDone('Remote Control connecting\\u2026', {\n        display: 'system',\n      })\n    })()\n\n    return () => {\n      cancelled = true\n    }\n  }, []) // eslint-disable-line react-hooks/exhaustive-deps -- run once on mount\n\n  if (showDisconnectDialog) {\n    return <BridgeDisconnectDialog onDone={onDone} />\n  }\n\n  return null\n}\n\n/**\n * Dialog shown when /remote-control is used while the bridge is already connected.\n * Shows the session URL and lets the user disconnect or continue.\n */\nfunction BridgeDisconnectDialog({ onDone }: Props): React.ReactNode {\n  useRegisterOverlay('bridge-disconnect-dialog')\n  const setAppState = useSetAppState()\n  const sessionUrl = useAppState(s => s.replBridgeSessionUrl)\n  const connectUrl = useAppState(s => s.replBridgeConnectUrl)\n  const sessionActive = useAppState(s => s.replBridgeSessionActive)\n  const [focusIndex, setFocusIndex] = useState(2)\n  const [showQR, setShowQR] = useState(false)\n  const [qrText, setQrText] = useState('')\n\n  const displayUrl = sessionActive ? sessionUrl : connectUrl\n\n  // Generate QR code when URL changes or QR is toggled on\n  useEffect(() => {\n    if (!showQR || !displayUrl) {\n      setQrText('')\n      return\n    }\n    qrToString(displayUrl, {\n      type: 'utf8',\n      errorCorrectionLevel: 'L',\n      small: true,\n    })\n      .then(setQrText)\n      .catch(() => setQrText(''))\n  }, [showQR, displayUrl])\n\n  function handleDisconnect(): void {\n    setAppState(prev => {\n      if (!prev.replBridgeEnabled) return prev\n      return {\n        ...prev,\n        replBridgeEnabled: false,\n        replBridgeExplicit: false,\n        replBridgeOutboundOnly: false,\n      }\n    })\n    logEvent('tengu_bridge_command', {\n      action:\n        'disconnect' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    onDone(REMOTE_CONTROL_DISCONNECTED_MSG, { display: 'system' })\n  }\n\n  function handleShowQR(): void {\n    setShowQR(prev => !prev)\n  }\n\n  function handleContinue(): void {\n    onDone(undefined, { display: 'skip' })\n  }\n\n  const ITEM_COUNT = 3\n\n  useKeybindings(\n    {\n      'select:next': () => setFocusIndex(i => (i + 1) % ITEM_COUNT),\n      'select:previous': () =>\n        setFocusIndex(i => (i - 1 + ITEM_COUNT) % ITEM_COUNT),\n      'select:accept': () => {\n        if (focusIndex === 0) {\n          handleDisconnect()\n        } else if (focusIndex === 1) {\n          handleShowQR()\n        } else {\n          handleContinue()\n        }\n      },\n    },\n    { context: 'Select' },\n  )\n\n  const qrLines = qrText ? qrText.split('\\n').filter(l => l.length > 0) : []\n\n  return (\n    <Dialog title=\"Remote Control\" onCancel={handleContinue} hideInputGuide>\n      <Box flexDirection=\"column\" gap={1}>\n        <Text>\n          This session is available via Remote Control\n          {displayUrl ? ` at ${displayUrl}` : ''}.\n        </Text>\n        {showQR && qrLines.length > 0 && (\n          <Box flexDirection=\"column\">\n            {qrLines.map((line, i) => (\n              <Text key={i}>{line}</Text>\n            ))}\n          </Box>\n        )}\n        <Box flexDirection=\"column\">\n          <ListItem isFocused={focusIndex === 0}>\n            <Text>Disconnect this session</Text>\n          </ListItem>\n          <ListItem isFocused={focusIndex === 1}>\n            <Text>{showQR ? 'Hide QR code' : 'Show QR code'}</Text>\n          </ListItem>\n          <ListItem isFocused={focusIndex === 2}>\n            <Text>Continue</Text>\n          </ListItem>\n        </Box>\n        <Text dimColor>Enter to select · Esc to continue</Text>\n      </Box>\n    </Dialog>\n  )\n}\n\n/**\n * Check bridge prerequisites. Returns an error message if a precondition\n * fails, or null if all checks pass. Awaits GrowthBook init if the disk\n * cache is stale, so a user who just became entitled (e.g. upgraded to Max,\n * or the flag just launched) gets an accurate result on the first try.\n */\nasync function checkBridgePrerequisites(): Promise<string | null> {\n  // Check organization policy — remote control may be disabled\n  const { waitForPolicyLimitsToLoad, isPolicyAllowed } = await import(\n    '../../services/policyLimits/index.js'\n  )\n  await waitForPolicyLimitsToLoad()\n  if (!isPolicyAllowed('allow_remote_control')) {\n    return \"Remote Control is disabled by your organization's policy.\"\n  }\n\n  const disabledReason = await getBridgeDisabledReason()\n  if (disabledReason) {\n    return disabledReason\n  }\n\n  // Mirror the v1/v2 branching logic in initReplBridge: env-less (v2) is used\n  // only when the flag is on AND the session is not perpetual.  In assistant\n  // mode (KAIROS) useReplBridge sets perpetual=true, which forces\n  // initReplBridge onto the v1 path — so the prerequisite check must match.\n  let useV2 = isEnvLessBridgeEnabled()\n  if (feature('KAIROS') && useV2) {\n    const { isAssistantMode } = await import('../../assistant/index.js')\n    if (isAssistantMode()) {\n      useV2 = false\n    }\n  }\n  const versionError = useV2\n    ? await checkEnvLessBridgeMinVersion()\n    : checkBridgeMinVersion()\n  if (versionError) {\n    return versionError\n  }\n\n  if (!getBridgeAccessToken()) {\n    return BRIDGE_LOGIN_INSTRUCTION\n  }\n\n  logForDebugging('[bridge] Prerequisites passed, enabling bridge')\n  return null\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  _context: ToolUseContext & LocalJSXCommandContext,\n  args: string,\n): Promise<React.ReactNode> {\n  const name = args.trim() || undefined\n  return <BridgeToggle onDone={onDone} name={name} />\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/btw/btw.tsx

@@ -0,0 +1,243 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { useInterval } from 'usehooks-ts';
+import type { CommandResultDisplay } from '../../commands.js';
+import { Markdown } from '../../components/Markdown.js';
+import { SpinnerGlyph } from '../../components/Spinner/SpinnerGlyph.js';
+import { DOWN_ARROW, UP_ARROW } from '../../constants/figures.js';
+import { getSystemPrompt } from '../../constants/prompts.js';
+import { useModalOrTerminalSize } from '../../context/modalContext.js';
+import { getSystemContext, getUserContext } from '../../context.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import ScrollBox, { type ScrollBoxHandle } from '../../ink/components/ScrollBox.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { Box, Text } from '../../ink.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import type { Message } from '../../types/message.js';
+import { createAbortController } from '../../utils/abortController.js';
+import { saveGlobalConfig } from '../../utils/config.js';
+import { errorMessage } from '../../utils/errors.js';
+import { type CacheSafeParams, getLastCacheSafeParams } from '../../utils/forkedAgent.js';
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js';
+import type { ProcessUserInputContext } from '../../utils/processUserInput/processUserInput.js';
+import { runSideQuestion } from '../../utils/sideQuestion.js';
+import { asSystemPrompt } from '../../utils/systemPromptType.js';
+type BtwComponentProps = {
+  question: string;
+  context: ProcessUserInputContext;
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+};
+const CHROME_ROWS = 5;
+const OUTER_CHROME_ROWS = 6;
+const SCROLL_LINES = 3;
+function BtwSideQuestion(t0) {
+  const $ = _c(25);
+  const {
+    question,
+    context,
+    onDone
+  } = t0;
+  const [response, setResponse] = useState(null);
+  const [error, setError] = useState(null);
+  const [frame, setFrame] = useState(0);
+  const scrollRef = useRef(null);
+  const {
+    rows
+  } = useModalOrTerminalSize(useTerminalSize());
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => setFrame(_temp);
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  useInterval(t1, response || error ? null : 80);
+  let t2;
+  if ($[1] !== onDone) {
+    t2 = function handleKeyDown(e) {
+      if (e.key === "escape" || e.key === "return" || e.key === " " || e.ctrl && (e.key === "c" || e.key === "d")) {
+        e.preventDefault();
+        onDone(undefined, {
+          display: "skip"
+        });
+        return;
+      }
+      if (e.key === "up" || e.ctrl && e.key === "p") {
+        e.preventDefault();
+        scrollRef.current?.scrollBy(-SCROLL_LINES);
+      }
+      if (e.key === "down" || e.ctrl && e.key === "n") {
+        e.preventDefault();
+        scrollRef.current?.scrollBy(SCROLL_LINES);
+      }
+    };
+    $[1] = onDone;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const handleKeyDown = t2;
+  let t3;
+  let t4;
+  if ($[3] !== context || $[4] !== question) {
+    t3 = () => {
+      const abortController = createAbortController();
+      const fetchResponse = async function fetchResponse() {
+        ;
+        try {
+          const cacheSafeParams = await buildCacheSafeParams(context);
+          const result = await runSideQuestion({
+            question,
+            cacheSafeParams
+          });
+          if (!abortController.signal.aborted) {
+            if (result.response) {
+              setResponse(result.response);
+            } else {
+              setError("No response received");
+            }
+          }
+        } catch (t5) {
+          const err = t5;
+          if (!abortController.signal.aborted) {
+            setError(errorMessage(err) || "Failed to get response");
+          }
+        }
+      };
+      fetchResponse();
+      return () => {
+        abortController.abort();
+      };
+    };
+    t4 = [question, context];
+    $[3] = context;
+    $[4] = question;
+    $[5] = t3;
+    $[6] = t4;
+  } else {
+    t3 = $[5];
+    t4 = $[6];
+  }
+  useEffect(t3, t4);
+  const maxContentHeight = Math.max(5, rows - CHROME_ROWS - OUTER_CHROME_ROWS);
+  let t5;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Text color="warning" bold={true}>/btw{" "}</Text>;
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  let t6;
+  if ($[8] !== question) {
+    t6 = <Box>{t5}<Text dimColor={true}>{question}</Text></Box>;
+    $[8] = question;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] !== error || $[11] !== frame || $[12] !== response) {
+    t7 = <ScrollBox ref={scrollRef} flexDirection="column" flexGrow={1}>{error ? <Text color="error">{error}</Text> : response ? <Markdown>{response}</Markdown> : <Box><SpinnerGlyph frame={frame} messageColor="warning" /><Text color="warning">Answering...</Text></Box>}</ScrollBox>;
+    $[10] = error;
+    $[11] = frame;
+    $[12] = response;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  let t8;
+  if ($[14] !== maxContentHeight || $[15] !== t7) {
+    t8 = <Box marginTop={1} marginLeft={2} maxHeight={maxContentHeight}>{t7}</Box>;
+    $[14] = maxContentHeight;
+    $[15] = t7;
+    $[16] = t8;
+  } else {
+    t8 = $[16];
+  }
+  let t9;
+  if ($[17] !== error || $[18] !== response) {
+    t9 = (response || error) && <Box marginTop={1}><Text dimColor={true}>{UP_ARROW}/{DOWN_ARROW} to scroll · Space, Enter, or Escape to dismiss</Text></Box>;
+    $[17] = error;
+    $[18] = response;
+    $[19] = t9;
+  } else {
+    t9 = $[19];
+  }
+  let t10;
+  if ($[20] !== handleKeyDown || $[21] !== t6 || $[22] !== t8 || $[23] !== t9) {
+    t10 = <Box flexDirection="column" paddingLeft={2} marginTop={1} tabIndex={0} autoFocus={true} onKeyDown={handleKeyDown}>{t6}{t8}{t9}</Box>;
+    $[20] = handleKeyDown;
+    $[21] = t6;
+    $[22] = t8;
+    $[23] = t9;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  return t10;
+}
+
+/**
+ * Build CacheSafeParams for the side question fork.
+ *
+ * The preferred source is getLastCacheSafeParams — the exact
+ * systemPrompt/userContext/systemContext bytes the main thread sent on its
+ * last request (captured in stopHooks). Reusing them guarantees a byte-
+ * identical prefix and thus a prompt cache hit. We pair these with the
+ * current toolUseContext (for thinkingConfig/tools) and current messages
+ * (for up-to-date context).
+ *
+ * Fallback (first turn before stop hooks fire, or prompt-suggestion
+ * disabled): rebuild from scratch. This may miss the cache if the main loop
+ * applied buildEffectiveSystemPrompt extras (--agent, --system-prompt,
+ * --append-system-prompt, coordinator mode).
+ */
+function _temp(f) {
+  return f + 1;
+}
+function stripInProgressAssistantMessage(messages: Message[]): Message[] {
+  const last = messages.at(-1);
+  if (last?.type === 'assistant' && last.message.stop_reason === null) {
+    return messages.slice(0, -1);
+  }
+  return messages;
+}
+async function buildCacheSafeParams(context: ProcessUserInputContext): Promise<CacheSafeParams> {
+  const forkContextMessages = getMessagesAfterCompactBoundary(stripInProgressAssistantMessage(context.messages));
+  const saved = getLastCacheSafeParams();
+  if (saved) {
+    return {
+      systemPrompt: saved.systemPrompt,
+      userContext: saved.userContext,
+      systemContext: saved.systemContext,
+      toolUseContext: context,
+      forkContextMessages
+    };
+  }
+  const [rawSystemPrompt, userContext, systemContext] = await Promise.all([getSystemPrompt(context.options.tools, context.options.mainLoopModel, [], context.options.mcpClients), getUserContext(), getSystemContext()]);
+  return {
+    systemPrompt: asSystemPrompt(rawSystemPrompt),
+    userContext,
+    systemContext,
+    toolUseContext: context,
+    forkContextMessages
+  };
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: ProcessUserInputContext, args: string): Promise<React.ReactNode> {
+  const question = args?.trim();
+  if (!question) {
+    onDone('Usage: /btw <your question>', {
+      display: 'system'
+    });
+    return null;
+  }
+  saveGlobalConfig(current => ({
+    ...current,
+    btwUseCount: current.btwUseCount + 1
+  }));
+  return <BtwSideQuestion question={question} context={context} onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useState","useInterval","CommandResultDisplay","Markdown","SpinnerGlyph","DOWN_ARROW","UP_ARROW","getSystemPrompt","useModalOrTerminalSize","getSystemContext","getUserContext","useTerminalSize","ScrollBox","ScrollBoxHandle","KeyboardEvent","Box","Text","LocalJSXCommandOnDone","Message","createAbortController","saveGlobalConfig","errorMessage","CacheSafeParams","getLastCacheSafeParams","getMessagesAfterCompactBoundary","ProcessUserInputContext","runSideQuestion","asSystemPrompt","BtwComponentProps","question","context","onDone","result","options","display","CHROME_ROWS","OUTER_CHROME_ROWS","SCROLL_LINES","BtwSideQuestion","t0","$","_c","response","setResponse","error","setError","frame","setFrame","scrollRef","rows","t1","Symbol","for","_temp","t2","handleKeyDown","e","key","ctrl","preventDefault","undefined","current","scrollBy","t3","t4","abortController","fetchResponse","cacheSafeParams","buildCacheSafeParams","signal","aborted","t5","err","abort","maxContentHeight","Math","max","t6","t7","t8","t9","t10","f","stripInProgressAssistantMessage","messages","last","at","type","message","stop_reason","slice","Promise","forkContextMessages","saved","systemPrompt","userContext","systemContext","toolUseContext","rawSystemPrompt","all","tools","mainLoopModel","mcpClients","call","args","ReactNode","trim","btwUseCount"],"sources":["btw.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport { useInterval } from 'usehooks-ts'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { Markdown } from '../../components/Markdown.js'\nimport { SpinnerGlyph } from '../../components/Spinner/SpinnerGlyph.js'\nimport { DOWN_ARROW, UP_ARROW } from '../../constants/figures.js'\nimport { getSystemPrompt } from '../../constants/prompts.js'\nimport { useModalOrTerminalSize } from '../../context/modalContext.js'\nimport { getSystemContext, getUserContext } from '../../context.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport ScrollBox, {\n  type ScrollBoxHandle,\n} from '../../ink/components/ScrollBox.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { Box, Text } from '../../ink.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport type { Message } from '../../types/message.js'\nimport { createAbortController } from '../../utils/abortController.js'\nimport { saveGlobalConfig } from '../../utils/config.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport {\n  type CacheSafeParams,\n  getLastCacheSafeParams,\n} from '../../utils/forkedAgent.js'\nimport { getMessagesAfterCompactBoundary } from '../../utils/messages.js'\nimport type { ProcessUserInputContext } from '../../utils/processUserInput/processUserInput.js'\nimport { runSideQuestion } from '../../utils/sideQuestion.js'\nimport { asSystemPrompt } from '../../utils/systemPromptType.js'\n\ntype BtwComponentProps = {\n  question: string\n  context: ProcessUserInputContext\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}\n\nconst CHROME_ROWS = 5\nconst OUTER_CHROME_ROWS = 6\nconst SCROLL_LINES = 3\n\nfunction BtwSideQuestion({\n  question,\n  context,\n  onDone,\n}: BtwComponentProps): React.ReactNode {\n  const [response, setResponse] = useState<string | null>(null)\n  const [error, setError] = useState<string | null>(null)\n  const [frame, setFrame] = useState(0)\n  const scrollRef = useRef<ScrollBoxHandle>(null)\n  const { rows } = useModalOrTerminalSize(useTerminalSize())\n\n  // Animate spinner while loading\n  useInterval(() => setFrame(f => f + 1), response || error ? null : 80)\n\n  function handleKeyDown(e: KeyboardEvent): void {\n    if (\n      e.key === 'escape' ||\n      e.key === 'return' ||\n      e.key === ' ' ||\n      (e.ctrl && (e.key === 'c' || e.key === 'd'))\n    ) {\n      e.preventDefault()\n      onDone(undefined, { display: 'skip' })\n      return\n    }\n    if (e.key === 'up' || (e.ctrl && e.key === 'p')) {\n      e.preventDefault()\n      scrollRef.current?.scrollBy(-SCROLL_LINES)\n    }\n    if (e.key === 'down' || (e.ctrl && e.key === 'n')) {\n      e.preventDefault()\n      scrollRef.current?.scrollBy(SCROLL_LINES)\n    }\n  }\n\n  useEffect(() => {\n    const abortController = createAbortController()\n\n    async function fetchResponse(): Promise<void> {\n      try {\n        const cacheSafeParams = await buildCacheSafeParams(context)\n        const result = await runSideQuestion({ question, cacheSafeParams })\n\n        if (!abortController.signal.aborted) {\n          if (result.response) {\n            setResponse(result.response)\n          } else {\n            setError('No response received')\n          }\n        }\n      } catch (err) {\n        if (!abortController.signal.aborted) {\n          setError(errorMessage(err) || 'Failed to get response')\n        }\n      }\n    }\n\n    void fetchResponse()\n\n    return () => {\n      abortController.abort()\n    }\n  }, [question, context])\n\n  const maxContentHeight = Math.max(5, rows - CHROME_ROWS - OUTER_CHROME_ROWS)\n\n  return (\n    <Box\n      flexDirection=\"column\"\n      paddingLeft={2}\n      marginTop={1}\n      tabIndex={0}\n      autoFocus\n      onKeyDown={handleKeyDown}\n    >\n      <Box>\n        <Text color=\"warning\" bold>\n          /btw{' '}\n        </Text>\n        <Text dimColor>{question}</Text>\n      </Box>\n      <Box marginTop={1} marginLeft={2} maxHeight={maxContentHeight}>\n        <ScrollBox ref={scrollRef} flexDirection=\"column\" flexGrow={1}>\n          {error ? (\n            <Text color=\"error\">{error}</Text>\n          ) : response ? (\n            <Markdown>{response}</Markdown>\n          ) : (\n            <Box>\n              <SpinnerGlyph frame={frame} messageColor=\"warning\" />\n              <Text color=\"warning\">Answering...</Text>\n            </Box>\n          )}\n        </ScrollBox>\n      </Box>\n      {(response || error) && (\n        <Box marginTop={1}>\n          <Text dimColor>\n            {UP_ARROW}/{DOWN_ARROW} to scroll · Space, Enter, or Escape to\n            dismiss\n          </Text>\n        </Box>\n      )}\n    </Box>\n  )\n}\n\n/**\n * Build CacheSafeParams for the side question fork.\n *\n * The preferred source is getLastCacheSafeParams — the exact\n * systemPrompt/userContext/systemContext bytes the main thread sent on its\n * last request (captured in stopHooks). Reusing them guarantees a byte-\n * identical prefix and thus a prompt cache hit. We pair these with the\n * current toolUseContext (for thinkingConfig/tools) and current messages\n * (for up-to-date context).\n *\n * Fallback (first turn before stop hooks fire, or prompt-suggestion\n * disabled): rebuild from scratch. This may miss the cache if the main loop\n * applied buildEffectiveSystemPrompt extras (--agent, --system-prompt,\n * --append-system-prompt, coordinator mode).\n */\nfunction stripInProgressAssistantMessage(messages: Message[]): Message[] {\n  const last = messages.at(-1)\n  if (last?.type === 'assistant' && last.message.stop_reason === null) {\n    return messages.slice(0, -1)\n  }\n  return messages\n}\n\nasync function buildCacheSafeParams(\n  context: ProcessUserInputContext,\n): Promise<CacheSafeParams> {\n  const forkContextMessages = getMessagesAfterCompactBoundary(\n    stripInProgressAssistantMessage(context.messages),\n  )\n  const saved = getLastCacheSafeParams()\n  if (saved) {\n    return {\n      systemPrompt: saved.systemPrompt,\n      userContext: saved.userContext,\n      systemContext: saved.systemContext,\n      toolUseContext: context,\n      forkContextMessages,\n    }\n  }\n  const [rawSystemPrompt, userContext, systemContext] = await Promise.all([\n    getSystemPrompt(\n      context.options.tools,\n      context.options.mainLoopModel,\n      [],\n      context.options.mcpClients,\n    ),\n    getUserContext(),\n    getSystemContext(),\n  ])\n  return {\n    systemPrompt: asSystemPrompt(rawSystemPrompt),\n    userContext,\n    systemContext,\n    toolUseContext: context,\n    forkContextMessages,\n  }\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: ProcessUserInputContext,\n  args: string,\n): Promise<React.ReactNode> {\n  const question = args?.trim()\n\n  if (!question) {\n    onDone('Usage: /btw <your question>', { display: 'system' })\n    return null\n  }\n\n  saveGlobalConfig(current => ({\n    ...current,\n    btwUseCount: current.btwUseCount + 1,\n  }))\n\n  return (\n    <BtwSideQuestion question={question} context={context} onDone={onDone} />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/bughunter/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/chrome/chrome.tsx

@@ -0,0 +1,285 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useState } from 'react';
+import { type OptionWithDescription, Select } from '../../components/CustomSelect/select.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { Box, Text } from '../../ink.js';
+import { useAppState } from '../../state/AppState.js';
+import { isClaudeAISubscriber } from '../../utils/auth.js';
+import { openBrowser } from '../../utils/browser.js';
+import { CLAUDE_IN_CHROME_MCP_SERVER_NAME, openInChrome } from '../../utils/claudeInChrome/common.js';
+import { isChromeExtensionInstalled } from '../../utils/claudeInChrome/setup.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { env } from '../../utils/env.js';
+import { isRunningOnHomespace } from '../../utils/envUtils.js';
+const CHROME_EXTENSION_URL = 'https://claude.ai/chrome';
+const CHROME_PERMISSIONS_URL = 'https://clau.de/chrome/permissions';
+const CHROME_RECONNECT_URL = 'https://clau.de/chrome/reconnect';
+type MenuAction = 'install-extension' | 'reconnect' | 'manage-permissions' | 'toggle-default';
+type Props = {
+  onDone: (result?: string) => void;
+  isExtensionInstalled: boolean;
+  configEnabled: boolean | undefined;
+  isClaudeAISubscriber: boolean;
+  isWSL: boolean;
+};
+function ClaudeInChromeMenu(t0) {
+  const $ = _c(41);
+  const {
+    onDone,
+    isExtensionInstalled: installed,
+    configEnabled,
+    isClaudeAISubscriber,
+    isWSL
+  } = t0;
+  const mcpClients = useAppState(_temp);
+  const [selectKey, setSelectKey] = useState(0);
+  const [enabledByDefault, setEnabledByDefault] = useState(configEnabled ?? false);
+  const [showInstallHint, setShowInstallHint] = useState(false);
+  const [isExtensionInstalled, setIsExtensionInstalled] = useState(installed);
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = false && isRunningOnHomespace();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const isHomespace = t1;
+  let t2;
+  if ($[1] !== mcpClients) {
+    t2 = mcpClients.find(_temp2);
+    $[1] = mcpClients;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const chromeClient = t2;
+  const isConnected = chromeClient?.type === "connected";
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = function openUrl(url) {
+      if (isHomespace) {
+        openBrowser(url);
+      } else {
+        openInChrome(url);
+      }
+    };
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const openUrl = t3;
+  let t4;
+  if ($[4] !== enabledByDefault) {
+    t4 = function handleAction(action) {
+      bb22: switch (action) {
+        case "install-extension":
+          {
+            setSelectKey(_temp3);
+            setShowInstallHint(true);
+            openUrl(CHROME_EXTENSION_URL);
+            break bb22;
+          }
+        case "reconnect":
+          {
+            setSelectKey(_temp4);
+            isChromeExtensionInstalled().then(installed_0 => {
+              setIsExtensionInstalled(installed_0);
+              if (installed_0) {
+                setShowInstallHint(false);
+              }
+            });
+            openUrl(CHROME_RECONNECT_URL);
+            break bb22;
+          }
+        case "manage-permissions":
+          {
+            setSelectKey(_temp5);
+            openUrl(CHROME_PERMISSIONS_URL);
+            break bb22;
+          }
+        case "toggle-default":
+          {
+            const newValue = !enabledByDefault;
+            saveGlobalConfig(current => ({
+              ...current,
+              claudeInChromeDefaultEnabled: newValue
+            }));
+            setEnabledByDefault(newValue);
+          }
+      }
+    };
+    $[4] = enabledByDefault;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  const handleAction = t4;
+  let options;
+  if ($[6] !== enabledByDefault || $[7] !== isExtensionInstalled) {
+    options = [];
+    const requiresExtensionSuffix = isExtensionInstalled ? "" : " (requires extension)";
+    if (!isExtensionInstalled && !isHomespace) {
+      let t5;
+      if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+        t5 = {
+          label: "Install Chrome extension",
+          value: "install-extension"
+        };
+        $[9] = t5;
+      } else {
+        t5 = $[9];
+      }
+      options.push(t5);
+    }
+    let t5;
+    if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+      t5 = <Text>Manage permissions</Text>;
+      $[10] = t5;
+    } else {
+      t5 = $[10];
+    }
+    let t6;
+    if ($[11] !== requiresExtensionSuffix) {
+      t6 = {
+        label: <>{t5}<Text dimColor={true}>{requiresExtensionSuffix}</Text></>,
+        value: "manage-permissions"
+      };
+      $[11] = requiresExtensionSuffix;
+      $[12] = t6;
+    } else {
+      t6 = $[12];
+    }
+    let t7;
+    if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+      t7 = <Text>Reconnect extension</Text>;
+      $[13] = t7;
+    } else {
+      t7 = $[13];
+    }
+    let t8;
+    if ($[14] !== requiresExtensionSuffix) {
+      t8 = {
+        label: <>{t7}<Text dimColor={true}>{requiresExtensionSuffix}</Text></>,
+        value: "reconnect"
+      };
+      $[14] = requiresExtensionSuffix;
+      $[15] = t8;
+    } else {
+      t8 = $[15];
+    }
+    const t9 = `Enabled by default: ${enabledByDefault ? "Yes" : "No"}`;
+    let t10;
+    if ($[16] !== t9) {
+      t10 = {
+        label: t9,
+        value: "toggle-default"
+      };
+      $[16] = t9;
+      $[17] = t10;
+    } else {
+      t10 = $[17];
+    }
+    options.push(t6, t8, t10);
+    $[6] = enabledByDefault;
+    $[7] = isExtensionInstalled;
+    $[8] = options;
+  } else {
+    options = $[8];
+  }
+  const isDisabled = isWSL || true && !isClaudeAISubscriber;
+  let t5;
+  if ($[18] !== onDone) {
+    t5 = () => onDone();
+    $[18] = onDone;
+    $[19] = t5;
+  } else {
+    t5 = $[19];
+  }
+  let t6;
+  if ($[20] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = <Text>Claude in Chrome works with the Chrome extension to let you control your browser directly from Claude Code. Navigate websites, fill forms, capture screenshots, record GIFs, and debug with console logs and network requests.</Text>;
+    $[20] = t6;
+  } else {
+    t6 = $[20];
+  }
+  let t7;
+  if ($[21] !== isWSL) {
+    t7 = isWSL && <Text color="error">Claude in Chrome is not supported in WSL at this time.</Text>;
+    $[21] = isWSL;
+    $[22] = t7;
+  } else {
+    t7 = $[22];
+  }
+  let t8;
+  if ($[23] !== isClaudeAISubscriber) {
+    t8 = true && !isClaudeAISubscriber && <Text color="error">Claude in Chrome requires a claude.ai subscription.</Text>;
+    $[23] = isClaudeAISubscriber;
+    $[24] = t8;
+  } else {
+    t8 = $[24];
+  }
+  let t9;
+  if ($[25] !== handleAction || $[26] !== isConnected || $[27] !== isDisabled || $[28] !== isExtensionInstalled || $[29] !== options || $[30] !== selectKey || $[31] !== showInstallHint) {
+    t9 = !isDisabled && <>{!isHomespace && <Box flexDirection="column"><Text>Status:{" "}{isConnected ? <Text color="success">Enabled</Text> : <Text color="inactive">Disabled</Text>}</Text><Text>Extension:{" "}{isExtensionInstalled ? <Text color="success">Installed</Text> : <Text color="warning">Not detected</Text>}</Text></Box>}<Select key={selectKey} options={options} onChange={handleAction} hideIndexes={true} />{showInstallHint && <Text color="warning">Once installed, select {"\"Reconnect extension\""} to connect.</Text>}<Text><Text dimColor={true}>Usage: </Text><Text>claude --chrome</Text><Text dimColor={true}> or </Text><Text>claude --no-chrome</Text></Text><Text dimColor={true}>Site-level permissions are inherited from the Chrome extension. Manage permissions in the Chrome extension settings to control which sites Claude can browse, click, and type on.</Text></>;
+    $[25] = handleAction;
+    $[26] = isConnected;
+    $[27] = isDisabled;
+    $[28] = isExtensionInstalled;
+    $[29] = options;
+    $[30] = selectKey;
+    $[31] = showInstallHint;
+    $[32] = t9;
+  } else {
+    t9 = $[32];
+  }
+  let t10;
+  if ($[33] === Symbol.for("react.memo_cache_sentinel")) {
+    t10 = <Text dimColor={true}>Learn more: https://code.claude.com/docs/en/chrome</Text>;
+    $[33] = t10;
+  } else {
+    t10 = $[33];
+  }
+  let t11;
+  if ($[34] !== t7 || $[35] !== t8 || $[36] !== t9) {
+    t11 = <Box flexDirection="column" gap={1}>{t6}{t7}{t8}{t9}{t10}</Box>;
+    $[34] = t7;
+    $[35] = t8;
+    $[36] = t9;
+    $[37] = t11;
+  } else {
+    t11 = $[37];
+  }
+  let t12;
+  if ($[38] !== t11 || $[39] !== t5) {
+    t12 = <Dialog title="Claude in Chrome (Beta)" onCancel={t5} color="chromeYellow">{t11}</Dialog>;
+    $[38] = t11;
+    $[39] = t5;
+    $[40] = t12;
+  } else {
+    t12 = $[40];
+  }
+  return t12;
+}
+function _temp5(k) {
+  return k + 1;
+}
+function _temp4(k_0) {
+  return k_0 + 1;
+}
+function _temp3(k_1) {
+  return k_1 + 1;
+}
+function _temp2(c) {
+  return c.name === CLAUDE_IN_CHROME_MCP_SERVER_NAME;
+}
+function _temp(s) {
+  return s.mcp.clients;
+}
+export const call = async function (onDone: (result?: string) => void): Promise<React.ReactNode> {
+  const isExtensionInstalled = await isChromeExtensionInstalled();
+  const config = getGlobalConfig();
+  const isSubscriber = isClaudeAISubscriber();
+  const isWSL = env.isWslEnvironment();
+  return <ClaudeInChromeMenu onDone={onDone} isExtensionInstalled={isExtensionInstalled} configEnabled={config.claudeInChromeDefaultEnabled} isClaudeAISubscriber={isSubscriber} isWSL={isWSL} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","OptionWithDescription","Select","Dialog","Box","Text","useAppState","isClaudeAISubscriber","openBrowser","CLAUDE_IN_CHROME_MCP_SERVER_NAME","openInChrome","isChromeExtensionInstalled","getGlobalConfig","saveGlobalConfig","env","isRunningOnHomespace","CHROME_EXTENSION_URL","CHROME_PERMISSIONS_URL","CHROME_RECONNECT_URL","MenuAction","Props","onDone","result","isExtensionInstalled","configEnabled","isWSL","ClaudeInChromeMenu","t0","$","_c","installed","mcpClients","_temp","selectKey","setSelectKey","enabledByDefault","setEnabledByDefault","showInstallHint","setShowInstallHint","setIsExtensionInstalled","t1","Symbol","for","isHomespace","t2","find","_temp2","chromeClient","isConnected","type","t3","openUrl","url","t4","handleAction","action","bb22","_temp3","_temp4","then","installed_0","_temp5","newValue","current","claudeInChromeDefaultEnabled","options","requiresExtensionSuffix","t5","label","value","push","t6","t7","t8","t9","t10","isDisabled","t11","t12","k","k_0","k_1","c","name","s","mcp","clients","call","Promise","ReactNode","config","isSubscriber","isWslEnvironment"],"sources":["chrome.tsx"],"sourcesContent":["import React, { useState } from 'react'\nimport {\n  type OptionWithDescription,\n  Select,\n} from '../../components/CustomSelect/select.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { Box, Text } from '../../ink.js'\nimport { useAppState } from '../../state/AppState.js'\nimport { isClaudeAISubscriber } from '../../utils/auth.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport {\n  CLAUDE_IN_CHROME_MCP_SERVER_NAME,\n  openInChrome,\n} from '../../utils/claudeInChrome/common.js'\nimport { isChromeExtensionInstalled } from '../../utils/claudeInChrome/setup.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport { env } from '../../utils/env.js'\nimport { isRunningOnHomespace } from '../../utils/envUtils.js'\n\nconst CHROME_EXTENSION_URL = 'https://claude.ai/chrome'\nconst CHROME_PERMISSIONS_URL = 'https://clau.de/chrome/permissions'\nconst CHROME_RECONNECT_URL = 'https://clau.de/chrome/reconnect'\n\ntype MenuAction =\n  | 'install-extension'\n  | 'reconnect'\n  | 'manage-permissions'\n  | 'toggle-default'\n\ntype Props = {\n  onDone: (result?: string) => void\n  isExtensionInstalled: boolean\n  configEnabled: boolean | undefined\n  isClaudeAISubscriber: boolean\n  isWSL: boolean\n}\n\nfunction ClaudeInChromeMenu({\n  onDone,\n  isExtensionInstalled: installed,\n  configEnabled,\n  isClaudeAISubscriber,\n  isWSL,\n}: Props): React.ReactNode {\n  const mcpClients = useAppState(s => s.mcp.clients)\n  const [selectKey, setSelectKey] = useState(0)\n  const [enabledByDefault, setEnabledByDefault] = useState(\n    configEnabled ?? false,\n  )\n  const [showInstallHint, setShowInstallHint] = useState(false)\n  const [isExtensionInstalled, setIsExtensionInstalled] = useState(installed)\n\n  const isHomespace = \"external\" === 'ant' && isRunningOnHomespace()\n\n  const chromeClient = mcpClients.find(\n    c => c.name === CLAUDE_IN_CHROME_MCP_SERVER_NAME,\n  )\n  const isConnected = chromeClient?.type === 'connected'\n\n  function openUrl(url: string): void {\n    if (isHomespace) {\n      void openBrowser(url)\n    } else {\n      void openInChrome(url)\n    }\n  }\n\n  function handleAction(action: MenuAction): void {\n    switch (action) {\n      case 'install-extension':\n        setSelectKey(k => k + 1)\n        setShowInstallHint(true)\n        openUrl(CHROME_EXTENSION_URL)\n        break\n      case 'reconnect':\n        setSelectKey(k => k + 1)\n        void isChromeExtensionInstalled().then(installed => {\n          setIsExtensionInstalled(installed)\n          if (installed) {\n            setShowInstallHint(false)\n          }\n        })\n        openUrl(CHROME_RECONNECT_URL)\n        break\n      case 'manage-permissions':\n        setSelectKey(k => k + 1)\n        openUrl(CHROME_PERMISSIONS_URL)\n        break\n      case 'toggle-default': {\n        const newValue = !enabledByDefault\n        saveGlobalConfig(current => ({\n          ...current,\n          claudeInChromeDefaultEnabled: newValue,\n        }))\n        setEnabledByDefault(newValue)\n        break\n      }\n    }\n  }\n\n  const options: OptionWithDescription<MenuAction>[] = []\n  const requiresExtensionSuffix = isExtensionInstalled\n    ? ''\n    : ' (requires extension)'\n\n  if (!isExtensionInstalled && !isHomespace) {\n    options.push({\n      label: 'Install Chrome extension',\n      value: 'install-extension',\n    })\n  }\n\n  options.push(\n    {\n      label: (\n        <>\n          <Text>Manage permissions</Text>\n          <Text dimColor>{requiresExtensionSuffix}</Text>\n        </>\n      ),\n      value: 'manage-permissions',\n    },\n    {\n      label: (\n        <>\n          <Text>Reconnect extension</Text>\n          <Text dimColor>{requiresExtensionSuffix}</Text>\n        </>\n      ),\n      value: 'reconnect',\n    },\n    {\n      label: `Enabled by default: ${enabledByDefault ? 'Yes' : 'No'}`,\n      value: 'toggle-default',\n    },\n  )\n\n  const isDisabled =\n    isWSL || (\"external\" !== 'ant' && !isClaudeAISubscriber)\n\n  return (\n    <Dialog\n      title=\"Claude in Chrome (Beta)\"\n      onCancel={() => onDone()}\n      color=\"chromeYellow\"\n    >\n      <Box flexDirection=\"column\" gap={1}>\n        <Text>\n          Claude in Chrome works with the Chrome extension to let you control\n          your browser directly from Claude Code. Navigate websites, fill forms,\n          capture screenshots, record GIFs, and debug with console logs and\n          network requests.\n        </Text>\n\n        {isWSL && (\n          <Text color=\"error\">\n            Claude in Chrome is not supported in WSL at this time.\n          </Text>\n        )}\n\n\n        {\"external\" !== 'ant' && !isClaudeAISubscriber && (\n          <Text color=\"error\">\n            Claude in Chrome requires a claude.ai subscription.\n          </Text>\n        )}\n\n        {!isDisabled && (\n          <>\n            {!isHomespace && (\n              <Box flexDirection=\"column\">\n                <Text>\n                  Status:{' '}\n                  {isConnected ? (\n                    <Text color=\"success\">Enabled</Text>\n                  ) : (\n                    <Text color=\"inactive\">Disabled</Text>\n                  )}\n                </Text>\n                <Text>\n                  Extension:{' '}\n                  {isExtensionInstalled ? (\n                    <Text color=\"success\">Installed</Text>\n                  ) : (\n                    <Text color=\"warning\">Not detected</Text>\n                  )}\n                </Text>\n              </Box>\n            )}\n            <Select\n              key={selectKey}\n              options={options}\n              onChange={handleAction}\n              hideIndexes\n            />\n\n            {showInstallHint && (\n              <Text color=\"warning\">\n                Once installed, select {'\"Reconnect extension\"'} to connect.\n              </Text>\n            )}\n\n            <Text>\n              <Text dimColor>Usage: </Text>\n              <Text>claude --chrome</Text>\n              <Text dimColor> or </Text>\n              <Text>claude --no-chrome</Text>\n            </Text>\n\n            <Text dimColor>\n              Site-level permissions are inherited from the Chrome extension.\n              Manage permissions in the Chrome extension settings to control\n              which sites Claude can browse, click, and type on.\n            </Text>\n          </>\n        )}\n        <Text dimColor>Learn more: https://code.claude.com/docs/en/chrome</Text>\n      </Box>\n    </Dialog>\n  )\n}\n\nexport const call = async function (\n  onDone: (result?: string) => void,\n): Promise<React.ReactNode> {\n  const isExtensionInstalled = await isChromeExtensionInstalled()\n  const config = getGlobalConfig()\n  const isSubscriber = isClaudeAISubscriber()\n  const isWSL = env.isWslEnvironment()\n\n  return (\n    <ClaudeInChromeMenu\n      onDone={onDone}\n      isExtensionInstalled={isExtensionInstalled}\n      configEnabled={config.claudeInChromeDefaultEnabled}\n      isClaudeAISubscriber={isSubscriber}\n      isWSL={isWSL}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/clear/caches.ts

@@ -0,0 +1,144 @@
+/**
+ * Session cache clearing utilities.
+ * This module is imported at startup by main.tsx, so keep imports minimal.
+ */
+import { feature } from 'bun:bundle'
+import {
+  clearInvokedSkills,
+  setLastEmittedDate,
+} from '../../bootstrap/state.js'
+import { clearCommandsCache } from '../../commands.js'
+import { getSessionStartDate } from '../../constants/common.js'
+import {
+  getGitStatus,
+  getSystemContext,
+  getUserContext,
+  setSystemPromptInjection,
+} from '../../context.js'
+import { clearFileSuggestionCaches } from '../../hooks/fileSuggestions.js'
+import { clearAllPendingCallbacks } from '../../hooks/useSwarmPermissionPoller.js'
+import { clearAllDumpState } from '../../services/api/dumpPrompts.js'
+import { resetPromptCacheBreakDetection } from '../../services/api/promptCacheBreakDetection.js'
+import { clearAllSessions } from '../../services/api/sessionIngress.js'
+import { runPostCompactCleanup } from '../../services/compact/postCompactCleanup.js'
+import { resetAllLSPDiagnosticState } from '../../services/lsp/LSPDiagnosticRegistry.js'
+import { clearTrackedMagicDocs } from '../../services/MagicDocs/magicDocs.js'
+import { clearDynamicSkills } from '../../skills/loadSkillsDir.js'
+import { resetSentSkillNames } from '../../utils/attachments.js'
+import { clearCommandPrefixCaches } from '../../utils/bash/commands.js'
+import { resetGetMemoryFilesCache } from '../../utils/claudemd.js'
+import { clearRepositoryCaches } from '../../utils/detectRepository.js'
+import { clearResolveGitDirCache } from '../../utils/git/gitFilesystem.js'
+import { clearStoredImagePaths } from '../../utils/imageStore.js'
+import { clearSessionEnvVars } from '../../utils/sessionEnvVars.js'
+
+/**
+ * Clear all session-related caches.
+ * Call this when resuming a session to ensure fresh file/skill discovery.
+ * This is a subset of what clearConversation does - it only clears caches
+ * without affecting messages, session ID, or triggering hooks.
+ *
+ * @param preservedAgentIds - Agent IDs whose per-agent state should survive
+ *   the clear (e.g., background tasks preserved across /clear). When non-empty,
+ *   agentId-keyed state (invoked skills) is selectively cleared and requestId-keyed
+ *   state (pending permission callbacks, dump state, cache-break tracking) is left
+ *   intact since it cannot be safely scoped to the main session.
+ */
+export function clearSessionCaches(
+  preservedAgentIds: ReadonlySet<string> = new Set(),
+): void {
+  const hasPreserved = preservedAgentIds.size > 0
+  // Clear context caches
+  getUserContext.cache.clear?.()
+  getSystemContext.cache.clear?.()
+  getGitStatus.cache.clear?.()
+  getSessionStartDate.cache.clear?.()
+  // Clear file suggestion caches (for @ mentions)
+  clearFileSuggestionCaches()
+
+  // Clear commands/skills cache
+  clearCommandsCache()
+
+  // Clear prompt cache break detection state
+  if (!hasPreserved) resetPromptCacheBreakDetection()
+
+  // Clear system prompt injection (cache breaker)
+  setSystemPromptInjection(null)
+
+  // Clear last emitted date so it's re-detected on next turn
+  setLastEmittedDate(null)
+
+  // Run post-compaction cleanup (clears system prompt sections, microcompact tracking,
+  // classifier approvals, speculative checks, and — for main-thread compacts — memory
+  // files cache with load_reason 'compact').
+  runPostCompactCleanup()
+  // Reset sent skill names so the skill listing is re-sent after /clear.
+  // runPostCompactCleanup intentionally does NOT reset this (post-compact
+  // re-injection costs ~4K tokens), but /clear wipes messages entirely so
+  // the model needs the full listing again.
+  resetSentSkillNames()
+  // Override the memory cache reset with 'session_start': clearSessionCaches is called
+  // from /clear and --resume/--continue, which are NOT compaction events. Without this,
+  // the InstructionsLoaded hook would fire with load_reason 'compact' instead of
+  // 'session_start' on the next getMemoryFiles() call.
+  resetGetMemoryFilesCache('session_start')
+
+  // Clear stored image paths cache
+  clearStoredImagePaths()
+
+  // Clear all session ingress caches (lastUuidMap, sequentialAppendBySession)
+  clearAllSessions()
+  // Clear swarm permission pending callbacks
+  if (!hasPreserved) clearAllPendingCallbacks()
+
+  // Clear tungsten session usage tracking
+  if (process.env.USER_TYPE === 'ant') {
+    void import('../../tools/TungstenTool/TungstenTool.js').then(
+      ({ clearSessionsWithTungstenUsage, resetInitializationState }) => {
+        clearSessionsWithTungstenUsage()
+        resetInitializationState()
+      },
+    )
+  }
+  // Clear attribution caches (file content cache, pending bash states)
+  // Dynamic import to preserve dead code elimination for COMMIT_ATTRIBUTION feature flag
+  if (feature('COMMIT_ATTRIBUTION')) {
+    void import('../../utils/attributionHooks.js').then(
+      ({ clearAttributionCaches }) => clearAttributionCaches(),
+    )
+  }
+  // Clear repository detection caches
+  clearRepositoryCaches()
+  // Clear bash command prefix caches (Haiku-extracted prefixes)
+  clearCommandPrefixCaches()
+  // Clear dump prompts state
+  if (!hasPreserved) clearAllDumpState()
+  // Clear invoked skills cache (each entry holds full skill file content)
+  clearInvokedSkills(preservedAgentIds)
+  // Clear git dir resolution cache
+  clearResolveGitDirCache()
+  // Clear dynamic skills (loaded from skill directories)
+  clearDynamicSkills()
+  // Clear LSP diagnostic tracking state
+  resetAllLSPDiagnosticState()
+  // Clear tracked magic docs
+  clearTrackedMagicDocs()
+  // Clear session environment variables
+  clearSessionEnvVars()
+  // Clear WebFetch URL cache (up to 50MB of cached page content)
+  void import('../../tools/WebFetchTool/utils.js').then(
+    ({ clearWebFetchCache }) => clearWebFetchCache(),
+  )
+  // Clear ToolSearch description cache (full tool prompts, ~500KB for 50 MCP tools)
+  void import('../../tools/ToolSearchTool/ToolSearchTool.js').then(
+    ({ clearToolSearchDescriptionCache }) => clearToolSearchDescriptionCache(),
+  )
+  // Clear agent definitions cache (accumulates per-cwd via EnterWorktreeTool)
+  void import('../../tools/AgentTool/loadAgentsDir.js').then(
+    ({ clearAgentDefinitionsCache }) => clearAgentDefinitionsCache(),
+  )
+  // Clear SkillTool prompt cache (accumulates per project root)
+  void import('../../tools/SkillTool/prompt.js').then(({ clearPromptCache }) =>
+    clearPromptCache(),
+  )
+}

src/commands/clear/conversation.ts

@@ -0,0 +1,251 @@
+/**
+ * Conversation clearing utility.
+ * This module has heavier dependencies and should be lazy-loaded when possible.
+ */
+import { feature } from 'bun:bundle'
+import { randomUUID, type UUID } from 'crypto'
+import {
+  getLastMainRequestId,
+  getOriginalCwd,
+  getSessionId,
+  regenerateSessionId,
+} from '../../bootstrap/state.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import type { AppState } from '../../state/AppState.js'
+import { isInProcessTeammateTask } from '../../tasks/InProcessTeammateTask/types.js'
+import {
+  isLocalAgentTask,
+  type LocalAgentTaskState,
+} from '../../tasks/LocalAgentTask/LocalAgentTask.js'
+import { isLocalShellTask } from '../../tasks/LocalShellTask/guards.js'
+import { asAgentId } from '../../types/ids.js'
+import type { Message } from '../../types/message.js'
+import { createEmptyAttributionState } from '../../utils/commitAttribution.js'
+import type { FileStateCache } from '../../utils/fileStateCache.js'
+import {
+  executeSessionEndHooks,
+  getSessionEndHookTimeoutMs,
+} from '../../utils/hooks.js'
+import { logError } from '../../utils/log.js'
+import { clearAllPlanSlugs } from '../../utils/plans.js'
+import { setCwd } from '../../utils/Shell.js'
+import { processSessionStartHooks } from '../../utils/sessionStart.js'
+import {
+  clearSessionMetadata,
+  getAgentTranscriptPath,
+  resetSessionFilePointer,
+  saveWorktreeState,
+} from '../../utils/sessionStorage.js'
+import {
+  evictTaskOutput,
+  initTaskOutputAsSymlink,
+} from '../../utils/task/diskOutput.js'
+import { getCurrentWorktreeSession } from '../../utils/worktree.js'
+import { clearSessionCaches } from './caches.js'
+
+export async function clearConversation({
+  setMessages,
+  readFileState,
+  discoveredSkillNames,
+  loadedNestedMemoryPaths,
+  getAppState,
+  setAppState,
+  setConversationId,
+}: {
+  setMessages: (updater: (prev: Message[]) => Message[]) => void
+  readFileState: FileStateCache
+  discoveredSkillNames?: Set<string>
+  loadedNestedMemoryPaths?: Set<string>
+  getAppState?: () => AppState
+  setAppState?: (f: (prev: AppState) => AppState) => void
+  setConversationId?: (id: UUID) => void
+}): Promise<void> {
+  // Execute SessionEnd hooks before clearing (bounded by
+  // CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS, default 1.5s)
+  const sessionEndTimeoutMs = getSessionEndHookTimeoutMs()
+  await executeSessionEndHooks('clear', {
+    getAppState,
+    setAppState,
+    signal: AbortSignal.timeout(sessionEndTimeoutMs),
+    timeoutMs: sessionEndTimeoutMs,
+  })
+
+  // Signal to inference that this conversation's cache can be evicted.
+  const lastRequestId = getLastMainRequestId()
+  if (lastRequestId) {
+    logEvent('tengu_cache_eviction_hint', {
+      scope:
+        'conversation_clear' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      last_request_id:
+        lastRequestId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+  }
+
+  // Compute preserved tasks up front so their per-agent state survives the
+  // cache wipe below. A task is preserved unless it explicitly has
+  // isBackgrounded === false. Main-session tasks (Ctrl+B) are preserved —
+  // they write to an isolated per-task transcript and run under an agent
+  // context, so they're safe across session ID regeneration. See
+  // LocalMainSessionTask.ts startBackgroundSession.
+  const preservedAgentIds = new Set<string>()
+  const preservedLocalAgents: LocalAgentTaskState[] = []
+  const shouldKillTask = (task: AppState['tasks'][string]): boolean =>
+    'isBackgrounded' in task && task.isBackgrounded === false
+  if (getAppState) {
+    for (const task of Object.values(getAppState().tasks)) {
+      if (shouldKillTask(task)) continue
+      if (isLocalAgentTask(task)) {
+        preservedAgentIds.add(task.agentId)
+        preservedLocalAgents.push(task)
+      } else if (isInProcessTeammateTask(task)) {
+        preservedAgentIds.add(task.identity.agentId)
+      }
+    }
+  }
+
+  setMessages(() => [])
+
+  // Clear context-blocked flag so proactive ticks resume after /clear
+  if (feature('PROACTIVE') || feature('KAIROS')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { setContextBlocked } = require('../../proactive/index.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    setContextBlocked(false)
+  }
+
+  // Force logo re-render by updating conversationId
+  if (setConversationId) {
+    setConversationId(randomUUID())
+  }
+
+  // Clear all session-related caches. Per-agent state for preserved background
+  // tasks (invoked skills, pending permission callbacks, dump state, cache-break
+  // tracking) is retained so those agents keep functioning.
+  clearSessionCaches(preservedAgentIds)
+
+  setCwd(getOriginalCwd())
+  readFileState.clear()
+  discoveredSkillNames?.clear()
+  loadedNestedMemoryPaths?.clear()
+
+  // Clean out necessary items from App State
+  if (setAppState) {
+    setAppState(prev => {
+      // Partition tasks using the same predicate computed above:
+      // kill+remove foreground tasks, preserve everything else.
+      const nextTasks: AppState['tasks'] = {}
+      for (const [taskId, task] of Object.entries(prev.tasks)) {
+        if (!shouldKillTask(task)) {
+          nextTasks[taskId] = task
+          continue
+        }
+        // Foreground task: kill it and drop from state
+        try {
+          if (task.status === 'running') {
+            if (isLocalShellTask(task)) {
+              task.shellCommand?.kill()
+              task.shellCommand?.cleanup()
+              if (task.cleanupTimeoutId) {
+                clearTimeout(task.cleanupTimeoutId)
+              }
+            }
+            if ('abortController' in task) {
+              task.abortController?.abort()
+            }
+            if ('unregisterCleanup' in task) {
+              task.unregisterCleanup?.()
+            }
+          }
+        } catch (error) {
+          logError(error)
+        }
+        void evictTaskOutput(taskId)
+      }
+
+      return {
+        ...prev,
+        tasks: nextTasks,
+        attribution: createEmptyAttributionState(),
+        // Clear standalone agent context (name/color set by /rename, /color)
+        // so the new session doesn't display the old session's identity badge
+        standaloneAgentContext: undefined,
+        fileHistory: {
+          snapshots: [],
+          trackedFiles: new Set(),
+          snapshotSequence: 0,
+        },
+        // Reset MCP state to default to trigger re-initialization.
+        // Preserve pluginReconnectKey so /clear doesn't cause a no-op
+        // (it's only bumped by /reload-plugins).
+        mcp: {
+          clients: [],
+          tools: [],
+          commands: [],
+          resources: {},
+          pluginReconnectKey: prev.mcp.pluginReconnectKey,
+        },
+      }
+    })
+  }
+
+  // Clear plan slug cache so a new plan file is used after /clear
+  clearAllPlanSlugs()
+
+  // Clear cached session metadata (title, tag, agent name/color)
+  // so the new session doesn't inherit the previous session's identity
+  clearSessionMetadata()
+
+  // Generate new session ID to provide fresh state
+  // Set the old session as parent for analytics lineage tracking
+  regenerateSessionId({ setCurrentAsParent: true })
+  // Update the environment variable so subprocesses use the new session ID
+  if (process.env.USER_TYPE === 'ant' && process.env.CLAUDE_CODE_SESSION_ID) {
+    process.env.CLAUDE_CODE_SESSION_ID = getSessionId()
+  }
+  await resetSessionFilePointer()
+
+  // Preserved local_agent tasks had their TaskOutput symlink baked against the
+  // old session ID at spawn time, but post-clear transcript writes land under
+  // the new session directory (appendEntry re-reads getSessionId()). Re-point
+  // the symlinks so TaskOutput reads the live file instead of a frozen pre-clear
+  // snapshot. Only re-point running tasks — finished tasks will never write
+  // again, so re-pointing would replace a valid symlink with a dangling one.
+  // Main-session tasks use the same per-agent path (they write via
+  // recordSidechainTranscript to getAgentTranscriptPath), so no special case.
+  for (const task of preservedLocalAgents) {
+    if (task.status !== 'running') continue
+    void initTaskOutputAsSymlink(
+      task.id,
+      getAgentTranscriptPath(asAgentId(task.agentId)),
+    )
+  }
+
+  // Re-persist mode and worktree state after the clear so future --resume
+  // knows what the new post-clear session was in. clearSessionMetadata
+  // wiped both from the cache, but the process is still in the same mode
+  // and (if applicable) the same worktree directory.
+  if (feature('COORDINATOR_MODE')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { saveMode } = require('../../utils/sessionStorage.js')
+    const {
+      isCoordinatorMode,
+    } = require('../../coordinator/coordinatorMode.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    saveMode(isCoordinatorMode() ? 'coordinator' : 'normal')
+  }
+  const worktreeSession = getCurrentWorktreeSession()
+  if (worktreeSession) {
+    saveWorktreeState(worktreeSession)
+  }
+
+  // Execute SessionStart hooks after clearing
+  const hookMessages = await processSessionStartHooks('clear')
+
+  // Update messages with hook results
+  if (hookMessages.length > 0) {
+    setMessages(() => hookMessages)
+  }
+}

src/commands/color/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Color command - minimal metadata only.
+ * Implementation is lazy-loaded from color.ts to reduce startup time.
+ */
+import type { Command } from '../../commands.js'
+
+const color = {
+  type: 'local-jsx',
+  name: 'color',
+  description: 'Set the prompt bar color for this session',
+  immediate: true,
+  argumentHint: '<color|default>',
+  load: () => import('./color.js'),
+} satisfies Command
+
+export default color

src/commands/compact/compact.ts

@@ -0,0 +1,287 @@
+import { feature } from 'bun:bundle'
+import chalk from 'chalk'
+import { markPostCompaction } from 'src/bootstrap/state.js'
+import { getSystemPrompt } from '../../constants/prompts.js'
+import { getSystemContext, getUserContext } from '../../context.js'
+import { getShortcutDisplay } from '../../keybindings/shortcutFormat.js'
+import { notifyCompaction } from '../../services/api/promptCacheBreakDetection.js'
+import {
+  type CompactionResult,
+  compactConversation,
+  ERROR_MESSAGE_INCOMPLETE_RESPONSE,
+  ERROR_MESSAGE_NOT_ENOUGH_MESSAGES,
+  ERROR_MESSAGE_USER_ABORT,
+  mergeHookInstructions,
+} from '../../services/compact/compact.js'
+import { suppressCompactWarning } from '../../services/compact/compactWarningState.js'
+import { microcompactMessages } from '../../services/compact/microCompact.js'
+import { runPostCompactCleanup } from '../../services/compact/postCompactCleanup.js'
+import { trySessionMemoryCompaction } from '../../services/compact/sessionMemoryCompact.js'
+import { setLastSummarizedMessageId } from '../../services/SessionMemory/sessionMemoryUtils.js'
+import type { ToolUseContext } from '../../Tool.js'
+import type { LocalCommandCall } from '../../types/command.js'
+import type { Message } from '../../types/message.js'
+import { hasExactErrorMessage } from '../../utils/errors.js'
+import { executePreCompactHooks } from '../../utils/hooks.js'
+import { logError } from '../../utils/log.js'
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js'
+import { getUpgradeMessage } from '../../utils/model/contextWindowUpgradeCheck.js'
+import {
+  buildEffectiveSystemPrompt,
+  type SystemPrompt,
+} from '../../utils/systemPrompt.js'
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const reactiveCompact = feature('REACTIVE_COMPACT')
+  ? (require('../../services/compact/reactiveCompact.js') as typeof import('../../services/compact/reactiveCompact.js'))
+  : null
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+export const call: LocalCommandCall = async (args, context) => {
+  const { abortController } = context
+  let { messages } = context
+
+  // REPL keeps snipped messages for UI scrollback — project so the compact
+  // model doesn't summarize content that was intentionally removed.
+  messages = getMessagesAfterCompactBoundary(messages)
+
+  if (messages.length === 0) {
+    throw new Error('No messages to compact')
+  }
+
+  const customInstructions = args.trim()
+
+  try {
+    // Try session memory compaction first if no custom instructions
+    // (session memory compaction doesn't support custom instructions)
+    if (!customInstructions) {
+      const sessionMemoryResult = await trySessionMemoryCompaction(
+        messages,
+        context.agentId,
+      )
+      if (sessionMemoryResult) {
+        getUserContext.cache.clear?.()
+        runPostCompactCleanup()
+        // Reset cache read baseline so the post-compact drop isn't flagged
+        // as a break. compactConversation does this internally; SM-compact doesn't.
+        if (feature('PROMPT_CACHE_BREAK_DETECTION')) {
+          notifyCompaction(
+            context.options.querySource ?? 'compact',
+            context.agentId,
+          )
+        }
+        markPostCompaction()
+        // Suppress warning immediately after successful compaction
+        suppressCompactWarning()
+
+        return {
+          type: 'compact',
+          compactionResult: sessionMemoryResult,
+          displayText: buildDisplayText(context),
+        }
+      }
+    }
+
+    // Reactive-only mode: route /compact through the reactive path.
+    // Checked after session-memory (that path is cheap and orthogonal).
+    if (reactiveCompact?.isReactiveOnlyMode()) {
+      return await compactViaReactive(
+        messages,
+        context,
+        customInstructions,
+        reactiveCompact,
+      )
+    }
+
+    // Fall back to traditional compaction
+    // Run microcompact first to reduce tokens before summarization
+    const microcompactResult = await microcompactMessages(messages, context)
+    const messagesForCompact = microcompactResult.messages
+
+    const result = await compactConversation(
+      messagesForCompact,
+      context,
+      await getCacheSharingParams(context, messagesForCompact),
+      false,
+      customInstructions,
+      false,
+    )
+
+    // Reset lastSummarizedMessageId since legacy compaction replaces all messages
+    // and the old message UUID will no longer exist in the new messages array
+    setLastSummarizedMessageId(undefined)
+
+    // Suppress the "Context left until auto-compact" warning after successful compaction
+    suppressCompactWarning()
+
+    getUserContext.cache.clear?.()
+    runPostCompactCleanup()
+
+    return {
+      type: 'compact',
+      compactionResult: result,
+      displayText: buildDisplayText(context, result.userDisplayMessage),
+    }
+  } catch (error) {
+    if (abortController.signal.aborted) {
+      throw new Error('Compaction canceled.')
+    } else if (hasExactErrorMessage(error, ERROR_MESSAGE_NOT_ENOUGH_MESSAGES)) {
+      throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES)
+    } else if (hasExactErrorMessage(error, ERROR_MESSAGE_INCOMPLETE_RESPONSE)) {
+      throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE)
+    } else {
+      logError(error)
+      throw new Error(`Error during compaction: ${error}`)
+    }
+  }
+}
+
+async function compactViaReactive(
+  messages: Message[],
+  context: ToolUseContext,
+  customInstructions: string,
+  reactive: NonNullable<typeof reactiveCompact>,
+): Promise<{
+  type: 'compact'
+  compactionResult: CompactionResult
+  displayText: string
+}> {
+  context.onCompactProgress?.({
+    type: 'hooks_start',
+    hookType: 'pre_compact',
+  })
+  context.setSDKStatus?.('compacting')
+
+  try {
+    // Hooks and cache-param build are independent — run concurrently.
+    // getCacheSharingParams walks all tools to build the system prompt;
+    // pre-compact hooks spawn subprocesses. Neither depends on the other.
+    const [hookResult, cacheSafeParams] = await Promise.all([
+      executePreCompactHooks(
+        { trigger: 'manual', customInstructions: customInstructions || null },
+        context.abortController.signal,
+      ),
+      getCacheSharingParams(context, messages),
+    ])
+    const mergedInstructions = mergeHookInstructions(
+      customInstructions,
+      hookResult.newCustomInstructions,
+    )
+
+    context.setStreamMode?.('requesting')
+    context.setResponseLength?.(() => 0)
+    context.onCompactProgress?.({ type: 'compact_start' })
+
+    const outcome = await reactive.reactiveCompactOnPromptTooLong(
+      messages,
+      cacheSafeParams,
+      { customInstructions: mergedInstructions, trigger: 'manual' },
+    )
+
+    if (!outcome.ok) {
+      // The outer catch in `call` translates these: aborted → "Compaction
+      // canceled." (via abortController.signal.aborted check), NOT_ENOUGH →
+      // re-thrown as-is, everything else → "Error during compaction: …".
+      switch (outcome.reason) {
+        case 'too_few_groups':
+          throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES)
+        case 'aborted':
+          throw new Error(ERROR_MESSAGE_USER_ABORT)
+        case 'exhausted':
+        case 'error':
+        case 'media_unstrippable':
+          throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE)
+      }
+    }
+
+    // Mirrors the post-success cleanup in tryReactiveCompact, minus
+    // resetMicrocompactState — processSlashCommand calls that for all
+    // type:'compact' results.
+    setLastSummarizedMessageId(undefined)
+    runPostCompactCleanup()
+    suppressCompactWarning()
+    getUserContext.cache.clear?.()
+
+    // reactiveCompactOnPromptTooLong runs PostCompact hooks but not PreCompact
+    // — both callers (here and tryReactiveCompact) run PreCompact outside so
+    // they can merge its userDisplayMessage with PostCompact's here. This
+    // caller additionally runs it concurrently with getCacheSharingParams.
+    const combinedMessage =
+      [hookResult.userDisplayMessage, outcome.result.userDisplayMessage]
+        .filter(Boolean)
+        .join('\n') || undefined
+
+    return {
+      type: 'compact',
+      compactionResult: {
+        ...outcome.result,
+        userDisplayMessage: combinedMessage,
+      },
+      displayText: buildDisplayText(context, combinedMessage),
+    }
+  } finally {
+    context.setStreamMode?.('requesting')
+    context.setResponseLength?.(() => 0)
+    context.onCompactProgress?.({ type: 'compact_end' })
+    context.setSDKStatus?.(null)
+  }
+}
+
+function buildDisplayText(
+  context: ToolUseContext,
+  userDisplayMessage?: string,
+): string {
+  const upgradeMessage = getUpgradeMessage('tip')
+  const expandShortcut = getShortcutDisplay(
+    'app:toggleTranscript',
+    'Global',
+    'ctrl+o',
+  )
+  const dimmed = [
+    ...(context.options.verbose
+      ? []
+      : [`(${expandShortcut} to see full summary)`]),
+    ...(userDisplayMessage ? [userDisplayMessage] : []),
+    ...(upgradeMessage ? [upgradeMessage] : []),
+  ]
+  return chalk.dim('Compacted ' + dimmed.join('\n'))
+}
+
+async function getCacheSharingParams(
+  context: ToolUseContext,
+  forkContextMessages: Message[],
+): Promise<{
+  systemPrompt: SystemPrompt
+  userContext: { [k: string]: string }
+  systemContext: { [k: string]: string }
+  toolUseContext: ToolUseContext
+  forkContextMessages: Message[]
+}> {
+  const appState = context.getAppState()
+  const defaultSysPrompt = await getSystemPrompt(
+    context.options.tools,
+    context.options.mainLoopModel,
+    Array.from(
+      appState.toolPermissionContext.additionalWorkingDirectories.keys(),
+    ),
+    context.options.mcpClients,
+  )
+  const systemPrompt = buildEffectiveSystemPrompt({
+    mainThreadAgentDefinition: undefined,
+    toolUseContext: context,
+    customSystemPrompt: context.options.customSystemPrompt,
+    defaultSystemPrompt: defaultSysPrompt,
+    appendSystemPrompt: context.options.appendSystemPrompt,
+  })
+  const [userContext, systemContext] = await Promise.all([
+    getUserContext(),
+    getSystemContext(),
+  ])
+  return {
+    systemPrompt,
+    userContext,
+    systemContext,
+    toolUseContext: context,
+    forkContextMessages,
+  }
+}

src/commands/compact/index.ts

@@ -0,0 +1,15 @@
+import type { Command } from '../../commands.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+const compact = {
+  type: 'local',
+  name: 'compact',
+  description:
+    'Clear conversation history but keep a summary in context. Optional: /compact [instructions for summarization]',
+  isEnabled: () => !isEnvTruthy(process.env.DISABLE_COMPACT),
+  supportsNonInteractive: true,
+  argumentHint: '<optional custom summarization instructions>',
+  load: () => import('./compact.js'),
+} satisfies Command
+
+export default compact

src/commands/config/config.tsx

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { Settings } from '../../components/Settings/Settings.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+export const call: LocalJSXCommandCall = async (onDone, context) => {
+  return <Settings onClose={onDone} context={context} defaultTab="Config" />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlNldHRpbmdzIiwiTG9jYWxKU1hDb21tYW5kQ2FsbCIsImNhbGwiLCJvbkRvbmUiLCJjb250ZXh0Il0sInNvdXJjZXMiOlsiY29uZmlnLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB7IFNldHRpbmdzIH0gZnJvbSAnLi4vLi4vY29tcG9uZW50cy9TZXR0aW5ncy9TZXR0aW5ncy5qcydcbmltcG9ydCB0eXBlIHsgTG9jYWxKU1hDb21tYW5kQ2FsbCB9IGZyb20gJy4uLy4uL3R5cGVzL2NvbW1hbmQuanMnXG5cbmV4cG9ydCBjb25zdCBjYWxsOiBMb2NhbEpTWENvbW1hbmRDYWxsID0gYXN5bmMgKG9uRG9uZSwgY29udGV4dCkgPT4ge1xuICByZXR1cm4gPFNldHRpbmdzIG9uQ2xvc2U9e29uRG9uZX0gY29udGV4dD17Y29udGV4dH0gZGVmYXVsdFRhYj1cIkNvbmZpZ1wiIC8+XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBS0EsS0FBSyxNQUFNLE9BQU87QUFDOUIsU0FBU0MsUUFBUSxRQUFRLHVDQUF1QztBQUNoRSxjQUFjQyxtQkFBbUIsUUFBUSx3QkFBd0I7QUFFakUsT0FBTyxNQUFNQyxJQUFJLEVBQUVELG1CQUFtQixHQUFHLE1BQUFDLENBQU9DLE1BQU0sRUFBRUMsT0FBTyxLQUFLO0VBQ2xFLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUNELE1BQU0sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDQyxPQUFPLENBQUMsQ0FBQyxVQUFVLENBQUMsUUFBUSxHQUFHO0FBQzVFLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

src/commands/config/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const config = {
+  aliases: ['settings'],
+  type: 'local-jsx',
+  name: 'config',
+  description: 'Open config panel',
+  load: () => import('./config.js'),
+} satisfies Command
+
+export default config

src/commands/context/context-noninteractive.ts

@@ -0,0 +1,325 @@
+import { feature } from 'bun:bundle'
+import { microcompactMessages } from '../../services/compact/microCompact.js'
+import type { AppState } from '../../state/AppStateStore.js'
+import type { Tools, ToolUseContext } from '../../Tool.js'
+import type { AgentDefinitionsResult } from '../../tools/AgentTool/loadAgentsDir.js'
+import type { Message } from '../../types/message.js'
+import {
+  analyzeContextUsage,
+  type ContextData,
+} from '../../utils/analyzeContext.js'
+import { formatTokens } from '../../utils/format.js'
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js'
+import { getSourceDisplayName } from '../../utils/settings/constants.js'
+import { plural } from '../../utils/stringUtils.js'
+
+/**
+ * Shared data-collection path for `/context` (slash command) and the SDK
+ * `get_context_usage` control request. Mirrors query.ts's pre-API transforms
+ * (compact boundary, projectView, microcompact) so the token count reflects
+ * what the model actually sees.
+ */
+type CollectContextDataInput = {
+  messages: Message[]
+  getAppState: () => AppState
+  options: {
+    mainLoopModel: string
+    tools: Tools
+    agentDefinitions: AgentDefinitionsResult
+    customSystemPrompt?: string
+    appendSystemPrompt?: string
+  }
+}
+
+export async function collectContextData(
+  context: CollectContextDataInput,
+): Promise<ContextData> {
+  const {
+    messages,
+    getAppState,
+    options: {
+      mainLoopModel,
+      tools,
+      agentDefinitions,
+      customSystemPrompt,
+      appendSystemPrompt,
+    },
+  } = context
+
+  let apiView = getMessagesAfterCompactBoundary(messages)
+  if (feature('CONTEXT_COLLAPSE')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { projectView } =
+      require('../../services/contextCollapse/operations.js') as typeof import('../../services/contextCollapse/operations.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    apiView = projectView(apiView)
+  }
+
+  const { messages: compactedMessages } = await microcompactMessages(apiView)
+  const appState = getAppState()
+
+  return analyzeContextUsage(
+    compactedMessages,
+    mainLoopModel,
+    async () => appState.toolPermissionContext,
+    tools,
+    agentDefinitions,
+    undefined, // terminalWidth
+    // analyzeContextUsage only reads options.{customSystemPrompt,appendSystemPrompt}
+    // but its signature declares the full Pick<ToolUseContext, 'options'>.
+    { options: { customSystemPrompt, appendSystemPrompt } } as Pick<
+      ToolUseContext,
+      'options'
+    >,
+    undefined, // mainThreadAgentDefinition
+    apiView, // original messages for API usage extraction
+  )
+}
+
+export async function call(
+  _args: string,
+  context: ToolUseContext,
+): Promise<{ type: 'text'; value: string }> {
+  const data = await collectContextData(context)
+  return {
+    type: 'text' as const,
+    value: formatContextAsMarkdownTable(data),
+  }
+}
+
+function formatContextAsMarkdownTable(data: ContextData): string {
+  const {
+    categories,
+    totalTokens,
+    rawMaxTokens,
+    percentage,
+    model,
+    memoryFiles,
+    mcpTools,
+    agents,
+    skills,
+    messageBreakdown,
+    systemTools,
+    systemPromptSections,
+  } = data
+
+  let output = `## Context Usage\n\n`
+  output += `**Model:** ${model}  \n`
+  output += `**Tokens:** ${formatTokens(totalTokens)} / ${formatTokens(rawMaxTokens)} (${percentage}%)\n`
+
+  // Context-collapse status. Always show when the runtime gate is on —
+  // the user needs to know which strategy is managing their context
+  // even before anything has fired.
+  if (feature('CONTEXT_COLLAPSE')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { getStats, isContextCollapseEnabled } =
+      require('../../services/contextCollapse/index.js') as typeof import('../../services/contextCollapse/index.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    if (isContextCollapseEnabled()) {
+      const s = getStats()
+      const { health: h } = s
+
+      const parts = []
+      if (s.collapsedSpans > 0) {
+        parts.push(
+          `${s.collapsedSpans} ${plural(s.collapsedSpans, 'span')} summarized (${s.collapsedMessages} messages)`,
+        )
+      }
+      if (s.stagedSpans > 0) parts.push(`${s.stagedSpans} staged`)
+      const summary =
+        parts.length > 0
+          ? parts.join(', ')
+          : h.totalSpawns > 0
+            ? `${h.totalSpawns} ${plural(h.totalSpawns, 'spawn')}, nothing staged yet`
+            : 'waiting for first trigger'
+      output += `**Context strategy:** collapse (${summary})\n`
+
+      if (h.totalErrors > 0) {
+        output += `**Collapse errors:** ${h.totalErrors}/${h.totalSpawns} spawns failed`
+        if (h.lastError) {
+          output += ` (last: ${h.lastError.slice(0, 80)})`
+        }
+        output += '\n'
+      } else if (h.emptySpawnWarningEmitted) {
+        output += `**Collapse idle:** ${h.totalEmptySpawns} consecutive empty runs\n`
+      }
+    }
+  }
+  output += '\n'
+
+  // Main categories table
+  const visibleCategories = categories.filter(
+    cat =>
+      cat.tokens > 0 &&
+      cat.name !== 'Free space' &&
+      cat.name !== 'Autocompact buffer',
+  )
+
+  if (visibleCategories.length > 0) {
+    output += `### Estimated usage by category\n\n`
+    output += `| Category | Tokens | Percentage |\n`
+    output += `|----------|--------|------------|\n`
+
+    for (const cat of visibleCategories) {
+      const percentDisplay = ((cat.tokens / rawMaxTokens) * 100).toFixed(1)
+      output += `| ${cat.name} | ${formatTokens(cat.tokens)} | ${percentDisplay}% |\n`
+    }
+
+    const freeSpaceCategory = categories.find(c => c.name === 'Free space')
+    if (freeSpaceCategory && freeSpaceCategory.tokens > 0) {
+      const percentDisplay = (
+        (freeSpaceCategory.tokens / rawMaxTokens) *
+        100
+      ).toFixed(1)
+      output += `| Free space | ${formatTokens(freeSpaceCategory.tokens)} | ${percentDisplay}% |\n`
+    }
+
+    const autocompactCategory = categories.find(
+      c => c.name === 'Autocompact buffer',
+    )
+    if (autocompactCategory && autocompactCategory.tokens > 0) {
+      const percentDisplay = (
+        (autocompactCategory.tokens / rawMaxTokens) *
+        100
+      ).toFixed(1)
+      output += `| Autocompact buffer | ${formatTokens(autocompactCategory.tokens)} | ${percentDisplay}% |\n`
+    }
+
+    output += `\n`
+  }
+
+  // MCP tools
+  if (mcpTools.length > 0) {
+    output += `### MCP Tools\n\n`
+    output += `| Tool | Server | Tokens |\n`
+    output += `|------|--------|--------|\n`
+    for (const tool of mcpTools) {
+      output += `| ${tool.name} | ${tool.serverName} | ${formatTokens(tool.tokens)} |\n`
+    }
+    output += `\n`
+  }
+
+  // System tools (ant-only)
+  if (
+    systemTools &&
+    systemTools.length > 0 &&
+    process.env.USER_TYPE === 'ant'
+  ) {
+    output += `### [ANT-ONLY] System Tools\n\n`
+    output += `| Tool | Tokens |\n`
+    output += `|------|--------|\n`
+    for (const tool of systemTools) {
+      output += `| ${tool.name} | ${formatTokens(tool.tokens)} |\n`
+    }
+    output += `\n`
+  }
+
+  // System prompt sections (ant-only)
+  if (
+    systemPromptSections &&
+    systemPromptSections.length > 0 &&
+    process.env.USER_TYPE === 'ant'
+  ) {
+    output += `### [ANT-ONLY] System Prompt Sections\n\n`
+    output += `| Section | Tokens |\n`
+    output += `|---------|--------|\n`
+    for (const section of systemPromptSections) {
+      output += `| ${section.name} | ${formatTokens(section.tokens)} |\n`
+    }
+    output += `\n`
+  }
+
+  // Custom agents
+  if (agents.length > 0) {
+    output += `### Custom Agents\n\n`
+    output += `| Agent Type | Source | Tokens |\n`
+    output += `|------------|--------|--------|\n`
+    for (const agent of agents) {
+      let sourceDisplay: string
+      switch (agent.source) {
+        case 'projectSettings':
+          sourceDisplay = 'Project'
+          break
+        case 'userSettings':
+          sourceDisplay = 'User'
+          break
+        case 'localSettings':
+          sourceDisplay = 'Local'
+          break
+        case 'flagSettings':
+          sourceDisplay = 'Flag'
+          break
+        case 'policySettings':
+          sourceDisplay = 'Policy'
+          break
+        case 'plugin':
+          sourceDisplay = 'Plugin'
+          break
+        case 'built-in':
+          sourceDisplay = 'Built-in'
+          break
+        default:
+          sourceDisplay = String(agent.source)
+      }
+      output += `| ${agent.agentType} | ${sourceDisplay} | ${formatTokens(agent.tokens)} |\n`
+    }
+    output += `\n`
+  }
+
+  // Memory files
+  if (memoryFiles.length > 0) {
+    output += `### Memory Files\n\n`
+    output += `| Type | Path | Tokens |\n`
+    output += `|------|------|--------|\n`
+    for (const file of memoryFiles) {
+      output += `| ${file.type} | ${file.path} | ${formatTokens(file.tokens)} |\n`
+    }
+    output += `\n`
+  }
+
+  // Skills
+  if (skills && skills.tokens > 0 && skills.skillFrontmatter.length > 0) {
+    output += `### Skills\n\n`
+    output += `| Skill | Source | Tokens |\n`
+    output += `|-------|--------|--------|\n`
+    for (const skill of skills.skillFrontmatter) {
+      output += `| ${skill.name} | ${getSourceDisplayName(skill.source)} | ${formatTokens(skill.tokens)} |\n`
+    }
+    output += `\n`
+  }
+
+  // Message breakdown (ant-only)
+  if (messageBreakdown && process.env.USER_TYPE === 'ant') {
+    output += `### [ANT-ONLY] Message Breakdown\n\n`
+    output += `| Category | Tokens |\n`
+    output += `|----------|--------|\n`
+    output += `| Tool calls | ${formatTokens(messageBreakdown.toolCallTokens)} |\n`
+    output += `| Tool results | ${formatTokens(messageBreakdown.toolResultTokens)} |\n`
+    output += `| Attachments | ${formatTokens(messageBreakdown.attachmentTokens)} |\n`
+    output += `| Assistant messages (non-tool) | ${formatTokens(messageBreakdown.assistantMessageTokens)} |\n`
+    output += `| User messages (non-tool-result) | ${formatTokens(messageBreakdown.userMessageTokens)} |\n`
+    output += `\n`
+
+    if (messageBreakdown.toolCallsByType.length > 0) {
+      output += `#### Top Tools\n\n`
+      output += `| Tool | Call Tokens | Result Tokens |\n`
+      output += `|------|-------------|---------------|\n`
+      for (const tool of messageBreakdown.toolCallsByType) {
+        output += `| ${tool.name} | ${formatTokens(tool.callTokens)} | ${formatTokens(tool.resultTokens)} |\n`
+      }
+      output += `\n`
+    }
+
+    if (messageBreakdown.attachmentsByType.length > 0) {
+      output += `#### Top Attachments\n\n`
+      output += `| Attachment | Tokens |\n`
+      output += `|------------|--------|\n`
+      for (const attachment of messageBreakdown.attachmentsByType) {
+        output += `| ${attachment.name} | ${formatTokens(attachment.tokens)} |\n`
+      }
+      output += `\n`
+    }
+  }
+
+  return output
+}

src/commands/context/context.tsx

@@ -0,0 +1,64 @@
+import { feature } from 'bun:bundle';
+import * as React from 'react';
+import type { LocalJSXCommandContext } from '../../commands.js';
+import { ContextVisualization } from '../../components/ContextVisualization.js';
+import { microcompactMessages } from '../../services/compact/microCompact.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import type { Message } from '../../types/message.js';
+import { analyzeContextUsage } from '../../utils/analyzeContext.js';
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js';
+import { renderToAnsiString } from '../../utils/staticRender.js';
+
+/**
+ * Apply the same context transforms query.ts does before the API call, so
+ * /context shows what the model actually sees rather than the REPL's raw
+ * history. Without projectView the token count overcounts by however much
+ * was collapsed — user sees "180k, 3 spans collapsed" when the API sees 120k.
+ */
+function toApiView(messages: Message[]): Message[] {
+  let view = getMessagesAfterCompactBoundary(messages);
+  if (feature('CONTEXT_COLLAPSE')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const {
+      projectView
+    } = require('../../services/contextCollapse/operations.js') as typeof import('../../services/contextCollapse/operations.js');
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    view = projectView(view);
+  }
+  return view;
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext): Promise<React.ReactNode> {
+  const {
+    messages,
+    getAppState,
+    options: {
+      mainLoopModel,
+      tools
+    }
+  } = context;
+  const apiView = toApiView(messages);
+
+  // Apply microcompact to get accurate representation of messages sent to API
+  const {
+    messages: compactedMessages
+  } = await microcompactMessages(apiView);
+
+  // Get terminal width for responsive sizing
+  const terminalWidth = process.stdout.columns || 80;
+  const appState = getAppState();
+
+  // Analyze context with compacted messages
+  // Pass original messages as last parameter for accurate API usage extraction
+  const data = await analyzeContextUsage(compactedMessages, mainLoopModel, async () => appState.toolPermissionContext, tools, appState.agentDefinitions, terminalWidth, context,
+  // Pass full context for system prompt calculation
+  undefined,
+  // mainThreadAgentDefinition
+  apiView // Original messages for API usage extraction
+  );
+
+  // Render to ANSI string to preserve colors and pass to onDone like local commands do
+  const output = await renderToAnsiString(<ContextVisualization data={data} />);
+  onDone(output);
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/commands/context/index.ts

@@ -0,0 +1,24 @@
+import { getIsNonInteractiveSession } from '../../bootstrap/state.js'
+import type { Command } from '../../commands.js'
+
+export const context: Command = {
+  name: 'context',
+  description: 'Visualize current context usage as a colored grid',
+  isEnabled: () => !getIsNonInteractiveSession(),
+  type: 'local-jsx',
+  load: () => import('./context.js'),
+}
+
+export const contextNonInteractive: Command = {
+  type: 'local',
+  name: 'context',
+  supportsNonInteractive: true,
+  description: 'Show current context usage',
+  get isHidden() {
+    return !getIsNonInteractiveSession()
+  },
+  isEnabled() {
+    return getIsNonInteractiveSession()
+  },
+  load: () => import('./context-noninteractive.js'),
+}

src/commands/copy/copy.tsx

@@ -0,0 +1,371 @@
+import { c as _c } from "react/compiler-runtime";
+import { mkdir, writeFile } from 'fs/promises';
+import { marked, type Tokens } from 'marked';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import React, { useRef } from 'react';
+import type { CommandResultDisplay } from '../../commands.js';
+import type { OptionWithDescription } from '../../components/CustomSelect/select.js';
+import { Select } from '../../components/CustomSelect/select.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { Pane } from '../../components/design-system/Pane.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { setClipboard } from '../../ink/termio/osc.js';
+import { Box, Text } from '../../ink.js';
+import { logEvent } from '../../services/analytics/index.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+import type { AssistantMessage, Message } from '../../types/message.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { extractTextContent, stripPromptXMLTags } from '../../utils/messages.js';
+import { countCharInString } from '../../utils/stringUtils.js';
+const COPY_DIR = join(tmpdir(), 'claude');
+const RESPONSE_FILENAME = 'response.md';
+const MAX_LOOKBACK = 20;
+type CodeBlock = {
+  code: string;
+  lang: string | undefined;
+};
+function extractCodeBlocks(markdown: string): CodeBlock[] {
+  const tokens = marked.lexer(stripPromptXMLTags(markdown));
+  const blocks: CodeBlock[] = [];
+  for (const token of tokens) {
+    if (token.type === 'code') {
+      const codeToken = token as Tokens.Code;
+      blocks.push({
+        code: codeToken.text,
+        lang: codeToken.lang
+      });
+    }
+  }
+  return blocks;
+}
+
+/**
+ * Walk messages newest-first, returning text from assistant messages that
+ * actually said something (skips tool-use-only turns and API errors).
+ * Index 0 = latest, 1 = second-to-latest, etc. Caps at MAX_LOOKBACK.
+ */
+export function collectRecentAssistantTexts(messages: Message[]): string[] {
+  const texts: string[] = [];
+  for (let i = messages.length - 1; i >= 0 && texts.length < MAX_LOOKBACK; i--) {
+    const msg = messages[i];
+    if (msg?.type !== 'assistant' || msg.isApiErrorMessage) continue;
+    const content = (msg as AssistantMessage).message.content;
+    if (!Array.isArray(content)) continue;
+    const text = extractTextContent(content, '\n\n');
+    if (text) texts.push(text);
+  }
+  return texts;
+}
+export function fileExtension(lang: string | undefined): string {
+  if (lang) {
+    // Sanitize to prevent path traversal (e.g. ```../../etc/passwd)
+    // Language identifiers are alphanumeric: python, tsx, jsonc, etc.
+    const sanitized = lang.replace(/[^a-zA-Z0-9]/g, '');
+    if (sanitized && sanitized !== 'plaintext') {
+      return `.${sanitized}`;
+    }
+  }
+  return '.txt';
+}
+async function writeToFile(text: string, filename: string): Promise<string> {
+  const filePath = join(COPY_DIR, filename);
+  await mkdir(COPY_DIR, {
+    recursive: true
+  });
+  await writeFile(filePath, text, 'utf-8');
+  return filePath;
+}
+async function copyOrWriteToFile(text: string, filename: string): Promise<string> {
+  const raw = await setClipboard(text);
+  if (raw) process.stdout.write(raw);
+  const lineCount = countCharInString(text, '\n') + 1;
+  const charCount = text.length;
+  // Also write to a temp file — clipboard paths are best-effort (OSC 52 needs
+  // terminal support), so the file provides a reliable fallback.
+  try {
+    const filePath = await writeToFile(text, filename);
+    return `Copied to clipboard (${charCount} characters, ${lineCount} lines)\nAlso written to ${filePath}`;
+  } catch {
+    return `Copied to clipboard (${charCount} characters, ${lineCount} lines)`;
+  }
+}
+function truncateLine(text: string, maxLen: number): string {
+  const firstLine = text.split('\n')[0] ?? '';
+  if (stringWidth(firstLine) <= maxLen) {
+    return firstLine;
+  }
+  let result = '';
+  let width = 0;
+  const targetWidth = maxLen - 1;
+  for (const char of firstLine) {
+    const charWidth = stringWidth(char);
+    if (width + charWidth > targetWidth) break;
+    result += char;
+    width += charWidth;
+  }
+  return result + '\u2026';
+}
+type PickerProps = {
+  fullText: string;
+  codeBlocks: CodeBlock[];
+  messageAge: number;
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+};
+type PickerSelection = number | 'full' | 'always';
+function CopyPicker(t0) {
+  const $ = _c(33);
+  const {
+    fullText,
+    codeBlocks,
+    messageAge,
+    onDone
+  } = t0;
+  const focusedRef = useRef("full");
+  const t1 = `${fullText.length} chars, ${countCharInString(fullText, "\n") + 1} lines`;
+  let t2;
+  if ($[0] !== t1) {
+    t2 = {
+      label: "Full response",
+      value: "full" as const,
+      description: t1
+    };
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] !== codeBlocks || $[3] !== t2) {
+    let t4;
+    if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+      t4 = {
+        label: "Always copy full response",
+        value: "always" as const,
+        description: "Skip this picker in the future (revert via /config)"
+      };
+      $[5] = t4;
+    } else {
+      t4 = $[5];
+    }
+    t3 = [t2, ...codeBlocks.map(_temp), t4];
+    $[2] = codeBlocks;
+    $[3] = t2;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  const options = t3;
+  let t4;
+  if ($[6] !== codeBlocks || $[7] !== fullText) {
+    t4 = function getSelectionContent(selected) {
+      if (selected === "full" || selected === "always") {
+        return {
+          text: fullText,
+          filename: RESPONSE_FILENAME
+        };
+      }
+      const block_0 = codeBlocks[selected];
+      return {
+        text: block_0.code,
+        filename: `copy${fileExtension(block_0.lang)}`,
+        blockIndex: selected
+      };
+    };
+    $[6] = codeBlocks;
+    $[7] = fullText;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  const getSelectionContent = t4;
+  let t5;
+  if ($[9] !== codeBlocks.length || $[10] !== getSelectionContent || $[11] !== messageAge || $[12] !== onDone) {
+    t5 = async function handleSelect(selected_0) {
+      const content = getSelectionContent(selected_0);
+      if (selected_0 === "always") {
+        if (!getGlobalConfig().copyFullResponse) {
+          saveGlobalConfig(_temp2);
+        }
+        logEvent("tengu_copy", {
+          block_count: codeBlocks.length,
+          always: true,
+          message_age: messageAge
+        });
+        const result = await copyOrWriteToFile(content.text, content.filename);
+        onDone(`${result}\nPreference saved. Use /config to change copyFullResponse`);
+        return;
+      }
+      logEvent("tengu_copy", {
+        selected_block: content.blockIndex,
+        block_count: codeBlocks.length,
+        message_age: messageAge
+      });
+      const result_0 = await copyOrWriteToFile(content.text, content.filename);
+      onDone(result_0);
+    };
+    $[9] = codeBlocks.length;
+    $[10] = getSelectionContent;
+    $[11] = messageAge;
+    $[12] = onDone;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  const handleSelect = t5;
+  let t6;
+  if ($[14] !== codeBlocks.length || $[15] !== getSelectionContent || $[16] !== messageAge || $[17] !== onDone) {
+    const handleWrite = async function handleWrite(selected_1) {
+      const content_0 = getSelectionContent(selected_1);
+      logEvent("tengu_copy", {
+        selected_block: content_0.blockIndex,
+        block_count: codeBlocks.length,
+        message_age: messageAge,
+        write_shortcut: true
+      });
+      ;
+      try {
+        const filePath = await writeToFile(content_0.text, content_0.filename);
+        onDone(`Written to ${filePath}`);
+      } catch (t7) {
+        const e = t7;
+        onDone(`Failed to write file: ${e instanceof Error ? e.message : e}`);
+      }
+    };
+    t6 = function handleKeyDown(e_0) {
+      if (e_0.key === "w") {
+        e_0.preventDefault();
+        handleWrite(focusedRef.current);
+      }
+    };
+    $[14] = codeBlocks.length;
+    $[15] = getSelectionContent;
+    $[16] = messageAge;
+    $[17] = onDone;
+    $[18] = t6;
+  } else {
+    t6 = $[18];
+  }
+  const handleKeyDown = t6;
+  let t7;
+  if ($[19] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = <Text dimColor={true}>Select content to copy:</Text>;
+    $[19] = t7;
+  } else {
+    t7 = $[19];
+  }
+  let t8;
+  if ($[20] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = value => {
+      focusedRef.current = value;
+    };
+    $[20] = t8;
+  } else {
+    t8 = $[20];
+  }
+  let t9;
+  if ($[21] !== handleSelect) {
+    t9 = selected_2 => {
+      handleSelect(selected_2);
+    };
+    $[21] = handleSelect;
+    $[22] = t9;
+  } else {
+    t9 = $[22];
+  }
+  let t10;
+  if ($[23] !== onDone) {
+    t10 = () => {
+      onDone("Copy cancelled", {
+        display: "system"
+      });
+    };
+    $[23] = onDone;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  let t11;
+  if ($[25] !== options || $[26] !== t10 || $[27] !== t9) {
+    t11 = <Select options={options} hideIndexes={false} onFocus={t8} onChange={t9} onCancel={t10} />;
+    $[25] = options;
+    $[26] = t10;
+    $[27] = t9;
+    $[28] = t11;
+  } else {
+    t11 = $[28];
+  }
+  let t12;
+  if ($[29] === Symbol.for("react.memo_cache_sentinel")) {
+    t12 = <Text dimColor={true}><Byline><KeyboardShortcutHint shortcut="enter" action="copy" /><KeyboardShortcutHint shortcut="w" action="write to file" /><KeyboardShortcutHint shortcut="esc" action="cancel" /></Byline></Text>;
+    $[29] = t12;
+  } else {
+    t12 = $[29];
+  }
+  let t13;
+  if ($[30] !== handleKeyDown || $[31] !== t11) {
+    t13 = <Pane><Box flexDirection="column" gap={1} tabIndex={0} autoFocus={true} onKeyDown={handleKeyDown}>{t7}{t11}{t12}</Box></Pane>;
+    $[30] = handleKeyDown;
+    $[31] = t11;
+    $[32] = t13;
+  } else {
+    t13 = $[32];
+  }
+  return t13;
+}
+function _temp2(c) {
+  return {
+    ...c,
+    copyFullResponse: true
+  };
+}
+function _temp(block, index) {
+  const blockLines = countCharInString(block.code, "\n") + 1;
+  return {
+    label: truncateLine(block.code, 60),
+    value: index,
+    description: [block.lang, blockLines > 1 ? `${blockLines} lines` : undefined].filter(Boolean).join(", ") || undefined
+  };
+}
+export const call: LocalJSXCommandCall = async (onDone, context, args) => {
+  const texts = collectRecentAssistantTexts(context.messages);
+  if (texts.length === 0) {
+    onDone('No assistant message to copy');
+    return null;
+  }
+
+  // /copy N reaches back N-1 messages (1 = latest, 2 = second-to-latest, ...)
+  let age = 0;
+  const arg = args?.trim();
+  if (arg) {
+    const n = Number(arg);
+    if (!Number.isInteger(n) || n < 1) {
+      onDone(`Usage: /copy [N] where N is 1 (latest), 2, 3, \u2026 Got: ${arg}`);
+      return null;
+    }
+    if (n > texts.length) {
+      onDone(`Only ${texts.length} assistant ${texts.length === 1 ? 'message' : 'messages'} available to copy`);
+      return null;
+    }
+    age = n - 1;
+  }
+  const text = texts[age]!;
+  const codeBlocks = extractCodeBlocks(text);
+  const config = getGlobalConfig();
+  if (codeBlocks.length === 0 || config.copyFullResponse) {
+    logEvent('tengu_copy', {
+      always: config.copyFullResponse,
+      block_count: codeBlocks.length,
+      message_age: age
+    });
+    const result = await copyOrWriteToFile(text, RESPONSE_FILENAME);
+    onDone(result);
+    return null;
+  }
+  return <CopyPicker fullText={text} codeBlocks={codeBlocks} messageAge={age} onDone={onDone} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mkdir","writeFile","marked","Tokens","tmpdir","join","React","useRef","CommandResultDisplay","OptionWithDescription","Select","Byline","KeyboardShortcutHint","Pane","KeyboardEvent","stringWidth","setClipboard","Box","Text","logEvent","LocalJSXCommandCall","AssistantMessage","Message","getGlobalConfig","saveGlobalConfig","extractTextContent","stripPromptXMLTags","countCharInString","COPY_DIR","RESPONSE_FILENAME","MAX_LOOKBACK","CodeBlock","code","lang","extractCodeBlocks","markdown","tokens","lexer","blocks","token","type","codeToken","Code","push","text","collectRecentAssistantTexts","messages","texts","i","length","msg","isApiErrorMessage","content","message","Array","isArray","fileExtension","sanitized","replace","writeToFile","filename","Promise","filePath","recursive","copyOrWriteToFile","raw","process","stdout","write","lineCount","charCount","truncateLine","maxLen","firstLine","split","result","width","targetWidth","char","charWidth","PickerProps","fullText","codeBlocks","messageAge","onDone","options","display","PickerSelection","CopyPicker","t0","$","_c","focusedRef","t1","t2","label","value","const","description","t3","t4","Symbol","for","map","_temp","getSelectionContent","selected","block_0","block","blockIndex","t5","handleSelect","selected_0","copyFullResponse","_temp2","block_count","always","message_age","selected_block","result_0","t6","handleWrite","selected_1","content_0","write_shortcut","t7","e","Error","handleKeyDown","e_0","key","preventDefault","current","t8","t9","selected_2","t10","t11","t12","t13","c","index","blockLines","undefined","filter","Boolean","call","context","args","age","arg","trim","n","Number","isInteger","config"],"sources":["copy.tsx"],"sourcesContent":["import { mkdir, writeFile } from 'fs/promises'\nimport { marked, type Tokens } from 'marked'\nimport { tmpdir } from 'os'\nimport { join } from 'path'\nimport React, { useRef } from 'react'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport type { OptionWithDescription } from '../../components/CustomSelect/select.js'\nimport { Select } from '../../components/CustomSelect/select.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { Pane } from '../../components/design-system/Pane.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { setClipboard } from '../../ink/termio/osc.js'\nimport { Box, Text } from '../../ink.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport type { LocalJSXCommandCall } from '../../types/command.js'\nimport type { AssistantMessage, Message } from '../../types/message.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport { extractTextContent, stripPromptXMLTags } from '../../utils/messages.js'\nimport { countCharInString } from '../../utils/stringUtils.js'\n\nconst COPY_DIR = join(tmpdir(), 'claude')\nconst RESPONSE_FILENAME = 'response.md'\nconst MAX_LOOKBACK = 20\n\ntype CodeBlock = {\n  code: string\n  lang: string | undefined\n}\n\nfunction extractCodeBlocks(markdown: string): CodeBlock[] {\n  const tokens = marked.lexer(stripPromptXMLTags(markdown))\n  const blocks: CodeBlock[] = []\n  for (const token of tokens) {\n    if (token.type === 'code') {\n      const codeToken = token as Tokens.Code\n      blocks.push({ code: codeToken.text, lang: codeToken.lang })\n    }\n  }\n  return blocks\n}\n\n/**\n * Walk messages newest-first, returning text from assistant messages that\n * actually said something (skips tool-use-only turns and API errors).\n * Index 0 = latest, 1 = second-to-latest, etc. Caps at MAX_LOOKBACK.\n */\nexport function collectRecentAssistantTexts(messages: Message[]): string[] {\n  const texts: string[] = []\n  for (\n    let i = messages.length - 1;\n    i >= 0 && texts.length < MAX_LOOKBACK;\n    i--\n  ) {\n    const msg = messages[i]\n    if (msg?.type !== 'assistant' || msg.isApiErrorMessage) continue\n    const content = (msg as AssistantMessage).message.content\n    if (!Array.isArray(content)) continue\n    const text = extractTextContent(content, '\\n\\n')\n    if (text) texts.push(text)\n  }\n  return texts\n}\n\nexport function fileExtension(lang: string | undefined): string {\n  if (lang) {\n    // Sanitize to prevent path traversal (e.g. ```../../etc/passwd)\n    // Language identifiers are alphanumeric: python, tsx, jsonc, etc.\n    const sanitized = lang.replace(/[^a-zA-Z0-9]/g, '')\n    if (sanitized && sanitized !== 'plaintext') {\n      return `.${sanitized}`\n    }\n  }\n  return '.txt'\n}\n\nasync function writeToFile(text: string, filename: string): Promise<string> {\n  const filePath = join(COPY_DIR, filename)\n  await mkdir(COPY_DIR, { recursive: true })\n  await writeFile(filePath, text, 'utf-8')\n  return filePath\n}\n\nasync function copyOrWriteToFile(\n  text: string,\n  filename: string,\n): Promise<string> {\n  const raw = await setClipboard(text)\n  if (raw) process.stdout.write(raw)\n  const lineCount = countCharInString(text, '\\n') + 1\n  const charCount = text.length\n  // Also write to a temp file — clipboard paths are best-effort (OSC 52 needs\n  // terminal support), so the file provides a reliable fallback.\n  try {\n    const filePath = await writeToFile(text, filename)\n    return `Copied to clipboard (${charCount} characters, ${lineCount} lines)\\nAlso written to ${filePath}`\n  } catch {\n    return `Copied to clipboard (${charCount} characters, ${lineCount} lines)`\n  }\n}\n\nfunction truncateLine(text: string, maxLen: number): string {\n  const firstLine = text.split('\\n')[0] ?? ''\n  if (stringWidth(firstLine) <= maxLen) {\n    return firstLine\n  }\n  let result = ''\n  let width = 0\n  const targetWidth = maxLen - 1\n  for (const char of firstLine) {\n    const charWidth = stringWidth(char)\n    if (width + charWidth > targetWidth) break\n    result += char\n    width += charWidth\n  }\n  return result + '\\u2026'\n}\n\ntype PickerProps = {\n  fullText: string\n  codeBlocks: CodeBlock[]\n  messageAge: number\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}\n\ntype PickerSelection = number | 'full' | 'always'\n\nfunction CopyPicker({\n  fullText,\n  codeBlocks,\n  messageAge,\n  onDone,\n}: PickerProps): React.ReactNode {\n  const focusedRef = useRef<PickerSelection>('full')\n\n  const options: OptionWithDescription<PickerSelection>[] = [\n    {\n      label: 'Full response',\n      value: 'full' as const,\n      description: `${fullText.length} chars, ${countCharInString(fullText, '\\n') + 1} lines`,\n    },\n    ...codeBlocks.map((block, index) => {\n      const blockLines = countCharInString(block.code, '\\n') + 1\n      return {\n        label: truncateLine(block.code, 60),\n        value: index,\n        description:\n          [block.lang, blockLines > 1 ? `${blockLines} lines` : undefined]\n            .filter(Boolean)\n            .join(', ') || undefined,\n      }\n    }),\n    {\n      label: 'Always copy full response',\n      value: 'always' as const,\n      description: 'Skip this picker in the future (revert via /config)',\n    },\n  ]\n\n  function getSelectionContent(selected: PickerSelection): {\n    text: string\n    filename: string\n    blockIndex?: number\n  } {\n    if (selected === 'full' || selected === 'always') {\n      return { text: fullText, filename: RESPONSE_FILENAME }\n    }\n    const block = codeBlocks[selected]!\n    return {\n      text: block.code,\n      filename: `copy${fileExtension(block.lang)}`,\n      blockIndex: selected,\n    }\n  }\n\n  async function handleSelect(selected: PickerSelection): Promise<void> {\n    const content = getSelectionContent(selected)\n    if (selected === 'always') {\n      if (!getGlobalConfig().copyFullResponse) {\n        saveGlobalConfig(c => ({ ...c, copyFullResponse: true }))\n      }\n      logEvent('tengu_copy', {\n        block_count: codeBlocks.length,\n        always: true,\n        message_age: messageAge,\n      })\n      const result = await copyOrWriteToFile(content.text, content.filename)\n      onDone(\n        `${result}\\nPreference saved. Use /config to change copyFullResponse`,\n      )\n      return\n    }\n    logEvent('tengu_copy', {\n      selected_block: content.blockIndex,\n      block_count: codeBlocks.length,\n      message_age: messageAge,\n    })\n    const result = await copyOrWriteToFile(content.text, content.filename)\n    onDone(result)\n  }\n\n  async function handleWrite(selected: PickerSelection): Promise<void> {\n    const content = getSelectionContent(selected)\n    logEvent('tengu_copy', {\n      selected_block: content.blockIndex,\n      block_count: codeBlocks.length,\n      message_age: messageAge,\n      write_shortcut: true,\n    })\n    try {\n      const filePath = await writeToFile(content.text, content.filename)\n      onDone(`Written to ${filePath}`)\n    } catch (e) {\n      onDone(`Failed to write file: ${e instanceof Error ? e.message : e}`)\n    }\n  }\n\n  function handleKeyDown(e: KeyboardEvent): void {\n    if (e.key === 'w') {\n      e.preventDefault()\n      void handleWrite(focusedRef.current)\n    }\n  }\n\n  return (\n    <Pane>\n      <Box\n        flexDirection=\"column\"\n        gap={1}\n        tabIndex={0}\n        autoFocus\n        onKeyDown={handleKeyDown}\n      >\n        <Text dimColor>Select content to copy:</Text>\n        <Select<PickerSelection>\n          options={options}\n          hideIndexes={false}\n          onFocus={value => {\n            focusedRef.current = value\n          }}\n          onChange={selected => {\n            void handleSelect(selected)\n          }}\n          onCancel={() => {\n            onDone('Copy cancelled', { display: 'system' })\n          }}\n        />\n        <Text dimColor>\n          <Byline>\n            <KeyboardShortcutHint shortcut=\"enter\" action=\"copy\" />\n            <KeyboardShortcutHint shortcut=\"w\" action=\"write to file\" />\n            <KeyboardShortcutHint shortcut=\"esc\" action=\"cancel\" />\n          </Byline>\n        </Text>\n      </Box>\n    </Pane>\n  )\n}\n\nexport const call: LocalJSXCommandCall = async (onDone, context, args) => {\n  const texts = collectRecentAssistantTexts(context.messages)\n\n  if (texts.length === 0) {\n    onDone('No assistant message to copy')\n    return null\n  }\n\n  // /copy N reaches back N-1 messages (1 = latest, 2 = second-to-latest, ...)\n  let age = 0\n  const arg = args?.trim()\n  if (arg) {\n    const n = Number(arg)\n    if (!Number.isInteger(n) || n < 1) {\n      onDone(`Usage: /copy [N] where N is 1 (latest), 2, 3, \\u2026 Got: ${arg}`)\n      return null\n    }\n    if (n > texts.length) {\n      onDone(\n        `Only ${texts.length} assistant ${texts.length === 1 ? 'message' : 'messages'} available to copy`,\n      )\n      return null\n    }\n    age = n - 1\n  }\n\n  const text = texts[age]!\n  const codeBlocks = extractCodeBlocks(text)\n  const config = getGlobalConfig()\n\n  if (codeBlocks.length === 0 || config.copyFullResponse) {\n    logEvent('tengu_copy', {\n      always: config.copyFullResponse,\n      block_count: codeBlocks.length,\n      message_age: age,\n    })\n    const result = await copyOrWriteToFile(text, RESPONSE_FILENAME)\n    onDone(result)\n    return null\n  }\n\n  return (\n    <CopyPicker\n      fullText={text}\n      codeBlocks={codeBlocks}\n      messageAge={age}\n      onDone={onDone}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/copy/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Copy command - minimal metadata only.
+ * Implementation is lazy-loaded from copy.tsx to reduce startup time.
+ */
+import type { Command } from '../../commands.js'
+
+const copy = {
+  type: 'local-jsx',
+  name: 'copy',
+  description:
+    "Copy Claude's last response to clipboard (or /copy N for the Nth-latest)",
+  load: () => import('./copy.js'),
+} satisfies Command
+
+export default copy

src/commands/cost/cost.ts

@@ -0,0 +1,24 @@
+import { formatTotalCost } from '../../cost-tracker.js'
+import { currentLimits } from '../../services/claudeAiLimits.js'
+import type { LocalCommandCall } from '../../types/command.js'
+import { isClaudeAISubscriber } from '../../utils/auth.js'
+
+export const call: LocalCommandCall = async () => {
+  if (isClaudeAISubscriber()) {
+    let value: string
+
+    if (currentLimits.isUsingOverage) {
+      value =
+        'You are currently using your overages to power your Claude Code usage. We will automatically switch you back to your subscription rate limits when they reset'
+    } else {
+      value =
+        'You are currently using your subscription to power your Claude Code usage'
+    }
+
+    if (process.env.USER_TYPE === 'ant') {
+      value += `\n\n[ANT-ONLY] Showing cost anyway:\n ${formatTotalCost()}`
+    }
+    return { type: 'text', value }
+  }
+  return { type: 'text', value: formatTotalCost() }
+}

src/commands/cost/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Cost command - minimal metadata only.
+ * Implementation is lazy-loaded from cost.ts to reduce startup time.
+ */
+import type { Command } from '../../commands.js'
+import { isClaudeAISubscriber } from '../../utils/auth.js'
+
+const cost = {
+  type: 'local',
+  name: 'cost',
+  description: 'Show the total cost and duration of the current session',
+  get isHidden() {
+    // Keep visible for Ants even if they're subscribers (they see cost breakdowns)
+    if (process.env.USER_TYPE === 'ant') {
+      return false
+    }
+    return isClaudeAISubscriber()
+  },
+  supportsNonInteractive: true,
+  load: () => import('./cost.js'),
+} satisfies Command
+
+export default cost

src/commands/ctx_viz/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/debug-tool-call/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/desktop/desktop.tsx

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { CommandResultDisplay } from '../../commands.js';
+import { DesktopHandoff } from '../../components/DesktopHandoff.js';
+export async function call(onDone: (result?: string, options?: {
+  display?: CommandResultDisplay;
+}) => void): Promise<React.ReactNode> {
+  return <DesktopHandoff onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkNvbW1hbmRSZXN1bHREaXNwbGF5IiwiRGVza3RvcEhhbmRvZmYiLCJjYWxsIiwib25Eb25lIiwicmVzdWx0Iiwib3B0aW9ucyIsImRpc3BsYXkiLCJQcm9taXNlIiwiUmVhY3ROb2RlIl0sInNvdXJjZXMiOlsiZGVza3RvcC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHR5cGUgeyBDb21tYW5kUmVzdWx0RGlzcGxheSB9IGZyb20gJy4uLy4uL2NvbW1hbmRzLmpzJ1xuaW1wb3J0IHsgRGVza3RvcEhhbmRvZmYgfSBmcm9tICcuLi8uLi9jb21wb25lbnRzL0Rlc2t0b3BIYW5kb2ZmLmpzJ1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY2FsbChcbiAgb25Eb25lOiAoXG4gICAgcmVzdWx0Pzogc3RyaW5nLFxuICAgIG9wdGlvbnM/OiB7IGRpc3BsYXk/OiBDb21tYW5kUmVzdWx0RGlzcGxheSB9LFxuICApID0+IHZvaWQsXG4pOiBQcm9taXNlPFJlYWN0LlJlYWN0Tm9kZT4ge1xuICByZXR1cm4gPERlc2t0b3BIYW5kb2ZmIG9uRG9uZT17b25Eb25lfSAvPlxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxLQUFLLE1BQU0sT0FBTztBQUN6QixjQUFjQyxvQkFBb0IsUUFBUSxtQkFBbUI7QUFDN0QsU0FBU0MsY0FBYyxRQUFRLG9DQUFvQztBQUVuRSxPQUFPLGVBQWVDLElBQUlBLENBQ3hCQyxNQUFNLEVBQUUsQ0FDTkMsTUFBZSxDQUFSLEVBQUUsTUFBTSxFQUNmQyxPQUE0QyxDQUFwQyxFQUFFO0VBQUVDLE9BQU8sQ0FBQyxFQUFFTixvQkFBb0I7QUFBQyxDQUFDLEVBQzVDLEdBQUcsSUFBSSxDQUNWLEVBQUVPLE9BQU8sQ0FBQ1IsS0FBSyxDQUFDUyxTQUFTLENBQUMsQ0FBQztFQUMxQixPQUFPLENBQUMsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDTCxNQUFNLENBQUMsR0FBRztBQUMzQyIsImlnbm9yZUxpc3QiOltdfQ==

src/commands/desktop/index.ts

@@ -0,0 +1,26 @@
+import type { Command } from '../../commands.js'
+
+function isSupportedPlatform(): boolean {
+  if (process.platform === 'darwin') {
+    return true
+  }
+  if (process.platform === 'win32' && process.arch === 'x64') {
+    return true
+  }
+  return false
+}
+
+const desktop = {
+  type: 'local-jsx',
+  name: 'desktop',
+  aliases: ['app'],
+  description: 'Continue the current session in Claude Desktop',
+  availability: ['claude-ai'],
+  isEnabled: isSupportedPlatform,
+  get isHidden() {
+    return !isSupportedPlatform()
+  },
+  load: () => import('./desktop.js'),
+} satisfies Command
+
+export default desktop

src/commands/diff/diff.tsx

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+export const call: LocalJSXCommandCall = async (onDone, context) => {
+  const {
+    DiffDialog
+  } = await import('../../components/diff/DiffDialog.js');
+  return <DiffDialog messages={context.messages} onDone={onDone} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkxvY2FsSlNYQ29tbWFuZENhbGwiLCJjYWxsIiwib25Eb25lIiwiY29udGV4dCIsIkRpZmZEaWFsb2ciLCJtZXNzYWdlcyJdLCJzb3VyY2VzIjpbImRpZmYudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHR5cGUgeyBMb2NhbEpTWENvbW1hbmRDYWxsIH0gZnJvbSAnLi4vLi4vdHlwZXMvY29tbWFuZC5qcydcblxuZXhwb3J0IGNvbnN0IGNhbGw6IExvY2FsSlNYQ29tbWFuZENhbGwgPSBhc3luYyAob25Eb25lLCBjb250ZXh0KSA9PiB7XG4gIGNvbnN0IHsgRGlmZkRpYWxvZyB9ID0gYXdhaXQgaW1wb3J0KCcuLi8uLi9jb21wb25lbnRzL2RpZmYvRGlmZkRpYWxvZy5qcycpXG4gIHJldHVybiA8RGlmZkRpYWxvZyBtZXNzYWdlcz17Y29udGV4dC5tZXNzYWdlc30gb25Eb25lPXtvbkRvbmV9IC8+XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBS0EsS0FBSyxNQUFNLE9BQU87QUFDOUIsY0FBY0MsbUJBQW1CLFFBQVEsd0JBQXdCO0FBRWpFLE9BQU8sTUFBTUMsSUFBSSxFQUFFRCxtQkFBbUIsR0FBRyxNQUFBQyxDQUFPQyxNQUFNLEVBQUVDLE9BQU8sS0FBSztFQUNsRSxNQUFNO0lBQUVDO0VBQVcsQ0FBQyxHQUFHLE1BQU0sTUFBTSxDQUFDLHFDQUFxQyxDQUFDO0VBQzFFLE9BQU8sQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUNELE9BQU8sQ0FBQ0UsUUFBUSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUNILE1BQU0sQ0FBQyxHQUFHO0FBQ25FLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

src/commands/diff/index.ts

@@ -0,0 +1,8 @@
+import type { Command } from '../../commands.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'diff',
+  description: 'View uncommitted changes and per-turn diffs',
+  load: () => import('./diff.js'),
+} satisfies Command

src/commands/doctor/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+const doctor: Command = {
+  name: 'doctor',
+  description: 'Diagnose and verify your Claude Code installation and settings',
+  isEnabled: () => !isEnvTruthy(process.env.DISABLE_DOCTOR_COMMAND),
+  type: 'local-jsx',
+  load: () => import('./doctor.js'),
+}
+
+export default doctor

src/commands/effort/effort.tsx

@@ -0,0 +1,183 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
+import { useAppState, useSetAppState } from '../../state/AppState.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { type EffortValue, getDisplayedEffortLevel, getEffortEnvOverride, getEffortValueDescription, isEffortLevel, toPersistableEffort } from '../../utils/effort.js';
+import { updateSettingsForSource } from '../../utils/settings/settings.js';
+const COMMON_HELP_ARGS = ['help', '-h', '--help'];
+type EffortCommandResult = {
+  message: string;
+  effortUpdate?: {
+    value: EffortValue | undefined;
+  };
+};
+function setEffortValue(effortValue: EffortValue): EffortCommandResult {
+  const persistable = toPersistableEffort(effortValue);
+  if (persistable !== undefined) {
+    const result = updateSettingsForSource('userSettings', {
+      effortLevel: persistable
+    });
+    if (result.error) {
+      return {
+        message: `Failed to set effort level: ${result.error.message}`
+      };
+    }
+  }
+  logEvent('tengu_effort_command', {
+    effort: effortValue as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+  });
+
+  // Env var wins at resolveAppliedEffort time. Only flag it when it actually
+  // conflicts — if env matches what the user just asked for, the outcome is
+  // the same, so "Set effort to X" is true and the note is noise.
+  const envOverride = getEffortEnvOverride();
+  if (envOverride !== undefined && envOverride !== effortValue) {
+    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+    if (persistable === undefined) {
+      return {
+        message: `Not applied: CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides effort this session, and ${effortValue} is session-only (nothing saved)`,
+        effortUpdate: {
+          value: effortValue
+        }
+      };
+    }
+    return {
+      message: `CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides this session — clear it and ${effortValue} takes over`,
+      effortUpdate: {
+        value: effortValue
+      }
+    };
+  }
+  const description = getEffortValueDescription(effortValue);
+  const suffix = persistable !== undefined ? '' : ' (this session only)';
+  return {
+    message: `Set effort level to ${effortValue}${suffix}: ${description}`,
+    effortUpdate: {
+      value: effortValue
+    }
+  };
+}
+export function showCurrentEffort(appStateEffort: EffortValue | undefined, model: string): EffortCommandResult {
+  const envOverride = getEffortEnvOverride();
+  const effectiveValue = envOverride === null ? undefined : envOverride ?? appStateEffort;
+  if (effectiveValue === undefined) {
+    const level = getDisplayedEffortLevel(model, appStateEffort);
+    return {
+      message: `Effort level: auto (currently ${level})`
+    };
+  }
+  const description = getEffortValueDescription(effectiveValue);
+  return {
+    message: `Current effort level: ${effectiveValue} (${description})`
+  };
+}
+function unsetEffortLevel(): EffortCommandResult {
+  const result = updateSettingsForSource('userSettings', {
+    effortLevel: undefined
+  });
+  if (result.error) {
+    return {
+      message: `Failed to set effort level: ${result.error.message}`
+    };
+  }
+  logEvent('tengu_effort_command', {
+    effort: 'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+  });
+  // env=auto/unset (null) matches what /effort auto asks for, so only warn
+  // when env is pinning a specific level that will keep overriding.
+  const envOverride = getEffortEnvOverride();
+  if (envOverride !== undefined && envOverride !== null) {
+    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+    return {
+      message: `Cleared effort from settings, but CLAUDE_CODE_EFFORT_LEVEL=${envRaw} still controls this session`,
+      effortUpdate: {
+        value: undefined
+      }
+    };
+  }
+  return {
+    message: 'Effort level set to auto',
+    effortUpdate: {
+      value: undefined
+    }
+  };
+}
+export function executeEffort(args: string): EffortCommandResult {
+  const normalized = args.toLowerCase();
+  if (normalized === 'auto' || normalized === 'unset') {
+    return unsetEffortLevel();
+  }
+  if (!isEffortLevel(normalized)) {
+    return {
+      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`
+    };
+  }
+  return setEffortValue(normalized);
+}
+function ShowCurrentEffort(t0) {
+  const {
+    onDone
+  } = t0;
+  const effortValue = useAppState(_temp);
+  const model = useMainLoopModel();
+  const {
+    message
+  } = showCurrentEffort(effortValue, model);
+  onDone(message);
+  return null;
+}
+function _temp(s) {
+  return s.effortValue;
+}
+function ApplyEffortAndClose(t0) {
+  const $ = _c(6);
+  const {
+    result,
+    onDone
+  } = t0;
+  const setAppState = useSetAppState();
+  const {
+    effortUpdate,
+    message
+  } = result;
+  let t1;
+  let t2;
+  if ($[0] !== effortUpdate || $[1] !== message || $[2] !== onDone || $[3] !== setAppState) {
+    t1 = () => {
+      if (effortUpdate) {
+        setAppState(prev => ({
+          ...prev,
+          effortValue: effortUpdate.value
+        }));
+      }
+      onDone(message);
+    };
+    t2 = [setAppState, effortUpdate, message, onDone];
+    $[0] = effortUpdate;
+    $[1] = message;
+    $[2] = onDone;
+    $[3] = setAppState;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t1 = $[4];
+    t2 = $[5];
+  }
+  React.useEffect(t1, t2);
+  return null;
+}
+export async function call(onDone: LocalJSXCommandOnDone, _context: unknown, args?: string): Promise<React.ReactNode> {
+  args = args?.trim() || '';
+  if (COMMON_HELP_ARGS.includes(args)) {
+    onDone('Usage: /effort [low|medium|high|max|auto]\n\nEffort levels:\n- low: Quick, straightforward implementation\n- medium: Balanced approach with standard testing\n- high: Comprehensive implementation with extensive testing\n- max: Maximum capability with deepest reasoning (Opus 4.6 only)\n- auto: Use the default effort level for your model');
+    return;
+  }
+  if (!args || args === 'current' || args === 'status') {
+    return <ShowCurrentEffort onDone={onDone} />;
+  }
+  const result = executeEffort(args);
+  return <ApplyEffortAndClose result={result} onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMainLoopModel","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","useAppState","useSetAppState","LocalJSXCommandOnDone","EffortValue","getDisplayedEffortLevel","getEffortEnvOverride","getEffortValueDescription","isEffortLevel","toPersistableEffort","updateSettingsForSource","COMMON_HELP_ARGS","EffortCommandResult","message","effortUpdate","value","setEffortValue","effortValue","persistable","undefined","result","effortLevel","error","effort","envOverride","envRaw","process","env","CLAUDE_CODE_EFFORT_LEVEL","description","suffix","showCurrentEffort","appStateEffort","model","effectiveValue","level","unsetEffortLevel","executeEffort","args","normalized","toLowerCase","ShowCurrentEffort","t0","onDone","_temp","s","ApplyEffortAndClose","$","_c","setAppState","t1","t2","prev","useEffect","call","_context","Promise","ReactNode","trim","includes"],"sources":["effort.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { useAppState, useSetAppState } from '../../state/AppState.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport {\n  type EffortValue,\n  getDisplayedEffortLevel,\n  getEffortEnvOverride,\n  getEffortValueDescription,\n  isEffortLevel,\n  toPersistableEffort,\n} from '../../utils/effort.js'\nimport { updateSettingsForSource } from '../../utils/settings/settings.js'\n\nconst COMMON_HELP_ARGS = ['help', '-h', '--help']\n\ntype EffortCommandResult = {\n  message: string\n  effortUpdate?: { value: EffortValue | undefined }\n}\n\nfunction setEffortValue(effortValue: EffortValue): EffortCommandResult {\n  const persistable = toPersistableEffort(effortValue)\n  if (persistable !== undefined) {\n    const result = updateSettingsForSource('userSettings', {\n      effortLevel: persistable,\n    })\n    if (result.error) {\n      return {\n        message: `Failed to set effort level: ${result.error.message}`,\n      }\n    }\n  }\n  logEvent('tengu_effort_command', {\n    effort:\n      effortValue as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n\n  // Env var wins at resolveAppliedEffort time. Only flag it when it actually\n  // conflicts — if env matches what the user just asked for, the outcome is\n  // the same, so \"Set effort to X\" is true and the note is noise.\n  const envOverride = getEffortEnvOverride()\n  if (envOverride !== undefined && envOverride !== effortValue) {\n    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL\n    if (persistable === undefined) {\n      return {\n        message: `Not applied: CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides effort this session, and ${effortValue} is session-only (nothing saved)`,\n        effortUpdate: { value: effortValue },\n      }\n    }\n    return {\n      message: `CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides this session — clear it and ${effortValue} takes over`,\n      effortUpdate: { value: effortValue },\n    }\n  }\n\n  const description = getEffortValueDescription(effortValue)\n  const suffix = persistable !== undefined ? '' : ' (this session only)'\n  return {\n    message: `Set effort level to ${effortValue}${suffix}: ${description}`,\n    effortUpdate: { value: effortValue },\n  }\n}\n\nexport function showCurrentEffort(\n  appStateEffort: EffortValue | undefined,\n  model: string,\n): EffortCommandResult {\n  const envOverride = getEffortEnvOverride()\n  const effectiveValue =\n    envOverride === null ? undefined : (envOverride ?? appStateEffort)\n  if (effectiveValue === undefined) {\n    const level = getDisplayedEffortLevel(model, appStateEffort)\n    return { message: `Effort level: auto (currently ${level})` }\n  }\n  const description = getEffortValueDescription(effectiveValue)\n  return {\n    message: `Current effort level: ${effectiveValue} (${description})`,\n  }\n}\n\nfunction unsetEffortLevel(): EffortCommandResult {\n  const result = updateSettingsForSource('userSettings', {\n    effortLevel: undefined,\n  })\n  if (result.error) {\n    return {\n      message: `Failed to set effort level: ${result.error.message}`,\n    }\n  }\n  logEvent('tengu_effort_command', {\n    effort:\n      'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  // env=auto/unset (null) matches what /effort auto asks for, so only warn\n  // when env is pinning a specific level that will keep overriding.\n  const envOverride = getEffortEnvOverride()\n  if (envOverride !== undefined && envOverride !== null) {\n    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL\n    return {\n      message: `Cleared effort from settings, but CLAUDE_CODE_EFFORT_LEVEL=${envRaw} still controls this session`,\n      effortUpdate: { value: undefined },\n    }\n  }\n  return {\n    message: 'Effort level set to auto',\n    effortUpdate: { value: undefined },\n  }\n}\n\nexport function executeEffort(args: string): EffortCommandResult {\n  const normalized = args.toLowerCase()\n  if (normalized === 'auto' || normalized === 'unset') {\n    return unsetEffortLevel()\n  }\n\n  if (!isEffortLevel(normalized)) {\n    return {\n      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`,\n    }\n  }\n\n  return setEffortValue(normalized)\n}\n\nfunction ShowCurrentEffort({\n  onDone,\n}: {\n  onDone: (result: string) => void\n}): React.ReactNode {\n  const effortValue = useAppState(s => s.effortValue)\n  const model = useMainLoopModel()\n  const { message } = showCurrentEffort(effortValue, model)\n  onDone(message)\n  return null\n}\n\nfunction ApplyEffortAndClose({\n  result,\n  onDone,\n}: {\n  result: EffortCommandResult\n  onDone: (result: string) => void\n}): React.ReactNode {\n  const setAppState = useSetAppState()\n  const { effortUpdate, message } = result\n  React.useEffect(() => {\n    if (effortUpdate) {\n      setAppState(prev => ({\n        ...prev,\n        effortValue: effortUpdate.value,\n      }))\n    }\n    onDone(message)\n  }, [setAppState, effortUpdate, message, onDone])\n  return null\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  _context: unknown,\n  args?: string,\n): Promise<React.ReactNode> {\n  args = args?.trim() || ''\n\n  if (COMMON_HELP_ARGS.includes(args)) {\n    onDone(\n      'Usage: /effort [low|medium|high|max|auto]\\n\\nEffort levels:\\n- low: Quick, straightforward implementation\\n- medium: Balanced approach with standard testing\\n- high: Comprehensive implementation with extensive testing\\n- max: Maximum capability with deepest reasoning (Opus 4.6 only)\\n- auto: Use the default effort level for your model',\n    )\n    return\n  }\n\n  if (!args || args === 'current' || args === 'status') {\n    return <ShowCurrentEffort onDone={onDone} />\n  }\n\n  const result = executeEffort(args)\n  return <ApplyEffortAndClose result={result} onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/effort/index.ts

@@ -0,0 +1,13 @@
+import type { Command } from '../../commands.js'
+import { shouldInferenceConfigCommandBeImmediate } from '../../utils/immediateCommand.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'effort',
+  description: 'Set effort level for model usage',
+  argumentHint: '[low|medium|high|max|auto]',
+  get immediate() {
+    return shouldInferenceConfigCommandBeImmediate()
+  },
+  load: () => import('./effort.js'),
+} satisfies Command

src/commands/env/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/exit/exit.tsx

@@ -0,0 +1,33 @@
+import { feature } from 'bun:bundle';
+import { spawnSync } from 'child_process';
+import sample from 'lodash-es/sample.js';
+import * as React from 'react';
+import { ExitFlow } from '../../components/ExitFlow.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { isBgSession } from '../../utils/concurrentSessions.js';
+import { gracefulShutdown } from '../../utils/gracefulShutdown.js';
+import { getCurrentWorktreeSession } from '../../utils/worktree.js';
+const GOODBYE_MESSAGES = ['Goodbye!', 'See ya!', 'Bye!', 'Catch you later!'];
+function getRandomGoodbyeMessage(): string {
+  return sample(GOODBYE_MESSAGES) ?? 'Goodbye!';
+}
+export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode> {
+  // Inside a `claude --bg` tmux session: detach instead of kill. The REPL
+  // keeps running; `claude attach` can reconnect. Covers /exit, /quit,
+  // ctrl+c, ctrl+d — all funnel through here via REPL's handleExit.
+  if (feature('BG_SESSIONS') && isBgSession()) {
+    onDone();
+    spawnSync('tmux', ['detach-client'], {
+      stdio: 'ignore'
+    });
+    return null;
+  }
+  const showWorktree = getCurrentWorktreeSession() !== null;
+  if (showWorktree) {
+    return <ExitFlow showWorktree={showWorktree} onDone={onDone} onCancel={() => onDone()} />;
+  }
+  onDone(getRandomGoodbyeMessage());
+  await gracefulShutdown(0, 'prompt_input_exit');
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/commands/exit/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const exit = {
+  type: 'local-jsx',
+  name: 'exit',
+  aliases: ['quit'],
+  description: 'Exit the REPL',
+  immediate: true,
+  load: () => import('./exit.js'),
+} satisfies Command
+
+export default exit

src/commands/export/export.tsx

@@ -0,0 +1,91 @@
+import { join } from 'path';
+import React from 'react';
+import { ExportDialog } from '../../components/ExportDialog.js';
+import type { ToolUseContext } from '../../Tool.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import type { Message } from '../../types/message.js';
+import { getCwd } from '../../utils/cwd.js';
+import { renderMessagesToPlainText } from '../../utils/exportRenderer.js';
+import { writeFileSync_DEPRECATED } from '../../utils/slowOperations.js';
+function formatTimestamp(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+  return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
+}
+export function extractFirstPrompt(messages: Message[]): string {
+  const firstUserMessage = messages.find(msg => msg.type === 'user');
+  if (!firstUserMessage || firstUserMessage.type !== 'user') {
+    return '';
+  }
+  const content = firstUserMessage.message?.content;
+  let result = '';
+  if (typeof content === 'string') {
+    result = content.trim();
+  } else if (Array.isArray(content)) {
+    const textContent = content.find(item => item.type === 'text');
+    if (textContent && 'text' in textContent) {
+      result = textContent.text.trim();
+    }
+  }
+
+  // Take first line only and limit length
+  result = result.split('\n')[0] || '';
+  if (result.length > 50) {
+    result = result.substring(0, 49) + '…';
+  }
+  return result;
+}
+export function sanitizeFilename(text: string): string {
+  // Replace special characters with hyphens
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, '') // Remove special chars
+  .replace(/\s+/g, '-') // Replace spaces with hyphens
+  .replace(/-+/g, '-') // Replace multiple hyphens with single
+  .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens
+}
+async function exportWithReactRenderer(context: ToolUseContext): Promise<string> {
+  const tools = context.options.tools || [];
+  return renderMessagesToPlainText(context.messages, tools);
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: ToolUseContext, args: string): Promise<React.ReactNode> {
+  // Render the conversation content
+  const content = await exportWithReactRenderer(context);
+
+  // If args are provided, write directly to file and skip dialog
+  const filename = args.trim();
+  if (filename) {
+    const finalFilename = filename.endsWith('.txt') ? filename : filename.replace(/\.[^.]+$/, '') + '.txt';
+    const filepath = join(getCwd(), finalFilename);
+    try {
+      writeFileSync_DEPRECATED(filepath, content, {
+        encoding: 'utf-8',
+        flush: true
+      });
+      onDone(`Conversation exported to: ${filepath}`);
+      return null;
+    } catch (error) {
+      onDone(`Failed to export conversation: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      return null;
+    }
+  }
+
+  // Generate default filename from first prompt or timestamp
+  const firstPrompt = extractFirstPrompt(context.messages);
+  const timestamp = formatTimestamp(new Date());
+  let defaultFilename: string;
+  if (firstPrompt) {
+    const sanitized = sanitizeFilename(firstPrompt);
+    defaultFilename = sanitized ? `${timestamp}-${sanitized}.txt` : `conversation-${timestamp}.txt`;
+  } else {
+    defaultFilename = `conversation-${timestamp}.txt`;
+  }
+
+  // Return the dialog component when no args provided
+  return <ExportDialog content={content} defaultFilename={defaultFilename} onDone={result => {
+    onDone(result.message);
+  }} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","React","ExportDialog","ToolUseContext","LocalJSXCommandOnDone","Message","getCwd","renderMessagesToPlainText","writeFileSync_DEPRECATED","formatTimestamp","date","Date","year","getFullYear","month","String","getMonth","padStart","day","getDate","hours","getHours","minutes","getMinutes","seconds","getSeconds","extractFirstPrompt","messages","firstUserMessage","find","msg","type","content","message","result","trim","Array","isArray","textContent","item","text","split","length","substring","sanitizeFilename","toLowerCase","replace","exportWithReactRenderer","context","Promise","tools","options","call","onDone","args","ReactNode","filename","finalFilename","endsWith","filepath","encoding","flush","error","Error","firstPrompt","timestamp","defaultFilename","sanitized"],"sources":["export.tsx"],"sourcesContent":["import { join } from 'path'\nimport React from 'react'\nimport { ExportDialog } from '../../components/ExportDialog.js'\nimport type { ToolUseContext } from '../../Tool.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport type { Message } from '../../types/message.js'\nimport { getCwd } from '../../utils/cwd.js'\nimport { renderMessagesToPlainText } from '../../utils/exportRenderer.js'\nimport { writeFileSync_DEPRECATED } from '../../utils/slowOperations.js'\n\nfunction formatTimestamp(date: Date): string {\n  const year = date.getFullYear()\n  const month = String(date.getMonth() + 1).padStart(2, '0')\n  const day = String(date.getDate()).padStart(2, '0')\n  const hours = String(date.getHours()).padStart(2, '0')\n  const minutes = String(date.getMinutes()).padStart(2, '0')\n  const seconds = String(date.getSeconds()).padStart(2, '0')\n  return `${year}-${month}-${day}-${hours}${minutes}${seconds}`\n}\n\nexport function extractFirstPrompt(messages: Message[]): string {\n  const firstUserMessage = messages.find(msg => msg.type === 'user')\n\n  if (!firstUserMessage || firstUserMessage.type !== 'user') {\n    return ''\n  }\n\n  const content = firstUserMessage.message?.content\n  let result = ''\n\n  if (typeof content === 'string') {\n    result = content.trim()\n  } else if (Array.isArray(content)) {\n    const textContent = content.find(item => item.type === 'text')\n    if (textContent && 'text' in textContent) {\n      result = textContent.text.trim()\n    }\n  }\n\n  // Take first line only and limit length\n  result = result.split('\\n')[0] || ''\n  if (result.length > 50) {\n    result = result.substring(0, 49) + '…'\n  }\n\n  return result\n}\n\nexport function sanitizeFilename(text: string): string {\n  // Replace special characters with hyphens\n  return text\n    .toLowerCase()\n    .replace(/[^a-z0-9\\s-]/g, '') // Remove special chars\n    .replace(/\\s+/g, '-') // Replace spaces with hyphens\n    .replace(/-+/g, '-') // Replace multiple hyphens with single\n    .replace(/^-|-$/g, '') // Remove leading/trailing hyphens\n}\n\nasync function exportWithReactRenderer(\n  context: ToolUseContext,\n): Promise<string> {\n  const tools = context.options.tools || []\n  return renderMessagesToPlainText(context.messages, tools)\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: ToolUseContext,\n  args: string,\n): Promise<React.ReactNode> {\n  // Render the conversation content\n  const content = await exportWithReactRenderer(context)\n\n  // If args are provided, write directly to file and skip dialog\n  const filename = args.trim()\n  if (filename) {\n    const finalFilename = filename.endsWith('.txt')\n      ? filename\n      : filename.replace(/\\.[^.]+$/, '') + '.txt'\n    const filepath = join(getCwd(), finalFilename)\n\n    try {\n      writeFileSync_DEPRECATED(filepath, content, {\n        encoding: 'utf-8',\n        flush: true,\n      })\n      onDone(`Conversation exported to: ${filepath}`)\n      return null\n    } catch (error) {\n      onDone(\n        `Failed to export conversation: ${error instanceof Error ? error.message : 'Unknown error'}`,\n      )\n      return null\n    }\n  }\n\n  // Generate default filename from first prompt or timestamp\n  const firstPrompt = extractFirstPrompt(context.messages)\n  const timestamp = formatTimestamp(new Date())\n\n  let defaultFilename: string\n  if (firstPrompt) {\n    const sanitized = sanitizeFilename(firstPrompt)\n    defaultFilename = sanitized\n      ? `${timestamp}-${sanitized}.txt`\n      : `conversation-${timestamp}.txt`\n  } else {\n    defaultFilename = `conversation-${timestamp}.txt`\n  }\n\n  // Return the dialog component when no args provided\n  return (\n    <ExportDialog\n      content={content}\n      defaultFilename={defaultFilename}\n      onDone={result => {\n        onDone(result.message)\n      }}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/export/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const exportCommand = {
+  type: 'local-jsx',
+  name: 'export',
+  description: 'Export the current conversation to a file or clipboard',
+  argumentHint: '[filename]',
+  load: () => import('./export.js'),
+} satisfies Command
+
+export default exportCommand

src/commands/extra-usage/extra-usage-core.ts

@@ -0,0 +1,118 @@
+import {
+  checkAdminRequestEligibility,
+  createAdminRequest,
+  getMyAdminRequests,
+} from '../../services/api/adminRequests.js'
+import { invalidateOverageCreditGrantCache } from '../../services/api/overageCreditGrant.js'
+import { type ExtraUsage, fetchUtilization } from '../../services/api/usage.js'
+import { getSubscriptionType } from '../../utils/auth.js'
+import { hasClaudeAiBillingAccess } from '../../utils/billing.js'
+import { openBrowser } from '../../utils/browser.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+import { logError } from '../../utils/log.js'
+
+type ExtraUsageResult =
+  | { type: 'message'; value: string }
+  | { type: 'browser-opened'; url: string; opened: boolean }
+
+export async function runExtraUsage(): Promise<ExtraUsageResult> {
+  if (!getGlobalConfig().hasVisitedExtraUsage) {
+    saveGlobalConfig(prev => ({ ...prev, hasVisitedExtraUsage: true }))
+  }
+  // Invalidate only the current org's entry so a follow-up read refetches
+  // the granted state. Separate from the visited flag since users may run
+  // /extra-usage more than once while iterating on the claim flow.
+  invalidateOverageCreditGrantCache()
+
+  const subscriptionType = getSubscriptionType()
+  const isTeamOrEnterprise =
+    subscriptionType === 'team' || subscriptionType === 'enterprise'
+  const hasBillingAccess = hasClaudeAiBillingAccess()
+
+  if (!hasBillingAccess && isTeamOrEnterprise) {
+    // Mirror apps/claude-ai useHasUnlimitedOverage(): if overage is enabled
+    // with no monthly cap, there is nothing to request. On fetch error, fall
+    // through and let the user ask (matching web's "err toward show" behavior).
+    let extraUsage: ExtraUsage | null | undefined
+    try {
+      const utilization = await fetchUtilization()
+      extraUsage = utilization?.extra_usage
+    } catch (error) {
+      logError(error as Error)
+    }
+
+    if (extraUsage?.is_enabled && extraUsage.monthly_limit === null) {
+      return {
+        type: 'message',
+        value:
+          'Your organization already has unlimited extra usage. No request needed.',
+      }
+    }
+
+    try {
+      const eligibility = await checkAdminRequestEligibility('limit_increase')
+      if (eligibility?.is_allowed === false) {
+        return {
+          type: 'message',
+          value: 'Please contact your admin to manage extra usage settings.',
+        }
+      }
+    } catch (error) {
+      logError(error as Error)
+      // If eligibility check fails, continue — the create endpoint will enforce if necessary
+    }
+
+    try {
+      const pendingOrDismissedRequests = await getMyAdminRequests(
+        'limit_increase',
+        ['pending', 'dismissed'],
+      )
+      if (pendingOrDismissedRequests && pendingOrDismissedRequests.length > 0) {
+        return {
+          type: 'message',
+          value:
+            'You have already submitted a request for extra usage to your admin.',
+        }
+      }
+    } catch (error) {
+      logError(error as Error)
+      // Fall through to creating a new request below
+    }
+
+    try {
+      await createAdminRequest({
+        request_type: 'limit_increase',
+        details: null,
+      })
+      return {
+        type: 'message',
+        value: extraUsage?.is_enabled
+          ? 'Request sent to your admin to increase extra usage.'
+          : 'Request sent to your admin to enable extra usage.',
+      }
+    } catch (error) {
+      logError(error as Error)
+      // Fall through to generic message below
+    }
+
+    return {
+      type: 'message',
+      value: 'Please contact your admin to manage extra usage settings.',
+    }
+  }
+
+  const url = isTeamOrEnterprise
+    ? 'https://claude.ai/admin-settings/usage'
+    : 'https://claude.ai/settings/usage'
+
+  try {
+    const opened = await openBrowser(url)
+    return { type: 'browser-opened', url, opened }
+  } catch (error) {
+    logError(error as Error)
+    return {
+      type: 'message',
+      value: `Failed to open browser. Please visit ${url} to manage extra usage.`,
+    }
+  }
+}

src/commands/extra-usage/extra-usage-noninteractive.ts

@@ -0,0 +1,16 @@
+import { runExtraUsage } from './extra-usage-core.js'
+
+export async function call(): Promise<{ type: 'text'; value: string }> {
+  const result = await runExtraUsage()
+
+  if (result.type === 'message') {
+    return { type: 'text', value: result.value }
+  }
+
+  return {
+    type: 'text',
+    value: result.opened
+      ? `Browser opened to manage extra usage. If it didn't open, visit: ${result.url}`
+      : `Please visit ${result.url} to manage extra usage.`,
+  }
+}

src/commands/extra-usage/index.ts

@@ -0,0 +1,31 @@
+import { getIsNonInteractiveSession } from '../../bootstrap/state.js'
+import type { Command } from '../../commands.js'
+import { isOverageProvisioningAllowed } from '../../utils/auth.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+function isExtraUsageAllowed(): boolean {
+  if (isEnvTruthy(process.env.DISABLE_EXTRA_USAGE_COMMAND)) {
+    return false
+  }
+  return isOverageProvisioningAllowed()
+}
+
+export const extraUsage = {
+  type: 'local-jsx',
+  name: 'extra-usage',
+  description: 'Configure extra usage to keep working when limits are hit',
+  isEnabled: () => isExtraUsageAllowed() && !getIsNonInteractiveSession(),
+  load: () => import('./extra-usage.js'),
+} satisfies Command
+
+export const extraUsageNonInteractive = {
+  type: 'local',
+  name: 'extra-usage',
+  supportsNonInteractive: true,
+  description: 'Configure extra usage to keep working when limits are hit',
+  isEnabled: () => isExtraUsageAllowed() && getIsNonInteractiveSession(),
+  get isHidden() {
+    return !getIsNonInteractiveSession()
+  },
+  load: () => import('./extra-usage-noninteractive.js'),
+} satisfies Command

src/commands/fast/fast.tsx

@@ -0,0 +1,269 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useState } from 'react';
+import type { CommandResultDisplay, LocalJSXCommandContext } from '../../commands.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { FastIcon, getFastIconString } from '../../components/FastIcon.js';
+import { Box, Link, Text } from '../../ink.js';
+import { useKeybindings } from '../../keybindings/useKeybinding.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
+import { type AppState, useAppState, useSetAppState } from '../../state/AppState.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { clearFastModeCooldown, FAST_MODE_MODEL_DISPLAY, getFastModeModel, getFastModeRuntimeState, getFastModeUnavailableReason, isFastModeEnabled, isFastModeSupportedByModel, prefetchFastModeStatus } from '../../utils/fastMode.js';
+import { formatDuration } from '../../utils/format.js';
+import { formatModelPricing, getOpus46CostTier } from '../../utils/modelCost.js';
+import { updateSettingsForSource } from '../../utils/settings/settings.js';
+function applyFastMode(enable: boolean, setAppState: (f: (prev: AppState) => AppState) => void): void {
+  clearFastModeCooldown();
+  updateSettingsForSource('userSettings', {
+    fastMode: enable ? true : undefined
+  });
+  if (enable) {
+    setAppState(prev => {
+      // Only switch model if current model doesn't support fast mode
+      const needsModelSwitch = !isFastModeSupportedByModel(prev.mainLoopModel);
+      return {
+        ...prev,
+        ...(needsModelSwitch ? {
+          mainLoopModel: getFastModeModel(),
+          mainLoopModelForSession: null
+        } : {}),
+        fastMode: true
+      };
+    });
+  } else {
+    setAppState(prev => ({
+      ...prev,
+      fastMode: false
+    }));
+  }
+}
+export function FastModePicker(t0) {
+  const $ = _c(30);
+  const {
+    onDone,
+    unavailableReason
+  } = t0;
+  const model = useAppState(_temp);
+  const initialFastMode = useAppState(_temp2);
+  const setAppState = useSetAppState();
+  const [enableFastMode, setEnableFastMode] = useState(initialFastMode ?? false);
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = getFastModeRuntimeState();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const runtimeState = t1;
+  const isCooldown = runtimeState.status === "cooldown";
+  const isUnavailable = unavailableReason !== null;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = formatModelPricing(getOpus46CostTier(true));
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const pricing = t2;
+  let t3;
+  if ($[2] !== enableFastMode || $[3] !== isUnavailable || $[4] !== model || $[5] !== onDone || $[6] !== setAppState) {
+    t3 = function handleConfirm() {
+      if (isUnavailable) {
+        return;
+      }
+      applyFastMode(enableFastMode, setAppState);
+      logEvent("tengu_fast_mode_toggled", {
+        enabled: enableFastMode,
+        source: "picker" as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      if (enableFastMode) {
+        const fastIcon = getFastIconString(enableFastMode);
+        const modelUpdated = !isFastModeSupportedByModel(model) ? ` · model set to ${FAST_MODE_MODEL_DISPLAY}` : "";
+        onDone(`${fastIcon} Fast mode ON${modelUpdated} · ${pricing}`);
+      } else {
+        setAppState(_temp3);
+        onDone("Fast mode OFF");
+      }
+    };
+    $[2] = enableFastMode;
+    $[3] = isUnavailable;
+    $[4] = model;
+    $[5] = onDone;
+    $[6] = setAppState;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  const handleConfirm = t3;
+  let t4;
+  if ($[8] !== initialFastMode || $[9] !== isUnavailable || $[10] !== onDone || $[11] !== setAppState) {
+    t4 = function handleCancel() {
+      if (isUnavailable) {
+        if (initialFastMode) {
+          applyFastMode(false, setAppState);
+        }
+        onDone("Fast mode OFF", {
+          display: "system"
+        });
+        return;
+      }
+      const message = initialFastMode ? `${getFastIconString()} Kept Fast mode ON` : "Kept Fast mode OFF";
+      onDone(message, {
+        display: "system"
+      });
+    };
+    $[8] = initialFastMode;
+    $[9] = isUnavailable;
+    $[10] = onDone;
+    $[11] = setAppState;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  const handleCancel = t4;
+  let t5;
+  if ($[13] !== isUnavailable) {
+    t5 = function handleToggle() {
+      if (isUnavailable) {
+        return;
+      }
+      setEnableFastMode(_temp4);
+    };
+    $[13] = isUnavailable;
+    $[14] = t5;
+  } else {
+    t5 = $[14];
+  }
+  const handleToggle = t5;
+  let t6;
+  if ($[15] !== handleConfirm || $[16] !== handleToggle) {
+    t6 = {
+      "confirm:yes": handleConfirm,
+      "confirm:nextField": handleToggle,
+      "confirm:next": handleToggle,
+      "confirm:previous": handleToggle,
+      "confirm:cycleMode": handleToggle,
+      "confirm:toggle": handleToggle
+    };
+    $[15] = handleConfirm;
+    $[16] = handleToggle;
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  let t7;
+  if ($[18] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = {
+      context: "Confirmation"
+    };
+    $[18] = t7;
+  } else {
+    t7 = $[18];
+  }
+  useKeybindings(t6, t7);
+  let t8;
+  if ($[19] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = <Text><FastIcon cooldown={isCooldown} /> Fast mode (research preview)</Text>;
+    $[19] = t8;
+  } else {
+    t8 = $[19];
+  }
+  const title = t8;
+  let t9;
+  if ($[20] !== isUnavailable) {
+    t9 = exitState => exitState.pending ? <Text>Press {exitState.keyName} again to exit</Text> : isUnavailable ? <Text>Esc to cancel</Text> : <Text>Tab to toggle · Enter to confirm · Esc to cancel</Text>;
+    $[20] = isUnavailable;
+    $[21] = t9;
+  } else {
+    t9 = $[21];
+  }
+  let t10;
+  if ($[22] !== enableFastMode || $[23] !== unavailableReason) {
+    t10 = unavailableReason ? <Box marginLeft={2}><Text color="error">{unavailableReason}</Text></Box> : <><Box flexDirection="column" gap={0} marginLeft={2}><Box flexDirection="row" gap={2}><Text bold={true}>Fast mode</Text><Text color={enableFastMode ? "fastMode" : undefined} bold={enableFastMode}>{enableFastMode ? "ON " : "OFF"}</Text><Text dimColor={true}>{pricing}</Text></Box></Box>{isCooldown && runtimeState.status === "cooldown" && <Box marginLeft={2}><Text color="warning">{runtimeState.reason === "overloaded" ? "Fast mode overloaded and is temporarily unavailable" : "You've hit your fast limit"}{" \xB7 resets in "}{formatDuration(runtimeState.resetAt - Date.now(), {
+            hideTrailingZeros: true
+          })}</Text></Box>}</>;
+    $[22] = enableFastMode;
+    $[23] = unavailableReason;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  let t11;
+  if ($[25] === Symbol.for("react.memo_cache_sentinel")) {
+    t11 = <Text dimColor={true}>Learn more:{" "}<Link url="https://code.claude.com/docs/en/fast-mode">https://code.claude.com/docs/en/fast-mode</Link></Text>;
+    $[25] = t11;
+  } else {
+    t11 = $[25];
+  }
+  let t12;
+  if ($[26] !== handleCancel || $[27] !== t10 || $[28] !== t9) {
+    t12 = <Dialog title={title} subtitle={`High-speed mode for ${FAST_MODE_MODEL_DISPLAY}. Billed as extra usage at a premium rate. Separate rate limits apply.`} onCancel={handleCancel} color="fastMode" inputGuide={t9}>{t10}{t11}</Dialog>;
+    $[26] = handleCancel;
+    $[27] = t10;
+    $[28] = t9;
+    $[29] = t12;
+  } else {
+    t12 = $[29];
+  }
+  return t12;
+}
+function _temp4(prev_0) {
+  return !prev_0;
+}
+function _temp3(prev) {
+  return {
+    ...prev,
+    fastMode: false
+  };
+}
+function _temp2(s_0) {
+  return s_0.fastMode;
+}
+function _temp(s) {
+  return s.mainLoopModel;
+}
+async function handleFastModeShortcut(enable: boolean, getAppState: () => AppState, setAppState: (f: (prev: AppState) => AppState) => void): Promise<string> {
+  const unavailableReason = getFastModeUnavailableReason();
+  if (unavailableReason) {
+    return `Fast mode unavailable: ${unavailableReason}`;
+  }
+  const {
+    mainLoopModel
+  } = getAppState();
+  applyFastMode(enable, setAppState);
+  logEvent('tengu_fast_mode_toggled', {
+    enabled: enable,
+    source: 'shortcut' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+  });
+  if (enable) {
+    const fastIcon = getFastIconString(true);
+    const modelUpdated = !isFastModeSupportedByModel(mainLoopModel) ? ` · model set to ${FAST_MODE_MODEL_DISPLAY}` : '';
+    const pricing = formatModelPricing(getOpus46CostTier(true));
+    return `${fastIcon} Fast mode ON${modelUpdated} · ${pricing}`;
+  } else {
+    return `Fast mode OFF`;
+  }
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext, args?: string): Promise<React.ReactNode | null> {
+  if (!isFastModeEnabled()) {
+    return null;
+  }
+
+  // Fetch org fast mode status before showing the picker. We must know
+  // whether the org has disabled fast mode before allowing any toggle.
+  // If a startup prefetch is already in flight, this awaits it.
+  await prefetchFastModeStatus();
+  const arg = args?.trim().toLowerCase();
+  if (arg === 'on' || arg === 'off') {
+    const result = await handleFastModeShortcut(arg === 'on', context.getAppState, context.setAppState);
+    onDone(result);
+    return null;
+  }
+  const unavailableReason = getFastModeUnavailableReason();
+  logEvent('tengu_fast_mode_picker_shown', {
+    unavailable_reason: (unavailableReason ?? '') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+  });
+  return <FastModePicker onDone={onDone} unavailableReason={unavailableReason} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","CommandResultDisplay","LocalJSXCommandContext","Dialog","FastIcon","getFastIconString","Box","Link","Text","useKeybindings","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","AppState","useAppState","useSetAppState","LocalJSXCommandOnDone","clearFastModeCooldown","FAST_MODE_MODEL_DISPLAY","getFastModeModel","getFastModeRuntimeState","getFastModeUnavailableReason","isFastModeEnabled","isFastModeSupportedByModel","prefetchFastModeStatus","formatDuration","formatModelPricing","getOpus46CostTier","updateSettingsForSource","applyFastMode","enable","setAppState","f","prev","fastMode","undefined","needsModelSwitch","mainLoopModel","mainLoopModelForSession","FastModePicker","t0","$","_c","onDone","unavailableReason","model","_temp","initialFastMode","_temp2","enableFastMode","setEnableFastMode","t1","Symbol","for","runtimeState","isCooldown","status","isUnavailable","t2","pricing","t3","handleConfirm","enabled","source","fastIcon","modelUpdated","_temp3","t4","handleCancel","display","message","t5","handleToggle","_temp4","t6","t7","context","t8","title","t9","exitState","pending","keyName","t10","reason","resetAt","Date","now","hideTrailingZeros","t11","t12","prev_0","s_0","s","handleFastModeShortcut","getAppState","Promise","call","args","ReactNode","arg","trim","toLowerCase","result","unavailable_reason"],"sources":["fast.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useState } from 'react'\nimport type {\n  CommandResultDisplay,\n  LocalJSXCommandContext,\n} from '../../commands.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { FastIcon, getFastIconString } from '../../components/FastIcon.js'\nimport { Box, Link, Text } from '../../ink.js'\nimport { useKeybindings } from '../../keybindings/useKeybinding.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport {\n  type AppState,\n  useAppState,\n  useSetAppState,\n} from '../../state/AppState.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport {\n  clearFastModeCooldown,\n  FAST_MODE_MODEL_DISPLAY,\n  getFastModeModel,\n  getFastModeRuntimeState,\n  getFastModeUnavailableReason,\n  isFastModeEnabled,\n  isFastModeSupportedByModel,\n  prefetchFastModeStatus,\n} from '../../utils/fastMode.js'\nimport { formatDuration } from '../../utils/format.js'\nimport { formatModelPricing, getOpus46CostTier } from '../../utils/modelCost.js'\nimport { updateSettingsForSource } from '../../utils/settings/settings.js'\n\nfunction applyFastMode(\n  enable: boolean,\n  setAppState: (f: (prev: AppState) => AppState) => void,\n): void {\n  clearFastModeCooldown()\n  updateSettingsForSource('userSettings', {\n    fastMode: enable ? true : undefined,\n  })\n  if (enable) {\n    setAppState(prev => {\n      // Only switch model if current model doesn't support fast mode\n      const needsModelSwitch = !isFastModeSupportedByModel(prev.mainLoopModel)\n      return {\n        ...prev,\n        ...(needsModelSwitch\n          ? { mainLoopModel: getFastModeModel(), mainLoopModelForSession: null }\n          : {}),\n        fastMode: true,\n      }\n    })\n  } else {\n    setAppState(prev => ({ ...prev, fastMode: false }))\n  }\n}\n\nexport function FastModePicker({\n  onDone,\n  unavailableReason,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n  unavailableReason: string | null\n}): React.ReactNode {\n  const model = useAppState(s => s.mainLoopModel)\n  const initialFastMode = useAppState(s => s.fastMode)\n  const setAppState = useSetAppState()\n  const [enableFastMode, setEnableFastMode] = useState(initialFastMode ?? false)\n  const runtimeState = getFastModeRuntimeState()\n  const isCooldown = runtimeState.status === 'cooldown'\n  const isUnavailable = unavailableReason !== null\n  const pricing = formatModelPricing(getOpus46CostTier(true))\n\n  function handleConfirm(): void {\n    if (isUnavailable) return\n    applyFastMode(enableFastMode, setAppState)\n    logEvent('tengu_fast_mode_toggled', {\n      enabled: enableFastMode,\n      source:\n        'picker' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    if (enableFastMode) {\n      const fastIcon = getFastIconString(enableFastMode)\n      const modelUpdated = !isFastModeSupportedByModel(model)\n        ? ` · model set to ${FAST_MODE_MODEL_DISPLAY}`\n        : ''\n      onDone(`${fastIcon} Fast mode ON${modelUpdated} · ${pricing}`)\n    } else {\n      setAppState(prev => ({ ...prev, fastMode: false }))\n      onDone(`Fast mode OFF`)\n    }\n  }\n\n  function handleCancel(): void {\n    if (isUnavailable) {\n      // Ensure fast mode is off if the org has disabled it\n      if (initialFastMode) {\n        applyFastMode(false, setAppState)\n      }\n      onDone('Fast mode OFF', { display: 'system' })\n      return\n    }\n    const message = initialFastMode\n      ? `${getFastIconString()} Kept Fast mode ON`\n      : `Kept Fast mode OFF`\n    onDone(message, { display: 'system' })\n  }\n\n  function handleToggle(): void {\n    if (isUnavailable) return\n    setEnableFastMode(prev => !prev)\n  }\n\n  useKeybindings(\n    {\n      'confirm:yes': handleConfirm,\n      'confirm:nextField': handleToggle,\n      'confirm:next': handleToggle,\n      'confirm:previous': handleToggle,\n      'confirm:cycleMode': handleToggle,\n      'confirm:toggle': handleToggle,\n    },\n    { context: 'Confirmation' },\n  )\n\n  const title = (\n    <Text>\n      <FastIcon cooldown={isCooldown} /> Fast mode (research preview)\n    </Text>\n  )\n\n  return (\n    <Dialog\n      title={title}\n      subtitle={`High-speed mode for ${FAST_MODE_MODEL_DISPLAY}. Billed as extra usage at a premium rate. Separate rate limits apply.`}\n      onCancel={handleCancel}\n      color=\"fastMode\"\n      inputGuide={exitState =>\n        exitState.pending ? (\n          <Text>Press {exitState.keyName} again to exit</Text>\n        ) : isUnavailable ? (\n          <Text>Esc to cancel</Text>\n        ) : (\n          <Text>Tab to toggle · Enter to confirm · Esc to cancel</Text>\n        )\n      }\n    >\n      {unavailableReason ? (\n        <Box marginLeft={2}>\n          <Text color=\"error\">{unavailableReason}</Text>\n        </Box>\n      ) : (\n        <>\n          <Box flexDirection=\"column\" gap={0} marginLeft={2}>\n            <Box flexDirection=\"row\" gap={2}>\n              <Text bold>Fast mode</Text>\n              <Text\n                color={enableFastMode ? 'fastMode' : undefined}\n                bold={enableFastMode}\n              >\n                {enableFastMode ? 'ON ' : 'OFF'}\n              </Text>\n              <Text dimColor>{pricing}</Text>\n            </Box>\n          </Box>\n\n          {isCooldown && runtimeState.status === 'cooldown' && (\n            <Box marginLeft={2}>\n              <Text color=\"warning\">\n                {runtimeState.reason === 'overloaded'\n                  ? 'Fast mode overloaded and is temporarily unavailable'\n                  : \"You've hit your fast limit\"}\n                {' · resets in '}\n                {formatDuration(runtimeState.resetAt - Date.now(), {\n                  hideTrailingZeros: true,\n                })}\n              </Text>\n            </Box>\n          )}\n        </>\n      )}\n      <Text dimColor>\n        Learn more:{' '}\n        <Link url=\"https://code.claude.com/docs/en/fast-mode\">\n          https://code.claude.com/docs/en/fast-mode\n        </Link>\n      </Text>\n    </Dialog>\n  )\n}\n\nasync function handleFastModeShortcut(\n  enable: boolean,\n  getAppState: () => AppState,\n  setAppState: (f: (prev: AppState) => AppState) => void,\n): Promise<string> {\n  const unavailableReason = getFastModeUnavailableReason()\n  if (unavailableReason) {\n    return `Fast mode unavailable: ${unavailableReason}`\n  }\n\n  const { mainLoopModel } = getAppState()\n  applyFastMode(enable, setAppState)\n  logEvent('tengu_fast_mode_toggled', {\n    enabled: enable,\n    source:\n      'shortcut' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n\n  if (enable) {\n    const fastIcon = getFastIconString(true)\n    const modelUpdated = !isFastModeSupportedByModel(mainLoopModel)\n      ? ` · model set to ${FAST_MODE_MODEL_DISPLAY}`\n      : ''\n    const pricing = formatModelPricing(getOpus46CostTier(true))\n    return `${fastIcon} Fast mode ON${modelUpdated} · ${pricing}`\n  } else {\n    return `Fast mode OFF`\n  }\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: LocalJSXCommandContext,\n  args?: string,\n): Promise<React.ReactNode | null> {\n  if (!isFastModeEnabled()) {\n    return null\n  }\n\n  // Fetch org fast mode status before showing the picker. We must know\n  // whether the org has disabled fast mode before allowing any toggle.\n  // If a startup prefetch is already in flight, this awaits it.\n  await prefetchFastModeStatus()\n\n  const arg = args?.trim().toLowerCase()\n  if (arg === 'on' || arg === 'off') {\n    const result = await handleFastModeShortcut(\n      arg === 'on',\n      context.getAppState,\n      context.setAppState,\n    )\n    onDone(result)\n    return null\n  }\n\n  const unavailableReason = getFastModeUnavailableReason()\n  logEvent('tengu_fast_mode_picker_shown', {\n    unavailable_reason: (unavailableReason ??\n      '') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  return (\n    <FastModePicker onDone={onDone} unavailableReason={unavailableReason} />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/feedback/feedback.tsx

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import type { CommandResultDisplay, LocalJSXCommandContext } from '../../commands.js';
+import { Feedback } from '../../components/Feedback.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import type { Message } from '../../types/message.js';
+
+// Shared function to render the Feedback component
+export function renderFeedbackComponent(onDone: (result?: string, options?: {
+  display?: CommandResultDisplay;
+}) => void, abortSignal: AbortSignal, messages: Message[], initialDescription: string = '', backgroundTasks: {
+  [taskId: string]: {
+    type: string;
+    identity?: {
+      agentId: string;
+    };
+    messages?: Message[];
+  };
+} = {}): React.ReactNode {
+  return <Feedback abortSignal={abortSignal} messages={messages} initialDescription={initialDescription} onDone={onDone} backgroundTasks={backgroundTasks} />;
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext, args?: string): Promise<React.ReactNode> {
+  const initialDescription = args || '';
+  return renderFeedbackComponent(onDone, context.abortController.signal, context.messages, initialDescription);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/commands/feedback/index.ts

@@ -0,0 +1,26 @@
+import type { Command } from '../../commands.js'
+import { isPolicyAllowed } from '../../services/policyLimits/index.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { isEssentialTrafficOnly } from '../../utils/privacyLevel.js'
+
+const feedback = {
+  aliases: ['bug'],
+  type: 'local-jsx',
+  name: 'feedback',
+  description: `Submit feedback about Claude Code`,
+  argumentHint: '[report]',
+  isEnabled: () =>
+    !(
+      isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) ||
+      isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) ||
+      isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY) ||
+      isEnvTruthy(process.env.DISABLE_FEEDBACK_COMMAND) ||
+      isEnvTruthy(process.env.DISABLE_BUG_COMMAND) ||
+      isEssentialTrafficOnly() ||
+      process.env.USER_TYPE === 'ant' ||
+      !isPolicyAllowed('allow_product_feedback')
+    ),
+  load: () => import('./feedback.js'),
+} satisfies Command
+
+export default feedback

src/commands/files/files.ts

@@ -0,0 +1,19 @@
+import { relative } from 'path'
+import type { ToolUseContext } from '../../Tool.js'
+import type { LocalCommandResult } from '../../types/command.js'
+import { getCwd } from '../../utils/cwd.js'
+import { cacheKeys } from '../../utils/fileStateCache.js'
+
+export async function call(
+  _args: string,
+  context: ToolUseContext,
+): Promise<LocalCommandResult> {
+  const files = context.readFileState ? cacheKeys(context.readFileState) : []
+
+  if (files.length === 0) {
+    return { type: 'text' as const, value: 'No files in context' }
+  }
+
+  const fileList = files.map(file => relative(getCwd(), file)).join('\n')
+  return { type: 'text' as const, value: `Files in context:\n${fileList}` }
+}

src/commands/files/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const files = {
+  type: 'local',
+  name: 'files',
+  description: 'List all files currently in context',
+  isEnabled: () => process.env.USER_TYPE === 'ant',
+  supportsNonInteractive: true,
+  load: () => import('./files.js'),
+} satisfies Command
+
+export default files

src/commands/good-claude/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/heapdump/heapdump.ts

@@ -0,0 +1,17 @@
+import { performHeapDump } from '../../utils/heapDumpService.js'
+
+export async function call(): Promise<{ type: 'text'; value: string }> {
+  const result = await performHeapDump()
+
+  if (!result.success) {
+    return {
+      type: 'text',
+      value: `Failed to create heap dump: ${result.error}`,
+    }
+  }
+
+  return {
+    type: 'text',
+    value: `${result.heapPath}\n${result.diagPath}`,
+  }
+}

src/commands/heapdump/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const heapDump = {
+  type: 'local',
+  name: 'heapdump',
+  description: 'Dump the JS heap to ~/Desktop',
+  isHidden: true,
+  supportsNonInteractive: true,
+  load: () => import('./heapdump.js'),
+} satisfies Command
+
+export default heapDump

src/commands/help/help.tsx

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { HelpV2 } from '../../components/HelpV2/HelpV2.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+export const call: LocalJSXCommandCall = async (onDone, {
+  options: {
+    commands
+  }
+}) => {
+  return <HelpV2 commands={commands} onClose={onDone} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkhlbHBWMiIsIkxvY2FsSlNYQ29tbWFuZENhbGwiLCJjYWxsIiwib25Eb25lIiwib3B0aW9ucyIsImNvbW1hbmRzIl0sInNvdXJjZXMiOlsiaGVscC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSAncmVhY3QnXG5pbXBvcnQgeyBIZWxwVjIgfSBmcm9tICcuLi8uLi9jb21wb25lbnRzL0hlbHBWMi9IZWxwVjIuanMnXG5pbXBvcnQgdHlwZSB7IExvY2FsSlNYQ29tbWFuZENhbGwgfSBmcm9tICcuLi8uLi90eXBlcy9jb21tYW5kLmpzJ1xuXG5leHBvcnQgY29uc3QgY2FsbDogTG9jYWxKU1hDb21tYW5kQ2FsbCA9IGFzeW5jIChcbiAgb25Eb25lLFxuICB7IG9wdGlvbnM6IHsgY29tbWFuZHMgfSB9LFxuKSA9PiB7XG4gIHJldHVybiA8SGVscFYyIGNvbW1hbmRzPXtjb21tYW5kc30gb25DbG9zZT17b25Eb25lfSAvPlxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLEtBQUssTUFBTSxPQUFPO0FBQzlCLFNBQVNDLE1BQU0sUUFBUSxtQ0FBbUM7QUFDMUQsY0FBY0MsbUJBQW1CLFFBQVEsd0JBQXdCO0FBRWpFLE9BQU8sTUFBTUMsSUFBSSxFQUFFRCxtQkFBbUIsR0FBRyxNQUFBQyxDQUN2Q0MsTUFBTSxFQUNOO0VBQUVDLE9BQU8sRUFBRTtJQUFFQztFQUFTO0FBQUUsQ0FBQyxLQUN0QjtFQUNILE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUNBLFFBQVEsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDRixNQUFNLENBQUMsR0FBRztBQUN4RCxDQUFDIiwiaWdub3JlTGlzdCI6W119