@cjhyy/code-shell 0.1.7 → 0.3.0

package/dist/cli/onboarding.d.ts

@@ -23,9 +23,14 @@ export interface ProviderDef {
     envKey: string;
     provider: string;
     baseUrl: string;
-    defaultModel: string;
     keyUrl: string;
     keyPrefix: string;
+    /**
+     * The catalog of model IDs to register for this provider. The first
+     * entry doubles as the zero-config default — auto-activated when the
+     * user boots with just an env key (no onboarding). Users override by
+     * picking in the wizard or running `/model`.
+     */
     models: string[];
     /** When true, skip API key prompt (e.g. local providers like Ollama). */
     noKey?: boolean;
@@ -77,7 +82,7 @@ export declare function findSavedKeyForProvider(provider: ProviderDef): {
  * Return the list of model IDs previously saved under this provider
  * (matched by baseUrl). Used by the onboarding wizard to pre-populate the
  * "model pool" step with the user's prior choices instead of resetting to
- * just provider.defaultModel.
+ * just the provider's first model.
  */
 export declare function loadSavedModelsForProvider(provider: ProviderDef): string[];
 export declare function hasApiKey(): boolean;

package/dist/client-base-GSFXPP2Y.js

@@ -0,0 +1 @@
+export{a as LLMClientBase}from'./chunk-OWBYLMDD.js';import'./chunk-FU7AHZNN.js';import'./chunk-DI26OUIU.js';import'./chunk-3QP5BQ3L.js';

package/dist/compaction-L3Y6NG4N.js

@@ -0,0 +1 @@
+import {p}from'./chunk-M7VU4YVY.js';export{e as COMPACTABLE_TOOL_NAMES,b as adjustIndexToPreserveAPIInvariants,k as applySummaryCompaction,g as applyToolResultBudget,i as buildSummarizationPrompt,m as dropOldestRounds,a as estimateTokens,j as extractAnchoredSummary,n as extractReferencedFilePaths,l as groupMessagesByApiRound,f as microcompact,c as snipCompact,h as truncateToolResult,d as windowCompact}from'./chunk-M7VU4YVY.js';import'./chunk-3QP5BQ3L.js';p();

package/dist/context/compaction.d.ts

@@ -89,7 +89,8 @@ export declare function truncateToolResult(result: string, maxChars?: number): s
  * Build a structured summarization prompt from messages to be compacted.
  * Produces a 9-section summary preserving key details.
  */
-export declare function buildSummarizationPrompt(messagesToSummarize: Message[]): string;
+export declare function buildSummarizationPrompt(messagesToSummarize: Message[], priorSummary?: string): string;
+export declare function extractAnchoredSummary(messages: Message[]): string | undefined;
 /**
  * Apply LLM-generated summary compaction (hybrid mode).
  *

package/dist/data/static-catalogs.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hand-maintained static model catalogs for providers whose /v1/models
+ * endpoint returns only ids — no context window, max output, or pricing.
+ *
+ * At runtime we still call the live /models endpoint to discover ids
+ * (so newly-released models work without a code update), then left-join
+ * this table on `id` to fill in metadata. Edit the JSONs in src/data/
+ * when a vendor ships a new model.
+ *
+ * OpenRouter is NOT here — its catalog is generated at build time by
+ * scripts/sync-models.ts because OpenRouter exposes full metadata.
+ */
+import type { ProviderKindName } from "../llm/provider-kinds.js";
+export interface StaticModel {
+    id: string;
+    name: string;
+    contextLength: number;
+    maxOutputTokens: number;
+    inputPricePerMillion: number;
+    outputPricePerMillion: number;
+    modalities: string[];
+    thinking?: boolean;
+}
+export declare function listStaticModels(kind: ProviderKindName): StaticModel[];
+export declare function hasStaticCatalog(kind: ProviderKindName): boolean;

package/dist/devtools-FBX4HVVY.js

@@ -0,0 +1 @@
+export{a as recordFrame,b as renderDevtools}from'./chunk-GYNO4R7R.js';import'./chunk-3QP5BQ3L.js';

package/dist/engine/engine.d.ts

@@ -51,6 +51,14 @@ export interface EngineConfig {
      * the loop to approve commands.
      */
     sandbox?: SandboxConfig;
+    /**
+     * True when this Engine is itself a sub-agent (spawned by another
+     * Engine's Agent tool). Threaded into ToolContext so the Agent tool can
+     * refuse re-entry — defense in depth against the tool-list strip in
+     * spawn(): if a tool registry regression ever leaks Agent into a child's
+     * pool, the runtime check still blocks the call.
+     */
+    isSubAgent?: boolean;
 }
 export interface EngineHookConfig {
     event: HookEventName;
@@ -78,10 +86,41 @@ export declare class Engine {
     private lastMessages;
     private lastSessionId;
     private compactedMessagesBySession;
+    /**
+     * SIDs whose ctx-bar seed we've already emitted in this process. The seed
+     * is a rough char/4 estimate; only useful before the first real
+     * usage_update arrives (cold start or cross-process resume). On subsequent
+     * turns the UI already shows the previous turn's accurate ctx — re-seeding
+     * would visibly drop the bar on every submit.
+     */
+    private ctxSeedSent;
+    /**
+     * Per-sid cache of "non-messages overhead" (system prompt + tool defs, in
+     * tokens). Survives across turns so each fresh TurnLoop instance can seed
+     * its first pre-llm emit with the right offset — without this the ctx bar
+     * visibly drops on every user submit (e.g. from ~20k → 3k) until the next
+     * LLM response arrives.
+     */
+    private ctxOverheadBySid;
     private activePermission;
     /** Public accessor so UI/clients can read the resolved per-model window. */
     get maxContextTokens(): number;
     private resolveMaxContextTokens;
+    /**
+     * Emit a lifecycle hook with isSubAgent auto-merged into data so handlers
+     * can skip noisy injections for spawned children. All Engine-side hook
+     * emits should go through this wrapper to keep the context envelope
+     * uniform with TurnLoop.emitHook.
+     */
+    private emitHook;
+    /**
+     * Read settings.hooks and register a shell-runner wrapper handler per
+     * entry. Sub-agents skip shell hooks entirely — spawning child processes
+     * per emit for every sub-agent run would multiply token-side overhead
+     * for marginal value; explicit users who want sub-agent observability
+     * should register SDK-side handlers.
+     */
+    private registerSettingsHooks;
     constructor(config: EngineConfig);
     /**
      * Load models[] / providers[] from settings into the active ModelPool and
@@ -121,6 +160,12 @@ export declare class Engine {
         signal?: AbortSignal;
         sessionId?: string;
     }): Promise<EngineResult>;
+    /**
+     * Run the end-of-session memory pipeline as a fire-and-forget background
+     * task. Extracts durable memories from the transcript, saves a session
+     * summary, and conditionally triggers auto-dream consolidation.
+     */
+    private runMemoryPipeline;
     getToolRegistry(): ToolRegistry;
     /**
      * Switch the active model by pool key. Takes effect on the next run() call.

package/dist/engine/turn-loop.d.ts

@@ -23,6 +23,11 @@ export interface TurnLoopConfig {
      */
     onTurnBoundary?: (turnCount: number) => void;
 }
+export interface CtxOverheadStore {
+    /** Tokens for system prompt + tool defs, derived from provider's promptTokens. */
+    get(sid: string): number;
+    set(sid: string, tokens: number): void;
+}
 export interface TurnLoopDeps {
     model: ModelFacade;
     toolExecutor: ToolExecutor;
@@ -31,6 +36,28 @@ export interface TurnLoopDeps {
     transcript: Transcript;
     systemPrompt: string;
     tools: import("../types.js").ToolDefinition[];
+    /** Per-sid overhead cache so the ctx bar doesn't drop between turns. */
+    ctxOverheadStore: CtxOverheadStore;
+    /** Current session id, used to key the overhead store. */
+    sessionId: string;
+    /**
+     * Carried into every hook emit's `ctx.data.isSubAgent` so handlers can
+     * skip noisy injections for spawned children. Set by Engine from
+     * EngineConfig.isSubAgent (engine.ts:119).
+     */
+    isSubAgent?: boolean;
+    /**
+     * Reads/clears the most recent compaction event emitted by
+     * ContextManager since the last call. Returns `null` if no compaction
+     * fired since the previous check. The Engine wires this up so the
+     * turn loop can `post_compact` emit + inject hook messages without
+     * the ContextManager itself depending on HookRegistry.
+     */
+    consumePendingCompactInfo?: () => {
+        strategy: string;
+        before: number;
+        after: number;
+    } | null;
 }
 export interface TurnLoopResult {
     text: string;
@@ -50,7 +77,25 @@ export declare class TurnLoop {
      * every line they write is tagged with the current turn/turnId.
      */
     private currentTurnLog;
+    /** Last emitted ctx token estimate; used to skip no-op usage_update events. */
+    private lastCtxEmit;
     constructor(deps: TurnLoopDeps, config: TurnLoopConfig);
+    /**
+     * Emit a lifecycle hook with isSubAgent + sessionId auto-merged into data.
+     * Returns the aggregated HookResult so callers can consume `messages` /
+     * `decision` / `stop`. Use this instead of `deps.hooks.emit` directly so
+     * every emit carries the same context envelope.
+     */
+    private emitHook;
+    /**
+     * Emit a usage_update so the UI ctx bar reflects current message-array
+     * size. Called at every point where messages mutate: after a tool_result
+     * is appended, after context management (which may shrink), and after an
+     * LLM response (which we also feed through with the provider's authoritative
+     * promptTokens to override our estimate).
+     */
+    private emitCtxFromMessages;
+    private emitCtxFromUsage;
     /**
      * Run the multi-turn agent loop until completion.
      */

package/dist/hooks/events.d.ts

@@ -5,16 +5,72 @@
  * Lifecycle hooks the engine emits.
  *
  * **Currently emitted** (handlers registered here will actually fire):
- *   - on_agent_start / on_agent_end        (engine.ts)
- *   - on_turn_start / on_turn_end          (turn-loop.ts)
- *   - pre_tool_use / post_tool_use         (executor.ts)
+ *   - on_session_start / on_session_end    (engine.ts) — fires once per Engine.run().
+ *                                          on_session_start handlers may return
+ *                                          `messages` to inject a <system-reminder>
+ *                                          at the head of the conversation, before
+ *                                          the current user prompt.
+ *   - on_agent_start / on_agent_end        (engine.ts) — notify-only; returned
+ *                                          messages are NOT consumed (the loop
+ *                                          is already armed by the time these
+ *                                          fire). Use on_session_start instead.
+ *   - user_prompt_submit                   (engine.ts) — fires once per run() for
+ *                                          every new user prompt (cold-start and
+ *                                          resume both qualify). Returned messages
+ *                                          are merged into the same lifecycle
+ *                                          <system-reminder> as on_session_start.
+ *   - on_turn_start / on_turn_end          (turn-loop.ts) — on_turn_start handlers
+ *                                          may return `messages` to inject a
+ *                                          per-turn reminder appended to the
+ *                                          conversation right before the model call.
+ *   - pre_tool_use / post_tool_use         (executor.ts) — pre_tool_use honors
+ *                                          `decision: "deny"` to short-circuit
+ *                                          the call (executor.ts:131).
  *   - on_tool_start / on_tool_end          (executor.ts)
  *   - file_changed                         (executor.ts, Write/Edit only)
+ *   - on_permission_check                  (executor.ts) — fires after the
+ *                                          classifier runs and before its
+ *                                          decision is acted on. Handler can
+ *                                          override via `decision`; the
+ *                                          override is logged as
+ *                                          `permission.hook_override`. ctx.data
+ *                                          carries `classifierDecision` so
+ *                                          handlers can branch on the rule
+ *                                          set's verdict.
+ *   - post_compact                         (turn-loop.ts) — fires after
+ *                                          ContextManager.manageAsync() runs
+ *                                          a non-micro compaction. Handlers
+ *                                          may return `messages` to inject a
+ *                                          <system-reminder> into the same
+ *                                          turn before the model call. ctx.data
+ *                                          carries `strategy` (summary/snip/
+ *                                          window/emergency), `beforeTokens`,
+ *                                          `afterTokens`. Microcompact is
+ *                                          intentionally suppressed.
+ *   - notification                         (agent.ts) — fired when a background
+ *                                          sub-agent transitions to a terminal
+ *                                          state. ctx.data carries `kind`
+ *                                          ("agent_completed" / "agent_failed" /
+ *                                          "agent_cancelled"), `agentId`,
+ *                                          `name`, `description`, plus
+ *                                          `finalText` (completed) or `error`
+ *                                          (failed). Fired void — handler
+ *                                          latency does not block the main
+ *                                          loop. Not consumed by the engine
+ *                                          (bg-agent feed renders the same
+ *                                          info via notificationQueue);
+ *                                          intended for shell hooks (osascript
+ *                                          / desktop notifications).
+ *
+ * All Engine-side emits run through Engine.emitHook / TurnLoop.emitHook, which
+ * auto-merge `isSubAgent` (and sessionId, for turn-loop) into ctx.data so
+ * handlers can skip noisy injections for spawned children.
  *
  * **Reserved / not-yet-emitted** (defined so downstream can register handlers
  * in anticipation; wire the emitter before relying on them):
- *   - on_permission_check / on_session_start / on_session_end
- *   - user_prompt_submit / pre_compact / post_compact / notification
+ *   - pre_compact   — would require pre-flight prediction inside
+ *                     ContextManager; current implementation only knows
+ *                     after-the-fact (use post_compact instead).
  */
 export type HookEventName = "on_agent_start" | "on_agent_end" | "on_turn_start" | "on_turn_end" | "on_tool_start" | "on_tool_end" | "on_permission_check" | "on_session_start" | "on_session_end" | "pre_tool_use" | "post_tool_use" | "user_prompt_submit" | "pre_compact" | "post_compact" | "file_changed" | "notification";
 export interface HookContext {
@@ -32,4 +88,27 @@ export interface HookResult {
     messages?: string[];
     /** Allow/deny/ask override for permission hooks */
     decision?: "allow" | "deny" | "ask";
+    /**
+     * For pre_tool_use: replace the tool's args before execution. Used by
+     * "sanitizer" handlers (e.g. redact secrets in Bash commands, normalize
+     * file paths, inject a default flag). Last handler in the chain wins.
+     * Args are re-validated against the tool's input schema before the
+     * tool runs, so a malformed updatedInput still surfaces as an
+     * "Invalid input" error rather than silently passing through.
+     */
+    updatedInput?: Record<string, unknown>;
+    /**
+     * For post_tool_use: text appended to the tool's content (visible to
+     * the model on the next LLM call). Used by linter/typecheck handlers
+     * to surface results without re-running the tool. Multiple handlers'
+     * additionalContext entries are joined with two newlines.
+     */
+    additionalContext?: string;
+    /**
+     * For user_prompt_submit: replace the most recent user message text
+     * with this string. Last handler wins. Used to auto-prepend project
+     * context, mask secrets, or rewrite shorthand prompts. The original
+     * prompt is logged at info level for audit purposes.
+     */
+    updatedPrompt?: string;
 }

package/dist/hooks/inject.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hook message injection helper.
+ *
+ * Handlers return raw markdown strings via HookResult.messages. The emit
+ * site uses wrapHookMessages() to package them into a single user-role
+ * <system-reminder> Message so the model sees them as one block instead
+ * of a noisy sequence of separate user turns.
+ *
+ * Contract:
+ *   - Handlers do NOT wrap their own <system-reminder>; emit-site owns the
+ *     wrapper. Keeps formatting consistent and lets us evolve it (e.g. add
+ *     a trailing close-tag, tag attributes) without touching every handler.
+ *   - Empty / whitespace-only messages are dropped before wrapping; if
+ *     nothing remains, returns null (caller skips the injection).
+ *   - Multiple handlers' messages are joined with a blank line between
+ *     blocks so each is visually distinct inside the reminder.
+ */
+import type { Message } from "../types.js";
+export declare function wrapHookMessages(messages: string[] | undefined): Message | null;

package/dist/hooks/shell-runner.d.ts

@@ -0,0 +1,45 @@
+/**
+ * shell-runner — execute a user-configured shell command as a hook handler.
+ *
+ * Protocol (matches Claude Code's shell-hook contract):
+ *
+ *   stdin       JSON.stringify({ eventName, data }) — the full HookContext
+ *               envelope, including ctx.data fields like toolName / args /
+ *               sessionId / isSubAgent.
+ *
+ *   stdout      Either ignored (when exit 0 with no/blank output) or parsed
+ *               as a HookResult JSON document. Unparseable stdout on exit 0
+ *               is logged at warn level and dropped — we do NOT crash the
+ *               turn loop on malformed handler output.
+ *
+ *   exit  0     Normal return. Stdout (if any) becomes the HookResult.
+ *   exit  2     Deny / block. Stderr becomes the human-readable reason and
+ *               is surfaced to the model via HookResult.messages so the LLM
+ *               sees why the action was rejected.
+ *   exit  *     Any other non-zero code = handler error. Logged at error
+ *               level; we return {} (no effect) so a buggy hook never wedges
+ *               the engine.
+ *
+ *   ENV (passed to child):
+ *               CODESHELL_HOOK_EVENT   — event name, also in stdin
+ *               CODESHELL_HOOK_CWD     — repo root for context-aware hooks
+ *               (callers may add more by reading process.env directly)
+ *
+ *   timeout     Defaults to 60_000 ms; settings.timeout_ms overrides.
+ *               On timeout we SIGTERM then SIGKILL, log, and return {}.
+ */
+import type { HookContext, HookResult } from "./events.js";
+import type { SettingsHookConfig } from "../types.js";
+/**
+ * Run one shell-hook command and return the parsed HookResult. Catches
+ * every failure mode (spawn error, timeout, malformed JSON) and
+ * returns an empty result so the registry's chain keeps going.
+ */
+export declare function runShellHook(config: SettingsHookConfig, ctx: HookContext): Promise<HookResult>;
+/**
+ * Check whether the hook should fire for the current ctx, respecting
+ * the optional `matcher` regex. Returns false for non-tool events
+ * when matcher is set (matcher only makes sense when ctx.data has a
+ * toolName field).
+ */
+export declare function shellHookMatches(config: SettingsHookConfig, ctx: HookContext): boolean;

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export declare const VERSION = "0.1.7";
+export declare const VERSION = "0.2.0";
 export type { Message, ContentBlock, ToolDefinition, ToolCall, ToolResult, RegisteredTool, TranscriptEvent, TranscriptEventType, SessionState, TokenUsage, CompiledInput, PermissionDecision, PermissionMode, PermissionRule, TurnPhase, TurnResult, TerminalReason, StreamEvent, StreamCallback, LLMConfig, LLMResponse, Settings, MCPServerConfig, } from "./types.js";
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, } from "./exceptions.js";
 export { Engine } from "./engine/engine.js";
@@ -25,6 +25,7 @@ export { taskManager } from "./tool-system/builtin/task.js";
 export type { Task, TaskStatus } from "./tool-system/builtin/task.js";
 export { HookRegistry } from "./hooks/registry.js";
 export type { HookEventName, HookContext, HookResult } from "./hooks/events.js";
+export { wrapHookMessages } from "./hooks/inject.js";
 export { Transcript } from "./session/transcript.js";
 export { SessionManager } from "./session/session-manager.js";
 export { FileHistory } from "./session/file-history.js";
@@ -43,8 +44,8 @@ export type { MicrocompactOptions } from "./context/compaction.js";
 export type { SummarizeFn, CompactStrategy, OnCompactFn, ContextManagerConfig, } from "./context/manager.js";
 export { applyToolResultPersistence, createContentReplacementState, reconstructContentReplacementState, resolveToolResultsDir, isPersistedReplacement, DEFAULT_PERSIST_THRESHOLD, PER_MESSAGE_AGGREGATE_CAP, PREVIEW_SIZE, } from "./context/tool-result-storage.js";
 export type { ContentReplacementState } from "./context/tool-result-storage.js";
-export { scanSkills, matchSkillsByInput, matchSkillsByTool, buildSkillListing } from "./skills/index.js";
-export type { SkillDefinition, MatchResult } from "./skills/index.js";
+export { scanSkills, invalidateSkillCache } from "./skills/index.js";
+export type { SkillDefinition } from "./skills/index.js";
 export { Arena } from "./arena/arena.js";
 export { MODEL_PRESETS, getMaxOutputTokens } from "./arena/model-presets.js";
 export type { ModelPreset } from "./arena/model-presets.js";

package/dist/index.js

@@ -1 +1 @@
-export{a as defineProduct}from'./chunk-KCXSARAA.js';export{a as createRunManager}from'./chunk-RP26WO4R.js';export{_ as ArtifactTracker,i as AutoApprovalBackend,I as BUILTIN_AGENT_PRESETS,e as BUILTIN_TOOLS,Z as CheckpointWriter,ca as CompositeEvaluator,w as ContextManager,J as DEFAULT_AGENT_PRESET,K as DEFAULT_CLI_PRESET,o as DEFAULT_PERSIST_THRESHOLD,T as Engine,da as EngineRunner,V as FileRunStore,h as HeadlessApprovalBackend,aa as Heartbeat,n as HookRegistry,ba as NoopEvaluator,p as PER_MESSAGE_AGGREGATE_CAP,q as PREVIEW_SIZE,m as PermissionClassifier,Q as PromptComposer,X as RunApprovalBackend,$ as RunLock,ea as RunManager,W as RunQueue,x as SectionCache,g as ToolExecutor,f as ToolRegistry,U as VALID_TRANSITIONS,u as applyToolResultPersistence,H as availableSections,O as buildPresetSystemPrompt,D as buildSkillListing,z as combineInstructions,r as createContentReplacementState,Y as createRunAskUserFn,v as isPersistedReplacement,M as listPresetNames,F as loadSection,G as loadSections,B as matchSkillsByInput,C as matchSkillsByTool,s as reconstructContentReplacementState,L as registerPreset,E as registerSection,N as resolveAgentPreset,P as resolveBuiltinToolNames,t as resolveToolResultsDir,y as scanInstructions,A as scanSkills,c as taskManager}from'./chunk-NMBYBGC7.js';export{a as ModelPool}from'./chunk-2NS3JMNK.js';export{a as FileHistory}from'./chunk-WI6FSWGU.js';import'./chunk-P6JSTIFM.js';import'./chunk-SNFAPSLA.js';export{a as MCPManager}from'./chunk-XDOWC7EG.js';import {o}from'./chunk-W47Z7MGS.js';export{e as COMPACTABLE_TOOL_NAMES,j as applySummaryCompaction,i as buildSummarizationPrompt,a as estimateTokens,f as microcompact,h as truncateToolResult,d as windowCompact}from'./chunk-W47Z7MGS.js';export{b as MemoryManager}from'./chunk-T222K6IV.js';export{b as SessionManager,a as Transcript}from'./chunk-QTWU7UNA.js';export{c as SettingsManager,a as SettingsSchema,b as validateSettings}from'./chunk-UDPUTFQT.js';export{j as IterativeArena,f as defaultIterateConvergence,i as getIterateFormat,g as iterateCodeFormat,e as iterateDiffRatio,h as iterateDocumentFormat}from'./chunk-Q4O2HGWS.js';export{J as Arena,I as ArenaLedger,e as DiscussionStrategy,Q as MODEL_PRESETS,f as PlanningStrategy,d as ReviewStrategy,z as applyReviewResult,u as buildDigest,n as collectEvidence,b as createLLMClient,v as formatDigest,R as getMaxOutputTokens,k as getStrategy,l as getStrategyForPlan,p as hasTools,B as isTerminal,y as markUnderReview,A as markUnresolved,m as planArena,s as registerClaims,a as registerProvider,x as resolveClaimStatus,t as selectClaimsForReview,o as selectTools,w as transitionClaim,C as validTransitions}from'./chunk-Y2NS6HPO.js';import'./chunk-NVAZJ5XS.js';export{a as AnthropicClient}from'./chunk-WOP6MJKW.js';export{a as OpenAIClient}from'./chunk-PGANL6F2.js';import'./chunk-O5HFCH2U.js';export{a as LLMClientBase}from'./chunk-HIJ2XXGX.js';export{l as ConfigError,d as ContextLimitError,a as FrameworkError,b as LLMError,c as LLMRateLimitError,i as PermissionDeniedError,j as SessionError,e as ToolError,g as ToolExecutionError,f as ToolNotFoundError,h as ToolTimeoutError,k as TranscriptError}from'./chunk-FU7AHZNN.js';export{b as logger}from'./chunk-B7K2OWKC.js';import {h,a}from'./chunk-3QP5BQ3L.js';h();o();h();var vt={review:[{patterns:[/\breview\b/i,/\baudit\b/i,/\binspect\b/i,/\bcheck\b/i],weight:2},{patterns:[/\bcode\s*quality\b/i,/\bbug\b/i,/\bvulnerab/i,/\bsecur/i]},{patterns:[/\bpr\b/i,/\bpull\s*request\b/i,/\bdiff\b/i,/\bchanges?\b/i]},{patterns:[/\brefactor/i,/\bclean\s*up\b/i,/\bimprove\b/i]}],discussion:[{patterns:[/\bdiscuss\b/i,/\bdebate\b/i,/\bcompare\b/i],weight:2},{patterns:[/\bpros?\s*(and|&|\/)\s*cons?\b/i,/\btrade\s*-?\s*offs?\b/i]},{patterns:[/\bshould\s+we\b/i,/\bwhich\s+(is|approach|way)\b/i,/\bvs\.?\b/i]},{patterns:[/\bopinion\b/i,/\bthoughts?\b/i,/\badvice\b/i]}],planning:[{patterns:[/\bplan\b/i,/\bplanning\b/i,/\broadmap\b/i,/\bstrategy\b/i],weight:2},{patterns:[/\barchitect/i,/\bdesign\b/i,/\bproposal\b/i]},{patterns:[/\bimplement(ation)?\s+(plan|strategy|approach)\b/i],weight:2},{patterns:[/\bphase\b/i,/\bmilestone\b/i,/\btimeline\b/i,/\bprioritiz/i]},{patterns:[/\bbuild\b/i,/\bcreate\b/i,/\bsetup\b/i,/\bbootstrap\b/i]}]},kt=3,Mt=2;function Pt(m){let a={review:0,discussion:0,planning:0};for(let[n,i]of Object.entries(vt))for(let p of i){let u=p.weight??1;for(let d of p.patterns)d.test(m)&&(a[n]+=u);}let s=Object.entries(a).sort((n,i)=>i[1]-n[1]),[t,e]=s[0],[,l]=s[1],r=e-l;return e>=kt&&r>=Mt?{mode:t,confidence:"high",reason:`Topic strongly matches "${t}" (score: ${e}, lead: +${r})`}:e>0&&r>0?{mode:t,confidence:"low",reason:`Topic weakly matches "${t}" (score: ${e}, lead: +${r})`}:{mode:"review",confidence:"low",reason:"No strong mode signal detected, defaulting to review"}}a(Pt,"detectArenaMode");var wt="0.1.7";export{wt as VERSION,Pt as detectArenaMode};
+export{a as defineProduct}from'./chunk-GGVAOPI7.js';export{a as createRunManager}from'./chunk-5QIVXFCT.js';export{Y as ArtifactTracker,k as AutoApprovalBackend,F as BUILTIN_AGENT_PRESETS,f as BUILTIN_TOOLS,X as CheckpointWriter,aa as CompositeEvaluator,x as ContextManager,G as DEFAULT_AGENT_PRESET,H as DEFAULT_CLI_PRESET,p as DEFAULT_PERSIST_THRESHOLD,R as Engine,fa as EngineRunner,T as FileRunStore,j as HeadlessApprovalBackend,_ as Heartbeat,n as HookRegistry,$ as NoopEvaluator,q as PER_MESSAGE_AGGREGATE_CAP,r as PREVIEW_SIZE,m as PermissionClassifier,N as PromptComposer,V as RunApprovalBackend,Z as RunLock,ga as RunManager,U as RunQueue,y as SectionCache,i as ToolExecutor,g as ToolRegistry,S as VALID_TRANSITIONS,v as applyToolResultPersistence,E as availableSections,L as buildPresetSystemPrompt,A as combineInstructions,s as createContentReplacementState,W as createRunAskUserFn,w as isPersistedReplacement,J as listPresetNames,C as loadSection,D as loadSections,t as reconstructContentReplacementState,I as registerPreset,B as registerSection,K as resolveAgentPreset,M as resolveBuiltinToolNames,u as resolveToolResultsDir,z as scanInstructions,e as taskManager,o as wrapHookMessages}from'./chunk-Z5HKHAO7.js';export{i as invalidateSkillCache,h as scanSkills}from'./chunk-SKIX2M5Z.js';export{a as ModelPool}from'./chunk-MLCTC53I.js';export{a as FileHistory}from'./chunk-WI6FSWGU.js';import'./chunk-P6JSTIFM.js';import'./chunk-SNFAPSLA.js';export{a as MCPManager}from'./chunk-D3TVASD2.js';export{c as SettingsManager,a as SettingsSchema,b as validateSettings}from'./chunk-FZXY554D.js';import {p}from'./chunk-M7VU4YVY.js';export{e as COMPACTABLE_TOOL_NAMES,k as applySummaryCompaction,i as buildSummarizationPrompt,a as estimateTokens,f as microcompact,h as truncateToolResult,d as windowCompact}from'./chunk-M7VU4YVY.js';export{b as MemoryManager}from'./chunk-T222K6IV.js';export{b as SessionManager,a as Transcript}from'./chunk-QTWU7UNA.js';export{j as IterativeArena,f as defaultIterateConvergence,i as getIterateFormat,g as iterateCodeFormat,e as iterateDiffRatio,h as iterateDocumentFormat}from'./chunk-K4HILJ6G.js';export{J as Arena,I as ArenaLedger,e as DiscussionStrategy,S as MODEL_PRESETS,f as PlanningStrategy,d as ReviewStrategy,z as applyReviewResult,u as buildDigest,n as collectEvidence,b as createLLMClient,v as formatDigest,T as getMaxOutputTokens,k as getStrategy,l as getStrategyForPlan,p as hasTools,B as isTerminal,y as markUnderReview,A as markUnresolved,m as planArena,s as registerClaims,a as registerProvider,x as resolveClaimStatus,t as selectClaimsForReview,o as selectTools,w as transitionClaim,C as validTransitions}from'./chunk-WONQHE4P.js';import'./chunk-GKAQH2DG.js';export{a as AnthropicClient}from'./chunk-X2S7ASQ2.js';export{b as OpenAIClient}from'./chunk-SV7H4FKT.js';import'./chunk-O5HFCH2U.js';export{a as LLMClientBase}from'./chunk-OWBYLMDD.js';export{l as ConfigError,d as ContextLimitError,a as FrameworkError,b as LLMError,c as LLMRateLimitError,i as PermissionDeniedError,j as SessionError,e as ToolError,g as ToolExecutionError,f as ToolNotFoundError,h as ToolTimeoutError,k as TranscriptError}from'./chunk-FU7AHZNN.js';export{d as logger}from'./chunk-DI26OUIU.js';import {h,a}from'./chunk-3QP5BQ3L.js';h();p();h();var vt={review:[{patterns:[/\breview\b/i,/\baudit\b/i,/\binspect\b/i,/\bcheck\b/i],weight:2},{patterns:[/\bcode\s*quality\b/i,/\bbug\b/i,/\bvulnerab/i,/\bsecur/i]},{patterns:[/\bpr\b/i,/\bpull\s*request\b/i,/\bdiff\b/i,/\bchanges?\b/i]},{patterns:[/\brefactor/i,/\bclean\s*up\b/i,/\bimprove\b/i]}],discussion:[{patterns:[/\bdiscuss\b/i,/\bdebate\b/i,/\bcompare\b/i],weight:2},{patterns:[/\bpros?\s*(and|&|\/)\s*cons?\b/i,/\btrade\s*-?\s*offs?\b/i]},{patterns:[/\bshould\s+we\b/i,/\bwhich\s+(is|approach|way)\b/i,/\bvs\.?\b/i]},{patterns:[/\bopinion\b/i,/\bthoughts?\b/i,/\badvice\b/i]}],planning:[{patterns:[/\bplan\b/i,/\bplanning\b/i,/\broadmap\b/i,/\bstrategy\b/i],weight:2},{patterns:[/\barchitect/i,/\bdesign\b/i,/\bproposal\b/i]},{patterns:[/\bimplement(ation)?\s+(plan|strategy|approach)\b/i],weight:2},{patterns:[/\bphase\b/i,/\bmilestone\b/i,/\btimeline\b/i,/\bprioritiz/i]},{patterns:[/\bbuild\b/i,/\bcreate\b/i,/\bsetup\b/i,/\bbootstrap\b/i]}]},ht=3,Mt=2;function Pt(m){let a={review:0,discussion:0,planning:0};for(let[n,i]of Object.entries(vt))for(let p of i){let u=p.weight??1;for(let d of p.patterns)d.test(m)&&(a[n]+=u);}let s=Object.entries(a).sort((n,i)=>i[1]-n[1]),[t,e]=s[0],[,l]=s[1],r=e-l;return e>=ht&&r>=Mt?{mode:t,confidence:"high",reason:`Topic strongly matches "${t}" (score: ${e}, lead: +${r})`}:e>0&&r>0?{mode:t,confidence:"low",reason:`Topic weakly matches "${t}" (score: ${e}, lead: +${r})`}:{mode:"review",confidence:"low",reason:"No strong mode signal detected, defaulting to review"}}a(Pt,"detectArenaMode");var Dt="0.2.0";export{Dt as VERSION,Pt as detectArenaMode};

package/dist/llm/api-key-sanitize.d.ts

@@ -0,0 +1,22 @@
+/**
+ * sanitizeApiKey — defensive cleanup for API keys pasted via the wizard.
+ *
+ * Windows terminals (ConPTY, legacy cmd.exe, IME-active states) are the main
+ * source of breakage: bracketed-paste residue, CR endings, zero-width chars
+ * pulled in from rich-text sources (Notion / OneNote / web pages), full-width
+ * spaces from CJK IME, smart quotes from word processors. None of these are
+ * valid in any real provider's API key, so we strip them and warn.
+ */
+export type SanitizeResult = {
+    value: string;
+    changed: boolean;
+    warnings: string[];
+};
+export declare function sanitizeApiKey(raw: string): SanitizeResult;
+/**
+ * Returns true when the sanitized key contains any non-ASCII-printable
+ * character. Real provider keys are uniformly ASCII (`[A-Za-z0-9_\-.]`-ish),
+ * so a stray non-ASCII char almost certainly means the user pasted the wrong
+ * thing (e.g. the surrounding sentence in Chinese).
+ */
+export declare function hasNonAsciiPrintable(s: string): boolean;

package/dist/llm/capabilities/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Capability layer — single entry point.
+ *
+ * `capabilitiesFor(kind, model)` walks the rules in `rules.ts`, returns
+ * a `Capability` describing what params the (provider, model) pair will
+ * accept. Clients spread the result into their request-build code.
+ *
+ * Pure function. No I/O, no caching beyond the rules array.
+ */
+import type { ProviderKindName } from "../provider-kinds.js";
+import { type Capability } from "./types.js";
+export { DEFAULT_CAPABILITY } from "./types.js";
+export type { Capability, ReasoningShape, ReasoningEffort, ThinkingSwitch, EchoReasoning, ParallelToolCallsShape, StreamUsageShape, } from "./types.js";
+/**
+ * Resolve the capability for a given (provider kind, model id).
+ *
+ * First matching rule for the kind wins — rules.ts is ordered so that
+ * more specific patterns come before catch-alls.
+ */
+export declare function capabilitiesFor(kind: ProviderKindName, model: string): Capability;

package/dist/llm/capabilities/rules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-(provider kind, model family) capability overrides.
+ *
+ * Each rule patches the conservative DEFAULT_CAPABILITY. First match per
+ * kind wins — order matters for overlapping families.
+ *
+ * Authority for every entry is the vendor's own docs; the `why` field
+ * cites the specific page. When a model 400s on something not captured
+ * here, add a rule, don't patch the client.
+ *
+ * Sources audited 2026-05-15:
+ *   OpenAI:    https://platform.openai.com/docs/guides/reasoning
+ *              https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/reasoning
+ *   Anthropic: https://platform.claude.com/docs/en/build-with-claude/extended-thinking
+ *   DeepSeek:  https://api-docs.deepseek.com/guides/reasoning_model
+ *              https://api-docs.deepseek.com/guides/thinking_mode
+ *   Z.AI:      https://docs.z.ai/guides/llm/glm-4.6
+ *   Gemini:    https://ai.google.dev/gemini-api/docs/openai
+ *              https://ai.google.dev/gemini-api/docs/thinking
+ *   OpenRouter: https://openrouter.ai/docs/guides/best-practices/reasoning-tokens
+ *   xAI:       https://docs.x.ai/docs/guides/reasoning
+ *   Mistral:   https://docs.mistral.ai/api/
+ *   Groq:      https://console.groq.com/docs/reasoning
+ */
+import type { CapabilityRule } from "./types.js";
+export declare const RULES: ReadonlyArray<CapabilityRule>;

package/dist/llm/capabilities/types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Per-(provider, model) capability descriptor.
+ *
+ * Captures the subset of request-shape divergence we've actually observed
+ * cause HTTP 400s or behavior changes. Each rule in `rules.ts` produces
+ * one of these; clients spread it into the outgoing request.
+ *
+ * Sources for every field are documented next to the matching rule in
+ * `rules.ts` — vendor docs, not folklore.
+ */
+import type { ProviderKindName } from "../provider-kinds.js";
+/** OpenAI-style reasoning effort levels — shared by several vendors. */
+export type ReasoningEffort = "minimal" | "low" | "medium" | "high";
+/** A binary thinking switch, like DeepSeek V4 and Z.AI GLM use. */
+export type ThinkingSwitch = "enabled" | "disabled";
+/**
+ * How the vendor exposes a "think harder / think less" knob (or none).
+ * Each kind has different field names and value shapes — we keep them
+ * separate so the engine can't accidentally cross-pollinate.
+ */
+export type ReasoningShape = {
+    kind: "none";
+}
+/** DeepSeek V4, Z.AI GLM-4.5+ — `{thinking: {type: "enabled"|"disabled"}}` at top level. */
+ | {
+    kind: "deepseek-thinking";
+}
+/**
+ * OpenAI o-series & gpt-5+ — `reasoning_effort: "minimal"|"low"|"medium"|"high"`.
+ * `disabledEffort` is the value we send when the caller asks for thinking
+ * "disabled" — defaults to `"minimal"` (OpenAI), but vendors with a
+ * narrower vocabulary override it (e.g. xAI Grok 4.3 has no `"minimal"`;
+ * Mistral Magistral only accepts `"high"` and `"none"`).
+ */
+ | {
+    kind: "openai-effort";
+    disabledEffort?: ReasoningEffort | "none";
+}
+/** Anthropic Claude 4.x ≤ 4.5 — `{thinking: {type: "enabled", budget_tokens: N}}`. */
+ | {
+    kind: "anthropic-budget";
+    minBudgetTokens: number;
+}
+/** Anthropic Claude 4.6+ — no opt-in, thinking is adaptive. Sending `type: "enabled"` 400s. */
+ | {
+    kind: "anthropic-adaptive";
+}
+/** OpenRouter normalized — `{reasoning: {effort, max_tokens, exclude, enabled}}`. */
+ | {
+    kind: "openrouter-reasoning";
+};
+/**
+ * How prior `reasoning_content` (or `thinking` blocks) must be threaded
+ * back into the next request.
+ */
+export type EchoReasoning = 
+/** DeepSeek `deepseek-reasoner`: 400 if you echo it back at all. */
+"never"
+/** DeepSeek V4 + tools, Claude 4.x + tools: must echo or 400. */
+ | "when-tools"
+/** Optional — echo if you have it, but absence is fine. */
+ | "optional";
+/**
+ * Parallel-tool-call shape. OpenAI exposes `parallel_tool_calls: bool`.
+ * Anthropic exposes it inside `tool_choice.disable_parallel_tool_use`.
+ * Some endpoints don't support it at all.
+ */
+export type ParallelToolCallsShape = "openai-flag" | "anthropic-disable-flag" | "unsupported";
+/**
+ * Streaming usage signal. OpenAI-compat needs `stream_options:
+ * {include_usage: true}`; Anthropic always emits usage in
+ * `message_delta`; some endpoints reject the field.
+ */
+export type StreamUsageShape = "include-usage-flag" | "auto" | "none";
+export interface Capability {
+    /** Token-limit request field. */
+    tokenLimitField: "max_tokens" | "max_completion_tokens";
+    /**
+     * Request fields the model 400s on (or silently drops). We just don't
+     * send them. Names are in OpenAI-compat spelling; clients translate
+     * for native protocols.
+     */
+    rejectedParams: ReadonlySet<"temperature" | "top_p" | "presence_penalty" | "frequency_penalty" | "logit_bias" | "logprobs" | "top_logprobs">;
+    /** How thinking is exposed (or not). */
+    reasoning: ReasoningShape;
+    /** Echo-back contract for prior reasoning. */
+    echoReasoning: EchoReasoning;
+    /** Parallel-tool-calls flag shape. */
+    parallelToolCalls: ParallelToolCallsShape;
+    /** Streaming usage reporting shape. */
+    streamUsage: StreamUsageShape;
+}
+/**
+ * Conservative default — used when no rule matches. Picks "send everything
+ * the vanilla OpenAI Chat Completions spec accepts," because that's what
+ * every OpenAI-compat endpoint at minimum understands.
+ */
+export declare const DEFAULT_CAPABILITY: Capability;
+export interface CapabilityRule {
+    /** Which provider kind this rule applies to. */
+    kind: ProviderKindName;
+    /** Model-id matcher. First matching rule wins (per kind). */
+    match: RegExp;
+    /** Patch applied on top of DEFAULT_CAPABILITY. */
+    capability: Partial<Capability>;
+    /** Free-text reason — shown in logs, helps future-you. */
+    why: string;
+}

package/dist/llm/model-pool.d.ts

@@ -29,6 +29,13 @@ export interface ModelEntry {
     /** Optional reference into ProviderCatalog. When set, baseUrl/apiKey
      *  come from the catalog unless the entry overrides them. */
     providerKey?: string;
+    /**
+     * Per-model thinking override. Wins over the provider-level setting
+     * (ProviderCatalog entry's `thinking`). Useful when models in the same
+     * provider need different defaults — e.g. DeepSeek V4 Pro off but
+     * V4 Flash on.
+     */
+    thinking?: "enabled" | "disabled";
 }
 export declare class ModelPool {
     private models;

package/dist/llm/provider-catalog.d.ts

@@ -13,6 +13,8 @@ export interface ProviderConfig {
     apiKey?: string;
     protocol?: "openai-compat" | "anthropic-style";
     modelsPath?: string;
+    /** Default DeepSeek V4 thinking-mode for this provider. See LLMConfig. */
+    thinking?: "enabled" | "disabled";
 }
 export declare class ProviderCatalog {
     private byKey;