@cjhyy/code-shell 0.2.0 → 0.3.0

package/dist/ui/components/MessageRow.d.ts

@@ -0,0 +1,54 @@
+/**
+ * MessageRow — memo boundary around a single chat entry's rendered output.
+ *
+ * Why this exists: stream events fire dozens of times per second. Without
+ * a memo boundary, every entry's renderer (markdown lexing, Yoga layout,
+ * syntax-highlight token cache) re-runs on every frame, defeating ink's
+ * blit fast-path. The hand-written comparator below mirrors Claude Code
+ * 2.1.88's areMessageRowPropsEqual: bail only when we are CERTAIN the
+ * entry didn't change.
+ *
+ * Why `render` is excluded from the comparator (intentional, see CC's
+ * VirtualItem note): when entry/columns/isStreaming all match, React.memo
+ * returns the PREVIOUS rendered ReactNode — it does NOT invoke render
+ * again with the new closure, so a stale-closure-on-bail scenario is
+ * impossible. Including `render` in the comparator would defeat memo
+ * entirely (render is fresh on every parent render).
+ */
+import React, { type ReactNode } from "react";
+import type { ChatEntry } from "../store.js";
+export interface MessageRowProps {
+    entry: ChatEntry;
+    /** Terminal columns — affects text wrap inside the renderer. */
+    columns: number;
+    /**
+     * True iff this entry is the one currently receiving stream deltas.
+     * Streaming rows never memo-bail (their text grows mid-frame).
+     */
+    isStreaming: boolean;
+    /**
+     * True iff this entry is the transcript-mode cursor target. State
+     * external to the entry that affects rendering (cursor outline) must
+     * be a prop so the comparator can invalidate when it flips. CC handles
+     * cursor/hover/expanded the same way on its VirtualItem.
+     */
+    isSelected: boolean;
+    /**
+     * True when long entries should render expanded (transcript mode).
+     * Flipping this re-renders every row — low-frequency event, acceptable.
+     */
+    expanded: boolean;
+    /**
+     * Called with the entry when we actually need to render. Excluded
+     * from the memo comparator on purpose (see file header).
+     */
+    render: (entry: ChatEntry) => ReactNode;
+}
+declare function MessageRowImpl({ entry, render }: MessageRowProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Returns true when the row can safely skip re-render. False on any
+ * uncertainty — we fail safe by re-rendering.
+ */
+export declare function areMessageRowPropsEqual(prev: MessageRowProps, next: MessageRowProps): boolean;
+export declare const MessageRow: React.MemoExoticComponent<typeof MessageRowImpl>;
+export {};

package/dist/ui/components/SpinnerWithVerb.d.ts

@@ -14,5 +14,6 @@ interface SpinnerWithVerbProps {
     runStartRef?: MutableRefObject<number>;
     thinkingContent?: string;
 }
-export declare function SpinnerWithVerb({ mode, streamingTokensRef, runStartRef, thinkingContent, }: SpinnerWithVerbProps): import("react/jsx-runtime").JSX.Element;
+declare function SpinnerWithVerbImpl({ mode, streamingTokensRef, runStartRef, thinkingContent, }: SpinnerWithVerbProps): import("react/jsx-runtime").JSX.Element;
+export declare const SpinnerWithVerb: import("react").MemoExoticComponent<typeof SpinnerWithVerbImpl>;
 export {};

package/dist/ui/components/TextInput.d.ts

@@ -4,6 +4,14 @@ interface TextInputProps {
     onSubmit?: (value: string) => void;
     placeholder?: string;
     focus?: boolean;
+    /** Suffix rendered dim after the cursor — e.g. "on|off" arg hint for
+     *  a slash command. Not part of `value`; not editable. */
+    hint?: string;
+    /** Bumping this number snaps the cursor to value.length on the next
+     *  render. Use when the parent rewrites `value` externally (e.g. tab
+     *  completion) — the in-component cursor would otherwise stay at its
+     *  pre-rewrite offset and land in the middle of the new text. */
+    cursorResetCounter?: number;
 }
-export default function TextInput({ value, onChange, onSubmit, placeholder, focus, }: TextInputProps): import("react/jsx-runtime").JSX.Element;
+export default function TextInput({ value, onChange, onSubmit, placeholder, focus, hint, cursorResetCounter, }: TextInputProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/ui/components/VirtualMessageList.d.ts

@@ -1,24 +1,43 @@
 /**
- * VirtualMessageList — renders only visible messages for performance.
+ * VirtualMessageList — ScrollBox + viewport-windowed chat rendering.
  *
- * When message count exceeds VIRTUALIZE_THRESHOLD, only renders messages
- * within the visible viewport (plus overscan buffer). Uses height estimation
- * for off-screen items via spacer elements.
+ * Owns its own ScrollBox + useVirtualScroll. Only items in the viewport
+ * (+ overscan) are mounted as React fibers / Yoga nodes; the rest live
+ * as height-equivalent topSpacer / bottomSpacer boxes. ScrollBox handles
+ * sticky-bottom, wheel/key scroll, render-time clamping.
  *
- * For smaller conversations, renders all messages directly (no virtualization).
+ * Each rendered item is wrapped in <MessageRow> (React.memo) so historical
+ * entries skip re-render entirely on stream ticks. Cursor-outline decoration
+ * is applied OUTSIDE the memo boundary so the render closure stays cursor-
+ * agnostic.
  *
- * Also provides an unseen message divider ("── N new ──") when the user
- * scrolls away and new messages arrive.
+ * Auto-stick: when entries grow while ScrollBox is "sticky" (default + after
+ * scrollToBottom), the view follows the tail. User scrolling up breaks
+ * stickiness; clicking the "N new messages" pill should call onJumpToNew
+ * which ultimately invokes scrollToBottom (wired via the imperative handle).
  */
-import { type ReactNode } from "react";
-import type { ChatEntry } from "../store.js";
+import React, { type ReactNode } from "react";
+import { type ChatEntry } from "../store.js";
 interface VirtualMessageListProps {
     entries: ChatEntry[];
-    renderEntry: (entry: ChatEntry, key: string) => ReactNode;
+    renderEntry: (entry: ChatEntry, key: string, expanded: boolean) => ReactNode;
+    /** Terminal width — threaded into MessageRow so width changes invalidate memo. */
+    columns: number;
+    /** Id of the entry currently receiving stream deltas (null = no stream). */
+    streamingEntryId?: string | null;
+    /** Id of the entry under the transcript-mode cursor (null = no cursor). */
+    selectedEntryId?: string | null;
+    /** True when long entries should render expanded (transcript mode). */
+    expanded?: boolean;
     /** Index where "N new" divider should render (null = no divider). */
     dividerIndex?: number | null;
     /** Count of unseen messages to show in divider. */
     unseenCount?: number;
 }
-export declare function VirtualMessageList({ entries, renderEntry, dividerIndex, unseenCount, }: VirtualMessageListProps): import("react/jsx-runtime").JSX.Element;
+export interface VirtualMessageListHandle {
+    scrollToBottom: () => void;
+    scrollBy: (dy: number) => void;
+    getViewportHeight: () => number;
+}
+export declare const VirtualMessageList: React.ForwardRefExoticComponent<VirtualMessageListProps & React.RefAttributes<VirtualMessageListHandle>>;
 export {};

package/dist/ui/dev-seed.d.ts

@@ -0,0 +1 @@
+export declare function applyDevSeed(): void;

package/dist/ui/fullscreen-mode.d.ts

@@ -0,0 +1,9 @@
+export declare const TAIL_ENTRY_LIMIT = 500;
+export declare const INITIAL_FULLSCREEN_MODE: boolean;
+export interface FullscreenModeValue {
+    fullscreen: boolean;
+    setFullscreen: (next: boolean) => void;
+    toggleFullscreen: () => void;
+}
+export declare const FullscreenModeContext: import("react").Context<FullscreenModeValue>;
+export declare function useFullscreenMode(): FullscreenModeValue;

package/dist/ui/hooks/useVirtualScroll.d.ts

@@ -0,0 +1,101 @@
+import type { RefObject } from 'react';
+import type { ScrollBoxHandle } from '../../render/components/ScrollBox.js';
+import type { DOMElement } from '../../render/dom.js';
+export type VirtualScrollResult = {
+    /** [startIndex, endIndex) half-open slice of items to render. */
+    range: readonly [number, number];
+    /** Height (rows) of spacer before the first rendered item. */
+    topSpacer: number;
+    /** Height (rows) of spacer after the last rendered item. */
+    bottomSpacer: number;
+    /**
+     * Callback ref factory. Attach `measureRef(itemKey)` to each rendered
+     * item's root Box; after Yoga layout, the computed height is cached.
+     */
+    measureRef: (key: string) => (el: DOMElement | null) => void;
+    /**
+     * Attach to the topSpacer Box. Its Yoga computedTop IS listOrigin
+     * (first child of the virtualized region, so its top = cumulative
+     * height of everything rendered before the list in the ScrollBox).
+     * Drift-free: no subtraction of offsets, no dependence on item
+     * heights that change between renders (tmux resize).
+     */
+    spacerRef: RefObject<DOMElement | null>;
+    /**
+     * Cumulative y-offset of each item in list-wrapper coords (NOT scrollbox
+     * coords — logo/siblings before this list shift the origin).
+     * offsets[i] = rows above item i; offsets[n] = totalHeight.
+     * Recomputed every render — don't memo on identity.
+     */
+    offsets: ArrayLike<number>;
+    /**
+     * Read Yoga computedTop for item at index. Returns -1 if the item isn't
+     * mounted or hasn't been laid out. Item Boxes are direct Yoga children
+     * of the ScrollBox content wrapper (fragments collapse in the Ink DOM),
+     * so this is content-wrapper-relative — same coordinate space as
+     * scrollTop. Yoga layout is scroll-independent (translation happens
+     * later in renderNodeToOutput), so positions stay valid across scrolls
+     * without waiting for Ink to re-render. StickyTracker walks the mount
+     * range with this to find the viewport boundary at per-scroll-tick
+     * granularity (finer than the 40-row quantum this hook re-renders at).
+     */
+    getItemTop: (index: number) => number;
+    /**
+     * Get the mounted DOMElement for item at index, or null. For
+     * ScrollBox.scrollToElement — anchoring by element ref defers the
+     * Yoga-position read to render time (deterministic; no throttle race).
+     */
+    getItemElement: (index: number) => DOMElement | null;
+    /** Measured Yoga height. undefined = not yet measured; 0 = rendered nothing. */
+    getItemHeight: (index: number) => number | undefined;
+    /**
+     * Scroll so item `i` is in the mounted range. Sets scrollTop =
+     * offsets[i] + listOrigin. The range logic finds start from
+     * scrollTop vs offsets[] — BOTH use the same offsets value, so they
+     * agree by construction regardless of whether offsets[i] is the
+     * "true" position. Item i mounts; its screen position may be off by
+     * a few-dozen rows (overscan-worth of estimate drift), but it's in
+     * the DOM. Follow with getItemTop(i) for the precise position.
+     */
+    scrollToIndex: (i: number) => void;
+};
+/**
+ * React-level virtualization for items inside a ScrollBox.
+ *
+ * The ScrollBox already does Ink-output-level viewport culling
+ * (render-node-to-output.ts:617 skips children outside the visible window),
+ * but all React fibers + Yoga nodes are still allocated. At ~250 KB RSS per
+ * MessageRow, a 1000-message session costs ~250 MB of grow-only memory
+ * (Ink screen buffer, WASM linear memory, JSC page retention all grow-only).
+ *
+ * This hook mounts only items in viewport + overscan. Spacer boxes hold the
+ * scroll height constant for the rest at O(1) fiber cost each.
+ *
+ * Height estimation: fixed DEFAULT_ESTIMATE for unmeasured items, replaced
+ * by real Yoga heights after first layout. No scroll anchoring — overscan
+ * absorbs estimate errors. If drift is noticeable in practice, anchoring
+ * (scrollBy(delta) when topSpacer changes) is a straightforward followup.
+ *
+ * stickyScroll caveat: render-node-to-output.ts:450 sets scrollTop=maxScroll
+ * during Ink's render phase, which does NOT fire ScrollBox.subscribe. The
+ * at-bottom check below handles this — when pinned to the bottom, we render
+ * the last N items regardless of what scrollTop claims.
+ */
+export declare function useVirtualScroll(scrollRef: RefObject<ScrollBoxHandle | null>, itemKeys: readonly string[], 
+/**
+ * Terminal column count. On change, cached heights are stale (text
+ * rewraps) — SCALED by oldCols/newCols rather than cleared. Clearing
+ * made the pessimistic coverage back-walk mount ~190 items (every
+ * uncached item → PESSIMISTIC_HEIGHT=1 → walk 190 to reach
+ * viewport+2×overscan). Each fresh mount runs marked.lexer + syntax
+ * highlighting ≈ 3ms; ~600ms React reconcile on first resize with a
+ * long conversation. Scaling keeps heightCache populated → back-walk
+ * uses real-ish heights → mount range stays tight. Scaled estimates
+ * are overwritten by real Yoga heights on next useLayoutEffect.
+ *
+ * Scaled heights are close enough that the black-screen-on-widen bug
+ * (inflated pre-resize offsets overshoot post-resize scrollTop → end
+ * loop stops short of tail) doesn't trigger: ratio<1 on widen scales
+ * heights DOWN, keeping offsets roughly aligned with post-resize Yoga.
+ */
+columns: number): VirtualScrollResult;

package/dist/ui/perf-probes.d.ts

@@ -0,0 +1,22 @@
+export declare const PERF_ENABLED: boolean;
+export declare function startEventLoopMonitor(intervalMs?: number, warnThresholdMs?: number): void;
+export declare function stopEventLoopMonitor(): void;
+export declare function recordStreamEvent(type: string, agentId: string | undefined): void;
+export declare function startStreamRateReporter(windowMs?: number): void;
+export declare function stopStreamRateReporter(): void;
+export declare function recordAppRender(): void;
+export declare function startAppRenderReporter(windowMs?: number): void;
+export declare function stopAppRenderReporter(): void;
+export declare function recordInkFrame(event: {
+    durationMs: number;
+    phases: {
+        diff: number;
+        write: number;
+        yoga: number;
+        patches: number;
+    };
+}): void;
+export declare function startInkFrameReporter(windowMs?: number): void;
+export declare function stopInkFrameReporter(): void;
+export declare function startAllPerfProbes(): void;
+export declare function stopAllPerfProbes(): void;

package/dist/ui/query-guard.d.ts

@@ -0,0 +1,35 @@
+/**
+ * QueryGuard — synchronous state machine for "is a query in flight".
+ * Replaces React useState for isRunning. Subscribers (via useSyncExternalStore)
+ * see state changes immediately, bypassing React 18 batching that otherwise
+ * opens a 1–10 ms window for double-submit / dead-click bugs.
+ *
+ * States:
+ *   idle      — no query active
+ *   reserved  — processUserInput started its sync prep but hasn't created the AbortController yet
+ *   running   — AbortController attached; query is in flight
+ *
+ * The only writers are reserve/tryStart/cancelReservation/end/forceEnd.
+ * No setter is exposed.
+ */
+export type QueryState = "idle" | "reserved" | "running";
+export declare class QueryGuard {
+    private state;
+    private controller;
+    private listeners;
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => boolean;
+    private notify;
+    /** Reserve a slot synchronously before the AbortController exists. */
+    reserve(): boolean;
+    /** Attach the AbortController. Must follow reserve(). */
+    tryStart(controller: AbortController): boolean;
+    /** Roll back reserve() when processUserInput threw before tryStart. */
+    cancelReservation(): void;
+    /** Normal completion — clean up without aborting (already finished). */
+    end(): void;
+    /** Hard abort: abort the controller AND clean up. */
+    forceEnd(reason?: string): void;
+    /** Read the current controller's signal; null when idle/reserved. */
+    getSignal(): AbortSignal | null;
+}

package/dist/ui/slice-anchor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SliceAnchor — UUID-anchored cap for the flow-mode chat slice.
+ *
+ * Flow mode renders all entries through Ink's normal diff path (no <Static>),
+ * relying on the terminal's native scrollback for history. To keep yoga
+ * layout and the screen buffer bounded, we slice the rendered list to a
+ * fixed cap. The naive `entries.slice(-CAP)` shifts the head by one on every
+ * append — that means row 0 of prev and row 0 of next describe different
+ * content, and log-update's diff sees changes at scrollback rows it can't
+ * reach, forcing a fullResetSequence_CAUSES_FLICKER per turn.
+ *
+ * Fix: anchor the slice start to a specific entry id and only advance when
+ * (entries.length - start) exceeds CAP + STEP. Quantizing in STEP-sized
+ * chunks turns "flicker every append" into "flicker every STEP appends".
+ *
+ * The anchor stores BOTH id and idx — if the anchored id disappears (rare
+ * for chat entries since ids are stable, but defensive), we fall back to
+ * the stored idx clamped into range, instead of resetting to 0 which would
+ * try to render the full history at once.
+ *
+ * Mirrors Claude Code's computeSliceStart in src/components/Messages.tsx.
+ */
+export declare const DEFAULT_CAP = 200;
+export declare const DEFAULT_STEP = 50;
+export type SliceAnchor = {
+    id: string;
+    idx: number;
+} | null;
+export interface AnchorRef {
+    current: SliceAnchor;
+}
+/**
+ * Returns the index at which the rendered slice should start. May mutate
+ * `anchorRef.current` to refresh the stored anchor when the window advances
+ * or the anchored id has shifted in the entries array.
+ *
+ * @param entries - The full, post-filter chat entries (must expose `.id`).
+ * @param anchorRef - Mutable container for the persistent anchor.
+ * @param cap - Soft maximum entries to render. Window advances past this.
+ * @param step - Hysteresis: only advance when length exceeds cap + step.
+ */
+export declare function computeSliceStart(entries: ReadonlyArray<{
+    id: string;
+}>, anchorRef: AnchorRef, cap?: number, step?: number): number;

package/dist/ui/store.d.ts

@@ -48,21 +48,36 @@ type ChatEntryData = {
 } | {
     type: "agent_start";
     agentId: string;
+    name?: string;
     description: string;
 } | {
     type: "agent_end";
     agentId: string;
+    name?: string;
     description: string;
+    text?: string;
     error?: string;
 };
 /** Specialized error kinds for smart rendering. */
 export type ErrorKind = "rate_limit" | "context_limit" | "invalid_api_key" | "api_timeout" | "credit_balance" | "generic";
 /** System message subtypes. */
-export type SystemSubtype = "compact_boundary" | "memory_saved" | "turn_duration" | "info";
+export type SystemSubtype = "compact_boundary" | "memory_saved" | "turn_duration" | "info" | "bg_agent_notification";
 export type ChatEntry = ChatEntryData & {
     id: string;
 };
 export declare function createEntry(data: ChatEntryData): ChatEntry;
+/**
+ * "Finalized" = entry's content is stable; further stream events will not
+ * mutate it in place. Used by VirtualMessageList flow mode to route entries
+ * into <Static> (append-only, never re-rendered) vs. the active region (kept
+ * in React tree and re-rendered on each delta).
+ *
+ *   assistant_text  → final once streaming flips to false
+ *   tool_running    → transient, always replaced by tool_result; not final
+ *   thinking        → transient, filtered out on next tool_use_start
+ *   everything else → final on append
+ */
+export declare function isEntryFinalized(e: ChatEntry): boolean;
 type Listener = () => void;
 declare class ChatStore {
     private entries;
@@ -74,6 +89,16 @@ declare class ChatStore {
     append(data: ChatEntryData): void;
     /** Functional update — same API as setState(fn). */
     update(fn: (prev: ChatEntry[]) => ChatEntry[]): void;
+    /**
+     * Commit the in-flight streaming assistant entry as a final (non-streaming)
+     * message, optionally appending a suffix (e.g., "[Request interrupted by user]").
+     * Drops any thinking entries — model scratch, no user value after interruption.
+     * No-op if there is no streaming entry.
+     *
+     * Empty-text streaming entry is finalized in place (streaming=false) without
+     * suffix — keeps the store transition consistent without persisting noise.
+     */
+    commitInterruptedStreaming(suffix: string): void;
     clear(): void;
     subscribe(listener: Listener): () => void;
     private notify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Code Shell — general-purpose agent orchestration framework with a terminal coding preset",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,10 +44,13 @@
     "build": "bun run sync-models && bun run tsup && bun run build:dts",
     "build:dts": "tsc --emitDeclarationOnly --declaration --outDir dist || true",
     "sync-models": "bun run scripts/sync-models.ts",
-    "dev": "CODE_SHELL_DEV=1 bun run src/cli/main.ts",
+    "dev": "CODE_SHELL_DEV=1 CODESHELL_UI_PERF=1 bun run src/cli/main.ts",
+    "dev:bigtranscript": "bun run scripts/render-bigtranscript-dev.ts",
     "test": "bun test",
+    "bench:render": "bun run bench/render-tail.bench.ts && bun run bench/render-streaming.bench.ts && bun run bench/render-spinner.bench.ts && bun run bench/render-wheel.bench.ts",
     "test:watch": "bun test --watch",
     "lint": "eslint src/",
+    "lint:engine-bypass": "bash scripts/check-no-engine-bypass.sh",
     "format": "prettier --write 'src/**/*.ts'",
     "typecheck": "bun run tsc --noEmit",
     "prepublishOnly": "bun run build"
@@ -58,7 +61,6 @@
   "files": [
     "dist",
     "scripts/check-node.cjs",
-    "skills-builtin",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/dist/anthropic-OVRWAZRD.js

@@ -1 +0,0 @@
-export{a as AnthropicClient}from'./chunk-DEYFK6FP.js';import'./chunk-O5HFCH2U.js';import'./chunk-2EUIMKJA.js';import'./chunk-FU7AHZNN.js';import'./chunk-ZSAONDT6.js';import'./chunk-3QP5BQ3L.js';

package/dist/arena-64T2EQD4.js

@@ -1,3 +0,0 @@
-import {a as a$1}from'./chunk-MLCTC53I.js';import'./chunk-P6JSTIFM.js';import {c as c$1}from'./chunk-DTPABBSV.js';import {U,V,J,W,T as T$1,R as R$1,Q as Q$1}from'./chunk-2GJ7H5NC.js';export{W as formatArenaResultForSession}from'./chunk-2GJ7H5NC.js';import'./chunk-A4M2Y42L.js';import'./chunk-FU7AHZNN.js';import'./chunk-ZSAONDT6.js';import {h,a}from'./chunk-3QP5BQ3L.js';import l from'chalk';h();async function Q(e,s,a){let{models:n,mode:i,base:m,head:r,topic:t}=E(e),o=a?.output??(d=>console.log(d));if(!t){o(R());return}let f=j(s,n);if(f.length<2){o(L());return}let P=i?i.charAt(0).toUpperCase()+i.slice(1):"Auto";o(l.bold(`\u2550\u2550\u2550 Arena ${P} \u2550\u2550\u2550`)),o(l.dim(`Topic:  ${t}`)),o(l.dim(`Models: ${f.map(d=>d.name).join(" vs ")}`));let x=a?.output?U(a.output):V,O=new J({participants:f,mode:i,enableContextTools:true,onProgress:x});try{let d=await O.run(t,{mode:i,base:m,head:r}),y=a?.outputMessage??a?.output;return y?y(W(d)):T$1(d),d}catch(d){o(l.red(`Arena failed: ${d.message}`));return}}a(Q,"runArenaReview");function T(e){let s=new a$1;try{let a=new c$1(process.cwd()).get();if(a.models?.length)for(let n of a.models)s.register({key:n.key,label:n.label,provider:n.provider??"",model:n.model,baseUrl:n.baseUrl??e.llm.baseUrl,apiKey:n.apiKey??e.llm.apiKey,maxOutputTokens:n.maxOutputTokens});}catch{}return s}a(T,"buildModelPool");function K(e,s,a){if(typeof e=="string"){let n=s.get(e);return n?{name:n.label??c(n.model),llm:{provider:n.provider,model:n.model,apiKey:n.apiKey??a.llm.apiKey,baseUrl:n.baseUrl??a.llm.baseUrl,temperature:.3,maxTokens:n.maxOutputTokens??R$1(n.model),enableStreaming:false}}:void 0}return {name:e.name,llm:{provider:e.provider??a.llm.provider,model:e.model,apiKey:e.apiKey??a.llm.apiKey,baseUrl:e.baseUrl??a.llm.baseUrl,temperature:.3,maxTokens:R$1(e.model),enableStreaming:false}}}a(K,"resolveOneParticipant");function j(e,s){let a=T(e);if(s)return s.split(",").map(r=>r.trim().toLowerCase()).map(r=>{let t=a.get(r);if(t)return {name:t.label??c(t.model),llm:{provider:t.provider,model:t.model,apiKey:t.apiKey??e.llm.apiKey,baseUrl:t.baseUrl??e.llm.baseUrl,temperature:.3,maxTokens:t.maxOutputTokens??R$1(t.model),enableStreaming:false}};let o=Q$1[r];return o?{name:c(o.model),llm:{provider:o.provider,model:o.model,apiKey:e.llm.apiKey,baseUrl:e.llm.baseUrl,temperature:.3,maxTokens:o.maxOutputTokens,enableStreaming:false}}:{name:c(r),llm:{...e.llm,model:r,enableStreaming:false}}});let n=new c$1(process.cwd()).get();if(n.arena?.participants?.length>=2){let m=n.arena.participants.map(r=>K(r,a,e)).filter(r=>r!==void 0);if(m.length>=2)return m}let i=[{name:c(e.llm.model),llm:{...e.llm,maxTokens:R$1(e.llm.model),enableStreaming:false}}];if(e.llm.baseUrl?.includes("openrouter")){let r=e.llm.model.includes("claude")?"openai/gpt-5.4":"anthropic/claude-opus-4.6";i.push({name:c(r),llm:{...e.llm,model:r,maxTokens:R$1(r),enableStreaming:false}});}return i}a(j,"resolveParticipants");var S=["review","discussion","planning"];function E(e){let s,a,n,i,m=[],r=e.split(/\s+/);for(let t=0;t<r.length;t++)if(r[t]==="--models"&&r[t+1])s=r[++t];else if(r[t]==="--mode"&&r[t+1]){let o=r[++t].toLowerCase();S.includes(o)?a=o:console.log(l.yellow(`  Unknown mode "${o}", valid: ${S.join(", ")}`));}else r[t]==="--base"&&r[t+1]?n=r[++t]:r[t]==="--head"&&r[t+1]?i=r[++t]:m.push(r[t]);return {models:s,mode:a,base:n,head:i,topic:m.join(" ").trim()}}a(E,"parseFlags");function R(){return [l.bold("Arena \u2014 Multi-model collaborative analysis"),"",l.dim("Usage:"),"  /arena review the authentication module","  /arena --models claude,gpt4o is the error handling correct?","  /arena --mode planning design the new auth system","  /arena --mode discussion should we use REST or GraphQL","  /arena --base main review changes since main",'  code-shell arena "review my latest changes"',"",`${l.dim("Modes:")} review (default), discussion, planning`,l.dim("Mode is auto-detected from the topic if --mode is not specified."),"",l.dim("Flags:"),"  --base <ref>   Base branch/ref for comparison","  --head <ref>   Head branch/ref (default: HEAD)","",`${l.dim("Available model presets:")} ${Object.keys(Q$1).join(", ")}`].join(`
-`)}a(R,"formatUsage");function L(e){return [l.red("Arena needs at least 2 models."),"","Use --models to specify:","  /arena --models claude,gpt4o review the code","","Or configure in ~/.code-shell/settings.json:",'  "arena": { "participants": [','    { "name": "Claude", "model": "anthropic/claude-sonnet-4-20250514" },','    { "name": "GPT-4o", "model": "openai/gpt-4o" }',"  ]}"].join(`
-`)}a(L,"formatModelHelp");function c(e){return (e.split("/").pop()??e).replace(/-\d.*$/,"").split("-").map(a=>a.charAt(0).toUpperCase()+a.slice(1)).join(" ")}a(c,"modelDisplayName");export{Q as runArenaReview};