@cjhyy/code-shell 0.1.0-alpha.0 → 0.1.0-alpha.2

package/dist/tool-system/builtin/apply-patch/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * V4A patch AST. A parsed patch is a list of Hunks; each Hunk targets one file.
+ *
+ * Three variants:
+ *   - AddFile:    create a new file with the given contents
+ *   - DeleteFile: remove an existing file
+ *   - UpdateFile: in-place edit (optionally with a rename via movePath),
+ *                 expressed as one or more UpdateFileChunks.
+ */
+export type Hunk = {
+    kind: "add";
+    path: string;
+    contents: string;
+} | {
+    kind: "delete";
+    path: string;
+} | {
+    kind: "update";
+    path: string;
+    movePath?: string;
+    chunks: UpdateFileChunk[];
+};
+export interface UpdateFileChunk {
+    /** Optional `@@ <context>` anchor that narrows where this chunk applies. */
+    changeContext?: string;
+    /** Lines that must match in the existing file (` ` and `-` markers). */
+    oldLines: string[];
+    /** Lines that should appear after the edit (` ` and `+` markers). */
+    newLines: string[];
+    /** True if this chunk ended with `*** End of File`; matches only at EOF. */
+    isEndOfFile: boolean;
+}
+export declare class PatchParseError extends Error {
+    readonly kind: "InvalidPatch" | "InvalidHunk";
+    readonly lineNumber?: number;
+    constructor(kind: "InvalidPatch" | "InvalidHunk", message: string, lineNumber?: number);
+}
+/**
+ * Result of staging (dry-run) a single file's planned change.
+ *
+ * A rename is represented as two PlannedFileChange entries: one for the
+ * source path with `newContent: null` (delete) and one for the destination
+ * path with the new content.
+ */
+export interface PlannedFileChange {
+    path: string;
+    /** null = delete; string = create-or-overwrite with this content. */
+    newContent: string | null;
+}

package/dist/tool-system/builtin/arena.d.ts

@@ -8,11 +8,24 @@
  * setArenaLLMConfig(), following the same pattern as setAskUserFn() and
  * setSubAgentConfig().
  */
-import type { ToolDefinition, LLMConfig } from "../../types.js";
+import type { ToolDefinition } from "../../types.js";
+import type { ToolContext } from "../context.js";
 export declare const arenaToolDef: ToolDefinition;
 /**
- * Inject the engine's LLM config so Arena participants inherit baseUrl/apiKey.
- * Called by Engine.run() alongside setAskUserFn(), setSubAgentConfig(), etc.
+ * Snapshot of what Arena would do right now if invoked. Used by the
+ * `/arena` REPL command (via the protocol `arena_status` query) so
+ * users can see participants/endpoint before launching a run.
  */
-export declare function setArenaLLMConfig(config: LLMConfig | undefined): void;
-export declare function arenaTool(args: Record<string, unknown>): Promise<string>;
+export interface ArenaStatus {
+    endpoint?: string;
+    defaultParticipants: Array<{
+        name: string;
+        model: string;
+        source: "pool" | "preset" | "raw";
+        compatible: boolean;
+        reason?: string;
+    }>;
+    poolSize: number;
+}
+export declare function getArenaStatus(): ArenaStatus;
+export declare function arenaTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/ask-user.d.ts

@@ -1,12 +1,12 @@
 /**
  * Built-in AskUserQuestion tool — ask the user a question during execution.
+ *
+ * The actual prompt-the-user implementation is provided per-Engine via
+ * ToolContext.askUser. Headless mode (no UI wired up) leaves askUser
+ * undefined and the tool reports back asking the LLM to assume.
  */
 import type { ToolDefinition } from "../../types.js";
+import type { ToolContext } from "../context.js";
 export declare const askUserToolDef: ToolDefinition;
-/**
- * Factory: the actual executor is injected at runtime by the Engine,
- * because it depends on the CLI/UI layer to collect user input.
- */
 export type AskUserFn = (question: string) => Promise<string>;
-export declare function setAskUserFn(fn: AskUserFn | undefined): void;
-export declare function askUserTool(args: Record<string, unknown>): Promise<string>;
+export declare function askUserTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/index.d.ts

@@ -2,7 +2,17 @@
  * Built-in tool registration.
  */
 import type { RegisteredTool } from "../../types.js";
-export type BuiltinToolFn = (args: Record<string, unknown>) => Promise<string>;
+/**
+ * Tool executor signature.
+ *
+ * Tools may inspect ctx for runtime services (askUser, llmConfig, modelPool,
+ * toolRegistry, subAgentSpawner). Tools that don't need any of these — Read,
+ * Write, Bash, Edit, Glob, Grep, etc. — may simply ignore the second arg.
+ *
+ * ctx is optional in the signature so legacy call sites (and tests) that
+ * pass only args still type-check; ToolRegistry always passes ctx at runtime.
+ */
+export type BuiltinToolFn = (args: Record<string, unknown>, ctx?: import("../context.js").ToolContext) => Promise<string>;
 export interface BuiltinTool {
     definition: RegisteredTool;
     execute: BuiltinToolFn;

package/dist/tool-system/builtin/tool-search.d.ts

@@ -6,7 +6,6 @@
  * saving context by not loading all MCP tool schemas upfront.
  */
 import type { ToolDefinition } from "../../types.js";
-import type { ToolRegistry } from "../registry.js";
+import type { ToolContext } from "../context.js";
 export declare const toolSearchToolDef: ToolDefinition;
-export declare function setToolSearchRegistry(registry: ToolRegistry): void;
-export declare function toolSearchTool(args: Record<string, unknown>): Promise<string>;
+export declare function toolSearchTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/context.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ToolContext — runtime services injected into every tool execution.
+ *
+ * Replaces the legacy module-level singletons (`setAskUserFn`,
+ * `setArenaLLMConfig`, `setSubAgentConfig`, `setToolSearchRegistry`).
+ *
+ * Each Engine instance builds its own ToolContext when run() starts and
+ * passes it through ToolExecutor → ToolRegistry → executor function.
+ * That makes concurrent Engine instances safe: tools never see another
+ * Engine's askUser handler or LLM credentials.
+ *
+ * Tools that don't need any context (Read/Write/Bash/...) just ignore
+ * the second argument; the type is purely additive.
+ */
+import type { LLMConfig, StreamCallback } from "../types.js";
+import type { ModelPool } from "../llm/model-pool.js";
+import type { ToolRegistry } from "./registry.js";
+import type { AgentPresetName } from "../preset/index.js";
+/** Function the host UI / server uses to ask the user a question. */
+export type AskUserFn = (question: string) => Promise<string>;
+/** Spawn a sub-agent. Returns the produced text or throws. */
+export interface SubAgentSpawnRequest {
+    agentId: string;
+    description: string;
+    prompt: string;
+    maxTurns: number;
+    signal: AbortSignal;
+}
+export interface SubAgentSpawner {
+    /** Run a sub-agent synchronously and return its text output. */
+    spawn(req: SubAgentSpawnRequest): Promise<string>;
+    /** Stream callback to forward sub-agent events back to the parent UI. */
+    parentStream?: StreamCallback;
+    /** Static config used to describe what the spawned engine looks like. */
+    describe(): {
+        cwd: string;
+        preset?: AgentPresetName;
+        permissionMode: string;
+    };
+}
+/**
+ * The full context object handed to every tool invocation.
+ *
+ * Optional fields are filled in by Engine.run(); some headless paths may
+ * leave them undefined (e.g. running without UI → no askUser).
+ */
+export interface ToolContext {
+    /** Active working directory for this Engine. */
+    cwd: string;
+    /** LLM credentials/endpoint for tools that need to make their own calls. */
+    llmConfig: LLMConfig;
+    /** Active model pool (Arena reads this to pick participants). */
+    modelPool?: ModelPool;
+    /** Tool registry (ToolSearch reads this to enumerate available tools). */
+    toolRegistry: ToolRegistry;
+    /** UI-backed AskUserQuestion handler. Undefined → headless mode. */
+    askUser?: AskUserFn;
+    /** Sub-agent spawner (Agent tool). Undefined → Agent tool unavailable. */
+    subAgentSpawner?: SubAgentSpawner;
+    /** Optional cancellation signal for the whole turn. */
+    signal?: AbortSignal;
+}
+/**
+ * Per-Engine container that produces a fresh ToolContext on demand.
+ * Engine creates one of these in run() and passes it to ToolExecutor.
+ */
+export declare class ServiceContainer {
+    private readonly base;
+    constructor(base: ToolContext);
+    /** Snapshot of the context at this moment. */
+    get(): ToolContext;
+    /** Create a derived context with overridden fields (e.g. per-call signal). */
+    withSignal(signal: AbortSignal): ToolContext;
+}

package/dist/tool-system/executor.d.ts

@@ -5,14 +5,29 @@ import type { ToolCall, ToolResult, Message } from "../types.js";
 import type { HookRegistry } from "../hooks/registry.js";
 import { ToolRegistry } from "./registry.js";
 import { PermissionClassifier } from "./permission.js";
+import { logger as rootLogger } from "../logging/logger.js";
+import type { ToolContext } from "./context.js";
+type Logger = typeof rootLogger;
 export declare class ToolExecutor {
     private readonly registry;
     private readonly permission;
     private readonly hooks;
     private signal?;
+    /** Per-Engine ToolContext injected for every tool call. */
+    private toolCtx?;
+    /**
+     * Turn-scoped logger set by TurnLoop at the top of each iteration.
+     * Falls back to the root logger so executor calls outside the turn loop
+     * (tests, ad-hoc tool runs) still write log lines, just without turn tags.
+     */
+    private log;
     constructor(registry: ToolRegistry, permission: PermissionClassifier, hooks: HookRegistry);
     /** Set the abort signal for cascading cancellation. */
     setSignal(signal?: AbortSignal): void;
+    /** Set the per-Engine ToolContext (askUser, llmConfig, modelPool, etc.). */
+    setContext(ctx: ToolContext | undefined): void;
+    /** Inject a turn-scoped logger so tool-execution lines carry turn/turnId. */
+    setLogger(log: Logger): void;
     /** Check if a tool is safe for concurrent execution (read-only). */
     isConcurrencySafe(toolName: string): boolean;
     executeSingle(call: ToolCall): Promise<ToolResult>;
@@ -23,3 +38,4 @@ export declare class ToolExecutor {
      */
     resultsToMessages(toolCalls: ToolCall[], results: ToolResult[]): Message[];
 }
+export {};

package/dist/tool-system/permission.d.ts

@@ -2,6 +2,7 @@
  * Permission system — classifier + approval backend.
  */
 import type { PermissionDecision, PermissionMode, PermissionRule, ApprovalRequest, ApprovalResult } from "../types.js";
+import { logger as rootPermLogger } from "../logging/logger.js";
 export interface ApprovalBackend {
     requestApproval(request: ApprovalRequest): Promise<ApprovalResult>;
 }
@@ -22,14 +23,33 @@ export declare class AutoApprovalBackend implements ApprovalBackend {
 }
 /**
  * Interactive approval backend — prompts the user via a callback.
- * Supports "always allow" rules that persist for the session.
+ *
+ * Stores "always allow" decisions at two scopes:
+ *   - session: in-memory map, lost when the process exits
+ *   - project: persisted to <cwd>/.code-shell/settings.local.json so the
+ *              same project remembers the rule across REPL restarts
+ *
+ * The classifier reads project rules from settings on session start (see
+ * Engine.buildPermissionConfig), so persisted rules become "auto-allow"
+ * the next time the user opens the project.
  */
 export declare class InteractiveApprovalBackend implements ApprovalBackend {
     private sessionRules;
     private promptFn;
+    private cwd;
+    private savedProjectRules;
+    private onProjectRules;
     setPromptFn(fn: (request: ApprovalRequest) => Promise<ApprovalResult>): void;
+    /** Inject the project root so persistence writes to the right settings file. */
+    setCwd(cwd: string): void;
+    /**
+     * Inject a callback fired when the user approves "for this project". The
+     * callback receives the *full* accumulated list of project rules saved in
+     * this session, so the classifier can be reconfigured without losing
+     * earlier approvals.
+     */
+    setOnProjectRules(fn: (rules: PermissionRule[]) => void): void;
     requestApproval(req: ApprovalRequest): Promise<ApprovalResult>;
-    private ruleKeyFromArgs;
 }
 export declare function getInteractiveApprovalBackend(): InteractiveApprovalBackend;
 export declare function setInteractiveApprovalFn(fn: (request: ApprovalRequest) => Promise<ApprovalResult>): void;
@@ -52,11 +72,21 @@ export declare class DenialTracker {
 export declare function setRuntimeBypass(enabled: boolean): void;
 export declare function isRuntimeBypass(): boolean;
 export declare class PermissionClassifier {
-    private readonly rules;
-    private readonly defaultMode;
-    private readonly approvalBackend;
+    private rules;
+    private defaultMode;
+    private approvalBackend;
     private denialTracker;
+    /**
+     * Turn-scoped logger so permission events (ask/decision/auto-deny) are
+     * tagged with the current turn/turnId. Falls back to the root logger so
+     * tests and ad-hoc usages still write log lines.
+     */
+    private log;
     constructor(rules: PermissionRule[], defaultMode?: PermissionMode, approvalBackend?: ApprovalBackend);
+    setLogger(log: typeof rootPermLogger): void;
+    /** Replace mode + backend in place so live tool execution sees the change. */
+    reconfigure(mode: PermissionMode, approvalBackend: ApprovalBackend, rules?: PermissionRule[]): void;
+    getMode(): PermissionMode;
     classify(toolName: string, args: Record<string, unknown>): PermissionDecision;
     handleAsk(toolName: string, args: Record<string, unknown>): Promise<boolean>;
     /** Get denial warning message if the model keeps getting denied. */
@@ -64,6 +94,11 @@ export declare class PermissionClassifier {
     private matchesRule;
     private isDangerousCommand;
     private assessRisk;
+    /**
+     * Short, human-friendly subtitle. The UI shows this under the tool title;
+     * full args (command bodies, diffs, etc.) come from the args field, so this
+     * stays compact — no truncation here, just a label.
+     */
     private describeToolCall;
 }
 export {};

package/dist/tool-system/registry.d.ts

@@ -3,6 +3,13 @@
  */
 import type { RegisteredTool, ToolDefinition, ToolResult } from "../types.js";
 import { type BuiltinToolFn } from "./builtin/index.js";
+import type { ToolContext } from "./context.js";
+/**
+ * Default execution timeout for any tool that does not declare its own
+ * timeoutMs at registration time. Tools that need to run longer (Agent,
+ * Arena, Bash, custom long-running tools) should set timeoutMs explicitly.
+ */
+export declare const DEFAULT_TOOL_TIMEOUT_MS = 120000;
 export interface ToolRegistryOptions {
     builtinTools?: readonly string[];
 }
@@ -18,6 +25,7 @@ export declare class ToolRegistry {
     executeTool(name: string, args: Record<string, unknown>, options?: {
         timeoutMs?: number;
         signal?: AbortSignal;
+        ctx?: ToolContext;
     }): Promise<ToolResult>;
     listTools(): string[];
     listToolsDetailed(): RegisteredTool[];

package/dist/types.d.ts

@@ -2,7 +2,7 @@
  * Core type definitions for the code-shell orchestration framework.
  */
 export interface ContentBlock {
-    type: "text" | "tool_use" | "tool_result" | "image";
+    type: "text" | "tool_use" | "tool_result" | "image" | "reasoning";
     text?: string;
     id?: string;
     name?: string;
@@ -14,6 +14,7 @@ export interface ContentBlock {
         media_type: string;
         data: string;
     };
+    reasoningContent?: string;
 }
 export interface Message {
     role: "system" | "user" | "assistant" | "tool";
@@ -49,6 +50,12 @@ export interface RegisteredTool {
     permissionDefault: PermissionDecision;
     isConcurrencySafe?: boolean;
     isReadOnly?: boolean;
+    /**
+     * Override the default tool execution timeout (ms).
+     * Falls back to DEFAULT_TOOL_TIMEOUT_MS (120s) if unset.
+     * The caller of executeTool() can still override via options.timeoutMs.
+     */
+    timeoutMs?: number;
 }
 export type TranscriptEventType = "message" | "tool_use" | "tool_result" | "summary" | "content_replace" | "file_history" | "plan_operation" | "session_meta" | "turn_boundary" | "error";
 export interface TranscriptEvent {
@@ -118,14 +125,25 @@ export interface ApprovalRequest {
     description: string;
     riskLevel: "low" | "medium" | "high";
 }
+/**
+ * Scope of an "always allow" decision.
+ *   "once"    — this single call only (default when always not set)
+ *   "session" — remembered for the rest of the REPL session (in-memory)
+ *   "project" — persisted to <cwd>/.code-shell/settings.local.json so it
+ *               survives restart for the current project. Not committed.
+ */
+export type ApprovalScope = "once" | "session" | "project";
 export type ApprovalResult = {
     approved: true;
     permanent?: boolean;
     always?: boolean;
+    scope?: ApprovalScope;
+    /** Used by AskUserQuestion to carry the user's free-text answer. */ answer?: string;
 } | {
     approved: false;
     reason?: string;
     always?: boolean;
+    scope?: ApprovalScope;
 };
 export type TurnPhase = "pre_check" | "model_call" | "post_check" | "tool_exec" | "context_mgmt" | "hook_notify" | "complete" | "error";
 export interface TurnResult {
@@ -142,6 +160,9 @@ export interface TaskInfo {
     status: "pending" | "in_progress" | "completed" | "stopped";
 }
 export type StreamEvent = {
+    type: "session_started";
+    sessionId: string;
+} | {
     type: "stream_request_start";
     turnNumber: number;
     agentId?: string;
@@ -153,6 +174,11 @@ export type StreamEvent = {
     type: "tool_use_start";
     toolCall: ToolCall;
     agentId?: string;
+} | {
+    type: "tool_use_args_delta";
+    toolCallId: string;
+    args: Record<string, unknown>;
+    agentId?: string;
 } | {
     type: "tool_result";
     result: ToolResult;
@@ -191,6 +217,12 @@ export type StreamEvent = {
 } | {
     type: "tool_summary";
     summary: string;
+} | {
+    type: "context_compact";
+    strategy: "summary" | "window" | "snip" | "emergency";
+    before: number;
+    after: number;
+    agentId?: string;
 };
 export type StreamCallback = (event: StreamEvent) => void | Promise<void>;
 export interface LLMConfig {
@@ -210,6 +242,7 @@ export interface LLMResponse {
     toolCalls: ToolCall[];
     usage?: TokenUsage;
     stopReason?: string;
+    reasoningContent?: string;
 }
 export interface LLMStreamChunk {
     type: "text" | "tool_use_start" | "tool_use_delta" | "tool_use_end" | "stop";

package/dist/ui/App.d.ts

@@ -10,5 +10,5 @@ interface AppProps {
     /** Pre-fill the input box without submitting (--prefill flag). */
     prefill?: string;
 }
-export declare function App({ client, model: initialModel, effort, maxTurns, cwd, maxContextTokens, sessionId: initialSessionId, prefill }: AppProps): import("react/jsx-runtime").JSX.Element;
+export declare function App({ client, model: initialModel, effort, maxTurns, cwd, maxContextTokens, sessionId: initialSessionId, prefill, }: AppProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -25,7 +25,7 @@ export declare function AgentBlockEnd({ description, error, isLast }: AgentBlock
 /**
  * Tree line prefix for nested content under an agent.
  */
-export declare function NestedPrefix({ children, isLast }: {
+export declare function NestedPrefix({ children, isLast, }: {
     children: React.ReactNode;
     isLast?: boolean;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,7 @@
+interface AskUserPromptProps {
+    question: string;
+    onAnswer: (answer: string) => void;
+    onCancel: () => void;
+}
+export declare function AskUserPrompt({ question, onAnswer, onCancel }: AskUserPromptProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,22 +1,26 @@
 interface MessageContentProps {
     text: string;
     streaming?: boolean;
+    /** When rendered inside an agent block, suppress the leading message gap. */
+    nested?: boolean;
 }
-export declare function MessageContent({ text, streaming }: MessageContentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function MessageContent({ text, streaming, nested }: MessageContentProps): import("react/jsx-runtime").JSX.Element | null;
 interface UserMessageProps {
     text: string;
 }
 export declare function UserMessage({ text }: UserMessageProps): import("react/jsx-runtime").JSX.Element;
 interface ErrorMessageProps {
     error: string;
+    nested?: boolean;
 }
-export declare function ErrorMessage({ error }: ErrorMessageProps): import("react/jsx-runtime").JSX.Element;
+export declare function ErrorMessage({ error, nested }: ErrorMessageProps): import("react/jsx-runtime").JSX.Element;
 export declare function RateLimitMessage({ text }: {
     text: string;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function ContextLimitMessage(): import("react/jsx-runtime").JSX.Element;
-export declare function ThinkingMessage({ content, collapsed }: {
+export declare function ThinkingMessage({ content, collapsed, nested, }: {
     content?: string;
     collapsed?: boolean;
+    nested?: boolean;
 }): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,35 @@
+import type { ProtocolModelEntry } from "../../protocol/types.js";
+interface SnapshotInfo {
+    count: number;
+    fetchedAt: string;
+}
+/**
+ * Settings stores arena.participants as Array<string | object>. The panel
+ * surfaces strings (pool keys); object-form entries are shown read-only so
+ * we don't clobber a user's hand-edited config.
+ */
+export type ArenaParticipantEntry = {
+    kind: "key";
+    value: string;
+} | {
+    kind: "object";
+    label: string;
+};
+interface ModelManagerProps {
+    entries: ProtocolModelEntry[];
+    snapshot: SnapshotInfo;
+    arenaParticipants: ArenaParticipantEntry[];
+    /** Activate a model. */
+    onSwitch: (key: string) => Promise<void>;
+    /** Trigger an OpenRouter snapshot refresh. */
+    onSync: () => Promise<{
+        ok: boolean;
+        count: number;
+        error?: string;
+    }>;
+    /** Persist updated participant list (string[]) to settings. */
+    onSaveArena: (participants: string[]) => Promise<void>;
+    onClose: () => void;
+}
+export declare function ModelManager({ entries, snapshot, arenaParticipants, onSwitch, onSync, onSaveArena, onClose, }: ModelManagerProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import type { ProtocolModelEntry } from "../../protocol/types.js";
+/** Re-export under the UI name for convenience. */
+export type ModelEntry = ProtocolModelEntry;
+interface ModelSelectorProps {
+    entries: ModelEntry[];
+    onSelect: (key: string) => void;
+    onCancel: () => void;
+}
+export declare function ModelSelector({ entries, onSelect, onCancel }: ModelSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import { type OnboardingResult } from "../../cli/onboarding.js";
+interface OnboardingPromptProps {
+    onComplete: (result: OnboardingResult) => void;
+    onCancel: () => void;
+}
+export declare function OnboardingPrompt({ onComplete, onCancel }: OnboardingPromptProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -1,8 +1,11 @@
+import type { ApprovalScope } from "../../types.js";
 interface PermissionPromptProps {
     toolName: string;
     description: string;
     riskLevel: string;
-    onDecision: (approved: boolean, always: boolean) => void;
+    args: Record<string, unknown>;
+    cwd: string;
+    onDecision: (approved: boolean, scope: ApprovalScope) => void;
 }
-export declare function PermissionPrompt({ toolName, description, riskLevel, onDecision }: PermissionPromptProps): import("react/jsx-runtime").JSX.Element;
+export declare function PermissionPrompt({ toolName, description, riskLevel, args, cwd, onDecision, }: PermissionPromptProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,14 @@
+export interface SessionPickerEntry {
+    sessionId: string;
+    startedAt: number;
+    turnCount: number;
+    preview?: string;
+    cwd?: string;
+}
+interface SessionPickerProps {
+    entries: SessionPickerEntry[];
+    onSelect: (sessionId: string) => void;
+    onCancel: () => void;
+}
+export declare function SessionPicker({ entries, onSelect, onCancel }: SessionPickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -12,11 +12,13 @@ interface StatusLineProps {
     tokens: number;
     cost: number;
     sessionId?: string;
-    contextPercent?: number;
+    /** Last known prompt tokens from completed turn. Live streaming is added on top. */
+    baseContextTokens?: number;
+    maxContextTokens?: number;
     gitBranch?: string;
     isRunning?: boolean;
     streamingCharsRef?: MutableRefObject<number>;
     runStartRef?: MutableRefObject<number>;
 }
-export declare function StatusLine({ model, effort, tokens, cost, sessionId, contextPercent, gitBranch, isRunning, streamingCharsRef, runStartRef, }: StatusLineProps): import("react/jsx-runtime").JSX.Element;
+export declare function StatusLine({ model, effort, tokens, cost, sessionId, baseContextTokens, maxContextTokens, gitBranch, isRunning, streamingCharsRef, runStartRef, }: StatusLineProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -7,7 +7,7 @@
  * version uses the lightweight ui/theme.ts context.
  */
 import React from "react";
-import { type BoxProps } from "../../ink/index.js";
+import { type BoxProps } from "../../render/index.js";
 import type { Theme } from "../../utils/theme.js";
 type ColorProp = keyof Theme | string;
 export interface ThemedBoxProps extends Omit<BoxProps, "borderColor" | "backgroundColor"> {

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

@@ -16,6 +16,13 @@ interface ToolCallResultProps {
     nested?: boolean;
     /** When true, show full output instead of collapsed preview. */
     expanded?: boolean;
+    /**
+     * When true, render as a single dim line — used for transient
+     * "this attempt failed and was retried" cases (e.g. Arena's
+     * fail-fast endpoint check) so the feed isn't swamped with scary
+     * red error cards for what was just a parameter fix-up.
+     */
+    compact?: boolean;
 }
-export declare function ToolCallResult({ toolName, result, error, nested, expanded: forceExpand }: ToolCallResultProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToolCallResult({ toolName, result, error, nested, expanded: forceExpand, compact, }: ToolCallResultProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,5 @@
+interface WelcomeTipsProps {
+    cwd: string;
+}
+export declare function WelcomeTips({ cwd }: WelcomeTipsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/onboarding-runner.d.ts

@@ -0,0 +1,2 @@
+import type { OnboardingResult } from "../cli/onboarding.js";
+export declare function runInkOnboarding(): Promise<OnboardingResult | null>;

package/dist/ui/store.d.ts

@@ -17,6 +17,7 @@ type ChatEntryData = {
     type: "tool_start";
     toolName: string;
     args: Record<string, unknown>;
+    toolCallId?: string;
     agentId?: string;
 } | {
     type: "tool_running";