@xelauvas/xela-cli 0.1.0

package/src/commands/bridge-kick.ts

@@ -0,0 +1,200 @@
+import { getBridgeDebugHandle } from '../bridge/bridgeDebug.js'
+import type { Command } from '../commands.js'
+import type { LocalCommandCall } from '../types/command.js'
+
+/**
+ * Ant-only: inject bridge failure states to manually test recovery paths.
+ *
+ *   /bridge-kick close 1002            — fire ws_closed with code 1002
+ *   /bridge-kick close 1006            — fire ws_closed with code 1006
+ *   /bridge-kick poll 404              — next poll throws 404/not_found_error
+ *   /bridge-kick poll 404 <type>       — next poll throws 404 with error_type
+ *   /bridge-kick poll 401              — next poll throws 401 (auth)
+ *   /bridge-kick poll transient        — next poll throws axios-style rejection
+ *   /bridge-kick register fail         — next register (inside doReconnect) transient-fails
+ *   /bridge-kick register fail 3       — next 3 registers transient-fail
+ *   /bridge-kick register fatal        — next register 403s (terminal)
+ *   /bridge-kick reconnect-session fail — POST /bridge/reconnect fails (→ Strategy 2)
+ *   /bridge-kick heartbeat 401         — next heartbeat 401s (JWT expired)
+ *   /bridge-kick reconnect             — call doReconnect directly (= SIGUSR2)
+ *   /bridge-kick status                — print current bridge state
+ *
+ * Workflow: connect Remote Control, run a subcommand, `tail -f debug.log`
+ * and watch [bridge:repl] / [bridge:debug] lines for the recovery reaction.
+ *
+ * Composite sequences — the failure modes in the BQ data are chains, not
+ * single events. Queue faults then fire the trigger:
+ *
+ *   # #22148 residual: ws_closed → register transient-blips → teardown?
+ *   /bridge-kick register fail 2
+ *   /bridge-kick close 1002
+ *   → expect: doReconnect tries register, fails, returns false → teardown
+ *     (demonstrates the retry gap that needs fixing)
+ *
+ *   # Dead gate: poll 404/not_found_error → does onEnvironmentLost fire?
+ *   /bridge-kick poll 404
+ *   → expect: tengu_bridge_repl_fatal_error (gate is dead — 147K/wk)
+ *     after fix: tengu_bridge_repl_env_lost → doReconnect
+ */
+
+const USAGE = `/bridge-kick <subcommand>
+  close <code>              fire ws_closed with the given code (e.g. 1002)
+  poll <status> [type]      next poll throws BridgeFatalError(status, type)
+  poll transient            next poll throws axios-style rejection (5xx/net)
+  register fail [N]         next N registers transient-fail (default 1)
+  register fatal            next register 403s (terminal)
+  reconnect-session fail    next POST /bridge/reconnect fails
+  heartbeat <status>        next heartbeat throws BridgeFatalError(status)
+  reconnect                 call reconnectEnvironmentWithSession directly
+  status                    print bridge state`
+
+const call: LocalCommandCall = async args => {
+  const h = getBridgeDebugHandle()
+  if (!h) {
+    return {
+      type: 'text',
+      value:
+        'No bridge debug handle registered. Remote Control must be connected (USER_TYPE=ant).',
+    }
+  }
+
+  const [sub, a, b] = args.trim().split(/\s+/)
+
+  switch (sub) {
+    case 'close': {
+      const code = Number(a)
+      if (!Number.isFinite(code)) {
+        return { type: 'text', value: `close: need a numeric code\n${USAGE}` }
+      }
+      h.fireClose(code)
+      return {
+        type: 'text',
+        value: `Fired transport close(${code}). Watch debug.log for [bridge:repl] recovery.`,
+      }
+    }
+
+    case 'poll': {
+      if (a === 'transient') {
+        h.injectFault({
+          method: 'pollForWork',
+          kind: 'transient',
+          status: 503,
+          count: 1,
+        })
+        h.wakePollLoop()
+        return {
+          type: 'text',
+          value:
+            'Next poll will throw a transient (axios rejection). Poll loop woken.',
+        }
+      }
+      const status = Number(a)
+      if (!Number.isFinite(status)) {
+        return {
+          type: 'text',
+          value: `poll: need 'transient' or a status code\n${USAGE}`,
+        }
+      }
+      // Default to what the server ACTUALLY sends for 404 (BQ-verified),
+      // so `/bridge-kick poll 404` reproduces the real 147K/week state.
+      const errorType =
+        b ?? (status === 404 ? 'not_found_error' : 'authentication_error')
+      h.injectFault({
+        method: 'pollForWork',
+        kind: 'fatal',
+        status,
+        errorType,
+        count: 1,
+      })
+      h.wakePollLoop()
+      return {
+        type: 'text',
+        value: `Next poll will throw BridgeFatalError(${status}, ${errorType}). Poll loop woken.`,
+      }
+    }
+
+    case 'register': {
+      if (a === 'fatal') {
+        h.injectFault({
+          method: 'registerBridgeEnvironment',
+          kind: 'fatal',
+          status: 403,
+          errorType: 'permission_error',
+          count: 1,
+        })
+        return {
+          type: 'text',
+          value:
+            'Next registerBridgeEnvironment will 403. Trigger with close/reconnect.',
+        }
+      }
+      const n = Number(b) || 1
+      h.injectFault({
+        method: 'registerBridgeEnvironment',
+        kind: 'transient',
+        status: 503,
+        count: n,
+      })
+      return {
+        type: 'text',
+        value: `Next ${n} registerBridgeEnvironment call(s) will transient-fail. Trigger with close/reconnect.`,
+      }
+    }
+
+    case 'reconnect-session': {
+      h.injectFault({
+        method: 'reconnectSession',
+        kind: 'fatal',
+        status: 404,
+        errorType: 'not_found_error',
+        count: 2,
+      })
+      return {
+        type: 'text',
+        value:
+          'Next 2 POST /bridge/reconnect calls will 404. doReconnect Strategy 1 falls through to Strategy 2.',
+      }
+    }
+
+    case 'heartbeat': {
+      const status = Number(a) || 401
+      h.injectFault({
+        method: 'heartbeatWork',
+        kind: 'fatal',
+        status,
+        errorType: status === 401 ? 'authentication_error' : 'not_found_error',
+        count: 1,
+      })
+      return {
+        type: 'text',
+        value: `Next heartbeat will ${status}. Watch for onHeartbeatFatal → work-state teardown.`,
+      }
+    }
+
+    case 'reconnect': {
+      h.forceReconnect()
+      return {
+        type: 'text',
+        value: 'Called reconnectEnvironmentWithSession(). Watch debug.log.',
+      }
+    }
+
+    case 'status': {
+      return { type: 'text', value: h.describe() }
+    }
+
+    default:
+      return { type: 'text', value: USAGE }
+  }
+}
+
+const bridgeKick = {
+  type: 'local',
+  name: 'bridge-kick',
+  description: 'Inject bridge failure states for manual recovery testing',
+  isEnabled: () => process.env.USER_TYPE === 'ant',
+  supportsNonInteractive: false,
+  load: () => Promise.resolve({ call }),
+} satisfies Command
+
+export default bridgeKick

package/src/commands/brief.ts

@@ -0,0 +1,130 @@
+import { feature } from 'bun:bundle'
+import { z } from 'zod/v4'
+import { getKairosActive, setUserMsgOptIn } from '../bootstrap/state.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import type { ToolUseContext } from '../Tool.js'
+import { isBriefEntitled } from '../tools/BriefTool/BriefTool.js'
+import { BRIEF_TOOL_NAME } from '../tools/BriefTool/prompt.js'
+import type {
+  Command,
+  LocalJSXCommandContext,
+  LocalJSXCommandOnDone,
+} from '../types/command.js'
+import { lazySchema } from '../utils/lazySchema.js'
+
+// Zod guards against fat-fingered GB pushes (same pattern as pollConfig.ts /
+// cronScheduler.ts). A malformed config falls back to DEFAULT_BRIEF_CONFIG
+// entirely rather than being partially trusted.
+const briefConfigSchema = lazySchema(() =>
+  z.object({
+    enable_slash_command: z.boolean(),
+  }),
+)
+type BriefConfig = z.infer<ReturnType<typeof briefConfigSchema>>
+
+const DEFAULT_BRIEF_CONFIG: BriefConfig = {
+  enable_slash_command: false,
+}
+
+// No TTL — this gate controls slash-command *visibility*, not a kill switch.
+// CACHED_MAY_BE_STALE still has one background-update flip (first call kicks
+// off fetch; second call sees fresh value), but no additional flips after that.
+// The tool-availability gate (tengu_kairos_brief in isBriefEnabled) keeps its
+// 5-min TTL because that one IS a kill switch.
+function getBriefConfig(): BriefConfig {
+  const raw = getFeatureValue_CACHED_MAY_BE_STALE<unknown>(
+    'tengu_kairos_brief_config',
+    DEFAULT_BRIEF_CONFIG,
+  )
+  const parsed = briefConfigSchema().safeParse(raw)
+  return parsed.success ? parsed.data : DEFAULT_BRIEF_CONFIG
+}
+
+const brief = {
+  type: 'local-jsx',
+  name: 'brief',
+  description: 'Toggle brief-only mode',
+  isEnabled: () => {
+    if (feature('KAIROS') || feature('KAIROS_BRIEF')) {
+      return getBriefConfig().enable_slash_command
+    }
+    return false
+  },
+  immediate: true,
+  load: () =>
+    Promise.resolve({
+      async call(
+        onDone: LocalJSXCommandOnDone,
+        context: ToolUseContext & LocalJSXCommandContext,
+      ): Promise<React.ReactNode> {
+        const current = context.getAppState().isBriefOnly
+        const newState = !current
+
+        // Entitlement check only gates the on-transition — off is always
+        // allowed so a user whose GB gate flipped mid-session isn't stuck.
+        if (newState && !isBriefEntitled()) {
+          logEvent('tengu_brief_mode_toggled', {
+            enabled: false,
+            gated: true,
+            source:
+              'slash_command' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          })
+          onDone('Brief tool is not enabled for your account', {
+            display: 'system',
+          })
+          return null
+        }
+
+        // Two-way: userMsgOptIn tracks isBriefOnly so the tool is available
+        // exactly when brief mode is on. This invalidates prompt cache on
+        // each toggle (tool list changes), but a stale tool list is worse —
+        // when /brief is enabled mid-session the model was previously left
+        // without the tool, emitting plain text the filter hides.
+        setUserMsgOptIn(newState)
+
+        context.setAppState(prev => {
+          if (prev.isBriefOnly === newState) return prev
+          return { ...prev, isBriefOnly: newState }
+        })
+
+        logEvent('tengu_brief_mode_toggled', {
+          enabled: newState,
+          gated: false,
+          source:
+            'slash_command' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        })
+
+        // The tool list change alone isn't a strong enough signal mid-session
+        // (model may keep emitting plain text from inertia, or keep calling a
+        // tool that just vanished). Inject an explicit reminder into the next
+        // turn's context so the transition is unambiguous.
+        // Skip when Kairos is active: isBriefEnabled() short-circuits on
+        // getKairosActive() so the tool never actually leaves the list, and
+        // the Kairos system prompt already mandates SendUserMessage.
+        // Inline <system-reminder> wrap — importing wrapInSystemReminder from
+        // utils/messages.ts pulls constants/xml.ts into the bridge SDK bundle
+        // via this module's import chain, tripping the excluded-strings check.
+        const metaMessages = getKairosActive()
+          ? undefined
+          : [
+              `<system-reminder>\n${
+                newState
+                  ? `Brief mode is now enabled. Use the ${BRIEF_TOOL_NAME} tool for all user-facing output — plain text outside it is hidden from the user's view.`
+                  : `Brief mode is now disabled. The ${BRIEF_TOOL_NAME} tool is no longer available — reply with plain text.`
+              }\n</system-reminder>`,
+            ]
+
+        onDone(
+          newState ? 'Brief-only mode enabled' : 'Brief-only mode disabled',
+          { display: 'system', metaMessages },
+        )
+        return null
+      },
+    }),
+} satisfies Command
+
+export default brief

package/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":";AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAC9B,SAASC,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AACnD,SAASC,WAAW,QAAQ,aAAa;AACzC,cAAcC,oBAAoB,QAAQ,mBAAmB;AAC7D,SAASC,QAAQ,QAAQ,8BAA8B;AACvD,SAASC,YAAY,QAAQ,0CAA0C;AACvE,SAASC,UAAU,EAAEC,QAAQ,QAAQ,4BAA4B;AACjE,SAASC,eAAe,QAAQ,4BAA4B;AAC5D,SAASC,sBAAsB,QAAQ,+BAA+B;AACtE,SAASC,gBAAgB,EAAEC,cAAc,QAAQ,kBAAkB;AACnE,SAASC,eAAe,QAAQ,gCAAgC;AAChE,OAAOC,SAAS,IACd,KAAKC,eAAe,QACf,mCAAmC;AAC1C,cAAcC,aAAa,QAAQ,oCAAoC;AACvE,SAASC,GAAG,EAAEC,IAAI,QAAQ,cAAc;AACxC,cAAcC,qBAAqB,QAAQ,wBAAwB;AACnE,cAAcC,OAAO,QAAQ,wBAAwB;AACrD,SAASC,qBAAqB,QAAQ,gCAAgC;AACtE,SAASC,gBAAgB,QAAQ,uBAAuB;AACxD,SAASC,YAAY,QAAQ,uBAAuB;AACpD,SACE,KAAKC,eAAe,EACpBC,sBAAsB,QACjB,4BAA4B;AACnC,SAASC,+BAA+B,QAAQ,yBAAyB;AACzE,cAAcC,uBAAuB,QAAQ,kDAAkD;AAC/F,SAASC,eAAe,QAAQ,6BAA6B;AAC7D,SAASC,cAAc,QAAQ,iCAAiC;AAEhE,KAAKC,iBAAiB,GAAG;EACvBC,QAAQ,EAAE,MAAM;EAChBC,OAAO,EAAEL,uBAAuB;EAChCM,MAAM,EAAE,CACNC,MAAe,CAAR,EAAE,MAAM,EACfC,OAA4C,CAApC,EAAE;IAAEC,OAAO,CAAC,EAAEhC,oBAAoB;EAAC,CAAC,EAC5C,GAAG,IAAI;AACX,CAAC;AAED,MAAMiC,WAAW,GAAG,CAAC;AACrB,MAAMC,iBAAiB,GAAG,CAAC;AAC3B,MAAMC,YAAY,GAAG,CAAC;AAEtB,SAAAC,gBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAyB;IAAAZ,QAAA;IAAAC,OAAA;IAAAC;EAAA,IAAAQ,EAIL;EAClB,OAAAG,QAAA,EAAAC,WAAA,IAAgC3C,QAAQ,CAAgB,IAAI,CAAC;EAC7D,OAAA4C,KAAA,EAAAC,QAAA,IAA0B7C,QAAQ,CAAgB,IAAI,CAAC;EACvD,OAAA8C,KAAA,EAAAC,QAAA,IAA0B/C,QAAQ,CAAC,CAAC,CAAC;EACrC,MAAAgD,SAAA,GAAkBjD,MAAM,CAAkB,IAAI,CAAC;EAC/C;IAAAkD;EAAA,IAAiBzC,sBAAsB,CAACG,eAAe,CAAC,CAAC,CAAC;EAAA,IAAAuC,EAAA;EAAA,IAAAV,CAAA,QAAAW,MAAA,CAAAC,GAAA;IAG9CF,EAAA,GAAAA,CAAA,KAAMH,QAAQ,CAACM,KAAU,CAAC;IAAAb,CAAA,MAAAU,EAAA;EAAA;IAAAA,EAAA,GAAAV,CAAA;EAAA;EAAtCvC,WAAW,CAACiD,EAA0B,EAAER,QAAiB,IAAjBE,KAA6B,GAA7B,IAA6B,GAA7B,EAA6B,CAAC;EAAA,IAAAU,EAAA;EAAA,IAAAd,CAAA,QAAAT,MAAA;IAEtEuB,EAAA,YAAAC,cAAAC,CAAA;MACE,IACEA,CAAC,CAAAC,GAAI,KAAK,QACQ,IAAlBD,CAAC,CAAAC,GAAI,KAAK,QACG,IAAbD,CAAC,CAAAC,GAAI,KAAK,GACkC,IAA3CD,CAAC,CAAAE,IAAyC,KAA/BF,CAAC,CAAAC,GAAI,KAAK,GAAoB,IAAbD,CAAC,CAAAC,GAAI,KAAK,GAAI,CAAC;QAE5CD,CAAC,CAAAG,cAAe,CAAC,CAAC;QAClB5B,MAAM,CAAC6B,SAAS,EAAE;UAAA1B,OAAA,EAAW;QAAO,CAAC,CAAC;QAAA;MAAA;MAGxC,IAAIsB,CAAC,CAAAC,GAAI,KAAK,IAAiC,IAAxBD,CAAC,CAAAE,IAAsB,IAAbF,CAAC,CAAAC,GAAI,KAAK,GAAI;QAC7CD,CAAC,CAAAG,cAAe,CAAC,CAAC;QAClBX,SAAS,CAAAa,OAAkB,EAAAC,QAAe,CAAd,CAACzB,YAAY,CAAC;MAAA;MAE5C,IAAImB,CAAC,CAAAC,GAAI,KAAK,MAAmC,IAAxBD,CAAC,CAAAE,IAAsB,IAAbF,CAAC,CAAAC,GAAI,KAAK,GAAI;QAC/CD,CAAC,CAAAG,cAAe,CAAC,CAAC;QAClBX,SAAS,CAAAa,OAAkB,EAAAC,QAAc,CAAbzB,YAAY,CAAC;MAAA;IAC1C,CACF;IAAAG,CAAA,MAAAT,MAAA;IAAAS,CAAA,MAAAc,EAAA;EAAA;IAAAA,EAAA,GAAAd,CAAA;EAAA;EAnBD,MAAAe,aAAA,GAAAD,EAmBC;EAAA,IAAAS,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAxB,CAAA,QAAAV,OAAA,IAAAU,CAAA,QAAAX,QAAA;IAESkC,EAAA,GAAAA,CAAA;MACR,MAAAE,eAAA,GAAwB9C,qBAAqB,CAAC,CAAC;MAE/C,MAAA+C,aAAA,kBAAAA,cAAA;QAAA;QACE;UACE,MAAAC,eAAA,GAAwB,MAAMC,oBAAoB,CAACtC,OAAO,CAAC;UAC3D,MAAAE,MAAA,GAAe,MAAMN,eAAe,CAAC;YAAAG,QAAA;YAAAsC;UAA4B,CAAC,CAAC;UAEnE,IAAI,CAACF,eAAe,CAAAI,MAAO,CAAAC,OAAQ;YACjC,IAAItC,MAAM,CAAAU,QAAS;cACjBC,WAAW,CAACX,MAAM,CAAAU,QAAS,CAAC;YAAA;cAE5BG,QAAQ,CAAC,sBAAsB,CAAC;YAAA;UACjC;QACF,SAAA0B,EAAA;UACMC,KAAA,CAAAA,GAAA,CAAAA,CAAA,CAAAA,EAAG;UACV,IAAI,CAACP,eAAe,CAAAI,MAAO,CAAAC,OAAQ;YACjCzB,QAAQ,CAACxB,YAAY,CAACmD,GAA+B,CAAC,IAA7C,wBAA6C,CAAC;UAAA;QACxD;MACF,CACF;MAEIN,aAAa,CAAC,CAAC;MAAA,OAEb;QACLD,eAAe,CAAAQ,KAAM,CAAC,CAAC;MAAA,CACxB;IAAA,CACF;IAAET,EAAA,IAACnC,QAAQ,EAAEC,OAAO,CAAC;IAAAU,CAAA,MAAAV,OAAA;IAAAU,CAAA,MAAAX,QAAA;IAAAW,CAAA,MAAAuB,EAAA;IAAAvB,CAAA,MAAAwB,EAAA;EAAA;IAAAD,EAAA,GAAAvB,CAAA;IAAAwB,EAAA,GAAAxB,CAAA;EAAA;EA3BtB1C,SAAS,CAACiE,EA2BT,EAAEC,EAAmB,CAAC;EAEvB,MAAAU,gBAAA,GAAyBC,IAAI,CAAAC,GAAI,CAAC,CAAC,EAAE3B,IAAI,GAAGd,WAAW,GAAGC,iBAAiB,CAAC;EAAA,IAAAmC,EAAA;EAAA,IAAA/B,CAAA,QAAAW,MAAA,CAAAC,GAAA;IAYtEmB,EAAA,IAAC,IAAI,CAAO,KAAS,CAAT,SAAS,CAAC,IAAI,CAAJ,KAAG,CAAC,CAAC,IACpB,IAAE,CACT,EAFC,IAAI,CAEE;IAAA/B,CAAA,MAAA+B,EAAA;EAAA;IAAAA,EAAA,GAAA/B,CAAA;EAAA;EAAA,IAAAqC,EAAA;EAAA,IAAArC,CAAA,QAAAX,QAAA;IAHTgD,EAAA,IAAC,GAAG,CACF,CAAAN,EAEM,CACN,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAE1C,SAAO,CAAE,EAAxB,IAAI,CACP,EALC,GAAG,CAKE;IAAAW,CAAA,MAAAX,QAAA;IAAAW,CAAA,MAAAqC,EAAA;EAAA;IAAAA,EAAA,GAAArC,CAAA;EAAA;EAAA,IAAAsC,EAAA;EAAA,IAAAtC,CAAA,SAAAI,KAAA,IAAAJ,CAAA,SAAAM,KAAA,IAAAN,CAAA,SAAAE,QAAA;IAEJoC,EAAA,IAAC,SAAS,CAAM9B,GAAS,CAATA,UAAQ,CAAC,CAAgB,aAAQ,CAAR,QAAQ,CAAW,QAAC,CAAD,GAAC,CAC1D,CAAAJ,KAAK,GACJ,CAAC,IAAI,CAAO,KAAO,CAAP,OAAO,CAAEA,MAAI,CAAE,EAA1B,IAAI,CAQN,GAPGF,QAAQ,GACV,CAAC,QAAQ,CAAEA,SAAO,CAAE,EAAnB,QAAQ,CAMV,GAJC,CAAC,GAAG,CACF,CAAC,YAAY,CAAQI,KAAK,CAALA,MAAI,CAAC,CAAe,YAAS,CAAT,SAAS,GAClD,CAAC,IAAI,CAAO,KAAS,CAAT,SAAS,CAAC,YAAY,EAAjC,IAAI,CACP,EAHC,GAAG,CAIN,CACF,EAXC,SAAS,CAWE;IAAAN,CAAA,OAAAI,KAAA;IAAAJ,CAAA,OAAAM,KAAA;IAAAN,CAAA,OAAAE,QAAA;IAAAF,CAAA,OAAAsC,EAAA;EAAA;IAAAA,EAAA,GAAAtC,CAAA;EAAA;EAAA,IAAAuC,EAAA;EAAA,IAAAvC,CAAA,SAAAkC,gBAAA,IAAAlC,CAAA,SAAAsC,EAAA;IAZdC,EAAA,IAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CAAc,UAAC,CAAD,GAAC,CAAaL,SAAgB,CAAhBA,iBAAe,CAAC,CAC3D,CAAAI,EAWW,CACb,EAbC,GAAG,CAaE;IAAAtC,CAAA,OAAAkC,gBAAA;IAAAlC,CAAA,OAAAsC,EAAA;IAAAtC,CAAA,OAAAuC,EAAA;EAAA;IAAAA,EAAA,GAAAvC,CAAA;EAAA;EAAA,IAAAwC,EAAA;EAAA,IAAAxC,CAAA,SAAAI,KAAA,IAAAJ,CAAA,SAAAE,QAAA;IACLsC,EAAA,IAACtC,QAAiB,IAAjBE,KAOD,KANC,CAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CACf,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CACXtC,SAAO,CAAE,CAAED,WAAS,CAAE,+CAEzB,EAHC,IAAI,CAIP,EALC,GAAG,CAML;IAAAmC,CAAA,OAAAI,KAAA;IAAAJ,CAAA,OAAAE,QAAA;IAAAF,CAAA,OAAAwC,EAAA;EAAA;IAAAA,EAAA,GAAAxC,CAAA;EAAA;EAAA,IAAAyC,GAAA;EAAA,IAAAzC,CAAA,SAAAe,aAAA,IAAAf,CAAA,SAAAqC,EAAA,IAAArC,CAAA,SAAAuC,EAAA,IAAAvC,CAAA,SAAAwC,EAAA;IAnCHC,GAAA,IAAC,GAAG,CACY,aAAQ,CAAR,QAAQ,CACT,WAAC,CAAD,GAAC,CACH,SAAC,CAAD,GAAC,CACF,QAAC,CAAD,GAAC,CACX,SAAS,CAAT,KAAQ,CAAC,CACE1B,SAAa,CAAbA,cAAY,CAAC,CAExB,CAAAsB,EAKK,CACL,CAAAE,EAaK,CACJ,CAAAC,EAOD,CACF,EApCC,GAAG,CAoCE;IAAAxC,CAAA,OAAAe,aAAA;IAAAf,CAAA,OAAAqC,EAAA;IAAArC,CAAA,OAAAuC,EAAA;IAAAvC,CAAA,OAAAwC,EAAA;IAAAxC,CAAA,OAAAyC,GAAA;EAAA;IAAAA,GAAA,GAAAzC,CAAA;EAAA;EAAA,OApCNyC,GAoCM;AAAA;;AAIV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAzHA,SAAA5B,MAAA6B,CAAA;EAAA,OAYkCA,CAAC,GAAG,CAAC;AAAA;AA8GvC,SAASC,+BAA+BA,CAACC,QAAQ,EAAElE,OAAO,EAAE,CAAC,EAAEA,OAAO,EAAE,CAAC;EACvE,MAAMmE,IAAI,GAAGD,QAAQ,CAACE,EAAE,CAAC,CAAC,CAAC,CAAC;EAC5B,IAAID,IAAI,EAAEE,IAAI,KAAK,WAAW,IAAIF,IAAI,CAACG,OAAO,CAACC,WAAW,KAAK,IAAI,EAAE;IACnE,OAAOL,QAAQ,CAACM,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;EAC9B;EACA,OAAON,QAAQ;AACjB;AAEA,eAAehB,oBAAoBA,CACjCtC,OAAO,EAAEL,uBAAuB,CACjC,EAAEkE,OAAO,CAACrE,eAAe,CAAC,CAAC;EAC1B,MAAMsE,mBAAmB,GAAGpE,+BAA+B,CACzD2D,+BAA+B,CAACrD,OAAO,CAACsD,QAAQ,CAClD,CAAC;EACD,MAAMS,KAAK,GAAGtE,sBAAsB,CAAC,CAAC;EACtC,IAAIsE,KAAK,EAAE;IACT,OAAO;MACLC,YAAY,EAAED,KAAK,CAACC,YAAY;MAChCC,WAAW,EAAEF,KAAK,CAACE,WAAW;MAC9BC,aAAa,EAAEH,KAAK,CAACG,aAAa;MAClCC,cAAc,EAAEnE,OAAO;MACvB8D;IACF,CAAC;EACH;EACA,MAAM,CAACM,eAAe,EAAEH,WAAW,EAAEC,aAAa,CAAC,GAAG,MAAML,OAAO,CAACQ,GAAG,CAAC,CACtE5F,eAAe,CACbuB,OAAO,CAACG,OAAO,CAACmE,KAAK,EACrBtE,OAAO,CAACG,OAAO,CAACoE,aAAa,EAC7B,EAAE,EACFvE,OAAO,CAACG,OAAO,CAACqE,UAClB,CAAC,EACD5F,cAAc,CAAC,CAAC,EAChBD,gBAAgB,CAAC,CAAC,CACnB,CAAC;EACF,OAAO;IACLqF,YAAY,EAAEnE,cAAc,CAACuE,eAAe,CAAC;IAC7CH,WAAW;IACXC,aAAa;IACbC,cAAc,EAAEnE,OAAO;IACvB8D;EACF,CAAC;AACH;AAEA,OAAO,eAAeW,IAAIA,CACxBxE,MAAM,EAAEd,qBAAqB,EAC7Ba,OAAO,EAAEL,uBAAuB,EAChC+E,IAAI,EAAE,MAAM,CACb,EAAEb,OAAO,CAAC9F,KAAK,CAAC4G,SAAS,CAAC,CAAC;EAC1B,MAAM5E,QAAQ,GAAG2E,IAAI,EAAEE,IAAI,CAAC,CAAC;EAE7B,IAAI,CAAC7E,QAAQ,EAAE;IACbE,MAAM,CAAC,6BAA6B,EAAE;MAAEG,OAAO,EAAE;IAAS,CAAC,CAAC;IAC5D,OAAO,IAAI;EACb;EAEAd,gBAAgB,CAACyC,OAAO,KAAK;IAC3B,GAAGA,OAAO;IACV8C,WAAW,EAAE9C,OAAO,CAAC8C,WAAW,GAAG;EACrC,CAAC,CAAC,CAAC;EAEH,OACE,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC9E,QAAQ,CAAC,CAAC,OAAO,CAAC,CAACC,OAAO,CAAC,CAAC,MAAM,CAAC,CAACC,MAAM,CAAC,GAAG;AAE7E","ignoreList":[]}

package/src/commands/btw/index.ts

@@ -0,0 +1,13 @@
+import type { Command } from '../../commands.js'
+
+const btw = {
+  type: 'local-jsx',
+  name: 'btw',
+  description:
+    'Ask a quick side question without interrupting the main conversation',
+  immediate: true,
+  argumentHint: '<question>',
+  load: () => import('./btw.js'),
+} satisfies Command
+
+export default btw

package/src/commands/bughunter/index.js

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