@cjhyy/code-shell 0.1.0-alpha.3 → 0.1.6

package/dist/cli/migrate-models.d.ts

@@ -0,0 +1,45 @@
+/**
+ * One-shot migration of legacy flat models[] into providers[] + models[].
+ *
+ * Pure function — takes a snapshot, returns the new snapshot plus a flag.
+ * The caller (settings load path) is responsible for writing settings.json
+ * and the .bak backup.
+ */
+import type { ProviderConfig } from "../llm/provider-catalog.js";
+interface LegacyModel {
+    key: string;
+    label?: string;
+    provider?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    model: string;
+    maxOutputTokens?: number;
+    maxContextTokens?: number;
+    providerKey?: string;
+}
+export interface MigrationInput {
+    providers: ProviderConfig[];
+    models: LegacyModel[];
+}
+export interface MigrationOutput {
+    providers: ProviderConfig[];
+    models: Array<{
+        key: string;
+        label?: string;
+        providerKey: string;
+        model: string;
+        /**
+         * Self-describing legacy fields. Kept (rather than stripped) so model
+         * entries stay valid standalone — the engine can read credentials
+         * straight off the entry without a ProviderCatalog round-trip.
+         */
+        provider?: string;
+        baseUrl?: string;
+        apiKey?: string;
+        maxOutputTokens?: number;
+        maxContextTokens?: number;
+    }>;
+    changed: boolean;
+}
+export declare function migrateModels(input: MigrationInput): MigrationOutput;
+export {};

package/dist/cli/onboarding.d.ts

@@ -5,6 +5,13 @@
  * pure(-ish) helpers it consumes, so there's a single input stack.
  */
 export interface OnboardingResult {
+    /**
+     * Pool alias key (e.g. "deepseek-v4-pro"). The engine uses this to switch
+     * the active model — callers should NOT re-derive an alias from `model`
+     * (the old modelKey() helper folded multiple model ids to one key, which
+     * silently shadowed entries in the pool).
+     */
+    key: string;
     provider: string;
     model: string;
     apiKey: string;
@@ -42,7 +49,37 @@ export interface DetectedEnvKey {
 export declare function detectEnvKeys(): DetectedEnvKey[];
 /** Mask a key for display: "sk-517f...b594" */
 export declare function maskKey(key: string): string;
+/**
+ * Find a provider definition that matches a given API key.
+ * Checks key prefix first, then env var match, then baseUrl.
+ */
+export declare function detectProviderFromApiKey(apiKey: string, baseUrl?: string): ProviderDef | undefined;
 export declare function validateApiKey(baseUrl: string, apiKey: string): Promise<boolean>;
+/**
+ * Resolve an API key from the canonical fallback chain.
+ * Priority: 1) command-line option  2) settings.json  3) all provider env vars
+ */
+export declare function resolveApiKey(optionsApiKey?: string, settingsApiKey?: string): string | undefined;
+/**
+ * Look up a previously-persisted API key for a given provider in
+ * ~/.code-shell/settings.json. Matches by baseUrl (each ProviderDef.baseUrl
+ * is unique, while `provider` is a generic kind like "openai" shared across
+ * multiple endpoints).
+ *
+ * Returns the first match found in: settings.models[] (preferred — newer),
+ * then settings.model (legacy top-level). undefined when nothing matches.
+ */
+export declare function findSavedKeyForProvider(provider: ProviderDef): {
+    apiKey: string;
+    baseUrl: string;
+} | undefined;
+/**
+ * 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.
+ */
+export declare function loadSavedModelsForProvider(provider: ProviderDef): string[];
 export declare function hasApiKey(): boolean;
 /**
  * Resolve a model's max-output-token budget. Lookup order:
@@ -56,12 +93,29 @@ export declare function hasApiKey(): boolean;
  */
 export declare function resolveMaxOutput(model: string): number | undefined;
 /**
- * Derive a short key from a model path.
- * "anthropic/claude-opus-4.7" → "claude-opus"
- * "openai/gpt-5" → "gpt"
- * "deepseek/deepseek-chat" → "deepseek"
+ * Resolve a model's context window size. Lookup order:
+ *   1. KNOWN_CONTEXT_WINDOWS (covers direct providers like DeepSeek)
+ *   2. OpenRouter snapshot (covers `vendor/model` style IDs)
+ *   3. undefined — unknown
  */
-export declare function modelKey(model: string): string;
+export declare function resolveContextWindow(model: string): number | undefined;
+/**
+ * Derive a pool key in `provider-model` form. Single source of truth for
+ * model alias generation — replaces the old modelKey() function which
+ * folded same-family models to one key (e.g. v4-flash and v4-pro both
+ * collapsed to "deepseek"), causing the pool to silently shadow entries.
+ *
+ *   ("deepseek", "deepseek-v4-pro")  → "deepseek-v4-pro"
+ *   ("openai",   "openai/gpt-5")      → "openai-gpt-5"
+ *   ("anthropic","claude-opus-4-7")   → "anthropic-claude-opus-4-7"
+ *
+ * If the model id already starts with `<provider>-` (e.g. "deepseek-v4-pro"
+ * under provider "deepseek"), the prefix isn't duplicated.
+ *
+ * `used` is a set of already-taken keys; collisions are resolved with a
+ * `-2`, `-3`, ... suffix.
+ */
+export declare function deriveModelPoolKey(providerKind: string, modelId: string, used?: string[]): string;
 /**
  * Build model pool entries from a provider's model list.
  */
@@ -73,7 +127,58 @@ export declare function buildModelPool(provider: ProviderDef, apiKey: string): A
     baseUrl: string;
     apiKey: string;
     maxOutputTokens?: number;
+    maxContextTokens?: number;
 }>;
 export declare function modelDisplayName(model: string): string;
 export declare function saveSettings(result: OnboardingResult, providerDef?: ProviderDef, poolModels?: string[]): void;
+/**
+ * Append-only persistence for the new ProviderModelFlow-based onboarding.
+ *
+ * Writes the new shape:
+ *   - settings.activeKey      — primary source of truth for active model
+ *   - settings.models[]       — self-describing entries (key, provider,
+ *                                model, baseUrl, apiKey, maxOutput, maxContext)
+ *   - settings.providers[]    — credential source for the wizard
+ *   - settings.model.*        — legacy mirror of the active entry, kept in
+ *                                sync so legacy boot paths (cli/main.ts,
+ *                                repl.ts, run.ts) keep working without
+ *                                each having to learn about activeKey
+ *
+ * Append-only: never removes existing entries. To start over use /logout.
+ * Writes atomically via tmp+rename.
+ */
+export declare function appendOnboardingResult(opts: {
+    /** Alias key the engine should switch to after writing. Matches one of addedModels[].key. */
+    activeKey: string;
+    /** Active entry's fields, used to mirror into the legacy settings.model.* block. */
+    activeMirror: {
+        provider: string;
+        model: string;
+        apiKey: string;
+        baseUrl: string;
+    };
+    addedProvider?: {
+        key: string;
+        label?: string;
+        kind: string;
+        baseUrl: string;
+        apiKey?: string;
+        protocol?: string;
+        modelsPath?: string;
+    };
+    addedModels: Array<{
+        key: string;
+        label?: string;
+        providerKey?: string;
+        /** LLM client/protocol ("openai"/"anthropic"). New canonical name. */
+        protocol?: string;
+        /** Legacy mirror of `protocol`. Both are written so legacy readers keep working. */
+        provider?: string;
+        model: string;
+        baseUrl: string;
+        apiKey?: string;
+        maxContextTokens?: number;
+        maxOutputTokens?: number;
+    }>;
+}): void;
 export declare function saveArenaSettingsByKeys(keys: string[]): void;

package/dist/cli/updater.d.ts

@@ -1,10 +1,65 @@
 /**
- * Auto-update checker — non-blocking check for newer versions on npm.
+ * Auto-update — checks npm registry for newer versions; can optionally install
+ * the new version in the background after the current process exits.
+ *
+ * Flow:
+ *   1. `checkForUpdate()` runs at startup (non-blocking). Stores result in
+ *      module state for the UI to read via `getUpdateAvailable()`.
+ *   2. UI re-polls every 30 min via `pollForUpdate()`.
+ *   3. If the user has write permission on the npm global prefix, we register
+ *      `scheduleAutoInstallOnExit()` so that on process exit a detached
+ *      `npm i -g` spawns and survives the parent. Next startup picks up
+ *      the new version.
+ *   4. If the user has NO permission, UI shows the manual command instead.
+ *
+ * Concurrency: multiple `code-shell` processes can run at once. A file lock
+ * at `~/.code-shell/.update.lock` prevents both from launching `npm i -g`
+ * simultaneously (which corrupts the install).
+ *
+ * Headless safety: `checkForUpdate()` and `scheduleAutoInstallOnExit()` are
+ * only invoked from the Ink-based UpdateBanner component, never from the
+ * `run` / `arena` headless code paths. Keep it that way — wiring the updater
+ * into bare CLI commands would surprise CI users with background `npm i -g`
+ * on every short-lived `code-shell run …` invocation. If you need updater
+ * behavior in a new headless entry point, gate it on something explicit
+ * (e.g. `--auto-update` flag) rather than calling it unconditionally.
  */
+export interface UpdateInfo {
+    latestVersion: string;
+    /** True if `<npm prefix>` is writable by current user — can self-install. */
+    canAutoInstall: boolean;
+    /** Cached npm global prefix path (for diagnostics / manual command hint). */
+    npmPrefix: string | null;
+}
 /**
- * Check if a newer version is available (non-blocking).
- * Call this on startup and read the result later.
+ * Kick off an update check. Non-blocking: returns immediately, fills module
+ * state when network/npm respond. Safe to call multiple times (e.g. on a 30min
+ * timer).
  */
 export declare function checkForUpdate(packageName?: string): void;
-export declare function getUpdateAvailable(): string | undefined;
+/** Returns update info if a newer version was found, else undefined. */
+export declare function getUpdateAvailable(): UpdateInfo | undefined;
+/** Returns "why is auto-update off" — for /doctor-style diagnostics. */
+export declare function getAutoUpdateDisabledReason(): string | null;
+/**
+ * Install the on-exit hook so that the new version is installed AFTER the
+ * current process exits (avoids overwriting files the running process still
+ * has open). Idempotent — calling twice is a no-op.
+ */
+export declare function scheduleAutoInstallOnExit(): void;
 export declare function getCurrentVersion(): string;
+declare function getLockFilePath(): string;
+/**
+ * Try to acquire the update lock. Returns true on success.
+ * Uses `O_EXCL` (writeFile flag 'wx') for atomic create. Stale locks (mtime
+ * older than LOCK_TIMEOUT_MS) are taken over, re-verifying staleness right
+ * before unlink to close the TOCTOU race.
+ */
+declare function acquireLock(): Promise<boolean>;
+declare function releaseLock(): Promise<void>;
+export declare const __internal: {
+    acquireLock: typeof acquireLock;
+    releaseLock: typeof releaseLock;
+    getLockFilePath: typeof getLockFilePath;
+};
+export {};

package/dist/client-base-HTF236ZD.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk7EG3V4JYcjs = require('./chunk-7EG3V4JY.cjs');
+require('./chunk-2YW4FPFG.cjs');
+require('./chunk-IK4EWJBP.cjs');
+require('./chunk-KS3RYAYL.cjs');
+
+
+exports.LLMClientBase = _chunk7EG3V4JYcjs.LLMClientBase;

package/dist/client-base-QKRKCOWB.js

@@ -0,0 +1,9 @@
+import {
+  LLMClientBase
+} from "./chunk-6S4BJ65N.js";
+import "./chunk-SFXHZSRF.js";
+import "./chunk-BXCY2FSE.js";
+import "./chunk-MD32R22I.js";
+export {
+  LLMClientBase
+};

package/dist/{compaction-YNWCEF7B.js → compaction-6VU2T643.js}

@@ -1,4 +1,5 @@
 import {
+  COMPACTABLE_TOOL_NAMES,
   adjustIndexToPreserveAPIInvariants,
   applySummaryCompaction,
   applyToolResultBudget,
@@ -12,10 +13,11 @@ import {
   snipCompact,
   truncateToolResult,
   windowCompact
-} from "./chunk-5C5HIOML.js";
-import "./chunk-DI7RDLOS.js";
+} from "./chunk-7Y6S3OCX.js";
+import "./chunk-MD32R22I.js";
 init_compaction();
 export {
+  COMPACTABLE_TOOL_NAMES,
   adjustIndexToPreserveAPIInvariants,
   applySummaryCompaction,
   applyToolResultBudget,

package/dist/compaction-OKUNTCA7.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk6QVAYW7Ccjs = require('./chunk-6QVAYW7C.cjs');
+require('./chunk-KS3RYAYL.cjs');
+_chunk6QVAYW7Ccjs.init_compaction.call(void 0, );
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.COMPACTABLE_TOOL_NAMES = _chunk6QVAYW7Ccjs.COMPACTABLE_TOOL_NAMES; exports.adjustIndexToPreserveAPIInvariants = _chunk6QVAYW7Ccjs.adjustIndexToPreserveAPIInvariants; exports.applySummaryCompaction = _chunk6QVAYW7Ccjs.applySummaryCompaction; exports.applyToolResultBudget = _chunk6QVAYW7Ccjs.applyToolResultBudget; exports.buildSummarizationPrompt = _chunk6QVAYW7Ccjs.buildSummarizationPrompt; exports.dropOldestRounds = _chunk6QVAYW7Ccjs.dropOldestRounds; exports.estimateTokens = _chunk6QVAYW7Ccjs.estimateTokens; exports.extractReferencedFilePaths = _chunk6QVAYW7Ccjs.extractReferencedFilePaths; exports.groupMessagesByApiRound = _chunk6QVAYW7Ccjs.groupMessagesByApiRound; exports.microcompact = _chunk6QVAYW7Ccjs.microcompact; exports.snipCompact = _chunk6QVAYW7Ccjs.snipCompact; exports.truncateToolResult = _chunk6QVAYW7Ccjs.truncateToolResult; exports.windowCompact = _chunk6QVAYW7Ccjs.windowCompact;

package/dist/context/compaction.d.ts

@@ -36,12 +36,44 @@ export declare function snipCompact(messages: Message[], keepFirstN?: number, ke
  * Uses adjustIndexToPreserveAPIInvariants to avoid splitting tool pairs.
  */
 export declare function windowCompact(messages: Message[], keepLastN: number): Message[];
+/**
+ * Tools whose results are safe to clear during microcompact.
+ *
+ * Tracks the CC `COMPACTABLE_TOOLS` set: only "data-fetching" tools where the
+ * result is reconstructible (re-Read, re-Glob, re-Bash). Orchestration tools
+ * (TaskCreate / TaskUpdate / Agent / Skill / etc.) are excluded — their
+ * results carry conversation state the model needs to keep referencing.
+ */
+export declare const COMPACTABLE_TOOL_NAMES: ReadonlySet<string>;
+export interface MicrocompactOptions {
+    /** Keep this many most-recent compactable tool-result rounds untouched. */
+    keepRecentN?: number;
+    /** Tool names whose results may be cleared. Defaults to COMPACTABLE_TOOL_NAMES. */
+    compactableTools?: ReadonlySet<string>;
+    /** Optional callback invoked once when any clearing actually happened. */
+    onClear?: (info: {
+        clearedRounds: number;
+        toolNames: string[];
+    }) => void;
+}
 /**
  * Remove old tool_result content (microcompact).
- * Replaces tool_result content with "[Old tool result cleared]" for messages
- * older than keepRecentN tool rounds.
+ *
+ * For each tool_result block older than the most-recent N compactable rounds,
+ * replaces its content with a short fingerprint of the originating call
+ * (e.g. `[Old tool result cleared — Read file_path=/.../foo.ts]`) so the
+ * model can decide whether it's worth re-running the tool instead of
+ * guessing what it had seen.
+ *
+ * Behavior changes vs. earlier versions:
+ *  - Only clears whitelisted tool names (Read/Glob/Bash/...). Orchestration
+ *    tool results (TaskCreate/TaskUpdate/Agent/etc.) are left intact.
+ *  - "Round" count is per *compactable* result, not per message with any
+ *    tool_result. A round containing only TaskUpdate doesn't count toward N.
+ *  - Replacement string includes tool name + key args so the model isn't
+ *    forced into blind re-Reads (which then trip the Investigation guard).
  */
-export declare function microcompact(messages: Message[], keepRecentN?: number): Message[];
+export declare function microcompact(messages: Message[], options?: MicrocompactOptions): Message[];
 /**
  * Apply aggregate per-message tool result budget.
  * When total tool_result content in a single message exceeds maxTotalChars,

package/dist/context/manager.d.ts

@@ -11,13 +11,27 @@ export interface ContextManagerConfig {
     compactAtRatio: number;
     summarizeAtRatio: number;
     maxToolResultChars: number;
+    /**
+     * Lower bound, as a ratio of maxTokens, below which microcompact will not
+     * run. CC's external (non-cache-edit) path is "autocompact handles context
+     * pressure"; mirror that by leaving early-turn context alone so a model
+     * with a 1M window doesn't see its first-3-rounds Read results wiped at
+     * 23k tokens. Raising the floor also keeps prompt-cache prefixes warm in
+     * short sessions.
+     */
+    microcompactFloorRatio: number;
+    /**
+     * Most-recent compactable rounds microcompact keeps untouched. Auto-derived
+     * from maxTokens when not set explicitly: bigger window → keep more.
+     */
+    microcompactKeepRecent?: number;
 }
 /**
  * Async function type for LLM summarization calls.
  * Injected by the Engine so the ContextManager doesn't depend on LLM directly.
  */
 export type SummarizeFn = (prompt: string) => Promise<string>;
-export type CompactStrategy = "summary" | "window" | "snip" | "emergency";
+export type CompactStrategy = "micro" | "summary" | "window" | "snip" | "emergency";
 export type OnCompactFn = (info: {
     strategy: CompactStrategy;
     before: number;
@@ -35,8 +49,15 @@ export declare class ContextManager {
     private lastActualAtMessageCount;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     private transcriptPath;
-    /** Notified whenever a non-trivial compaction tier fires (skips microcompact). */
+    /** Notified whenever any compaction tier fires, including microcompact. */
     private onCompact;
+    /**
+     * Tool-result persistence state. Created lazily once we know where to
+     * write files (i.e. once setTranscriptPath has been called).
+     * `null` = persistence has been explicitly disabled.
+     */
+    private replacementState;
+    private toolResultsDir;
     constructor(config?: Partial<ContextManagerConfig>);
     setOnCompact(fn: OnCompactFn): void;
     /**
@@ -54,9 +75,19 @@ export declare class ContextManager {
      */
     setSummarizeFn(fn: SummarizeFn): void;
     /**
-     * Set the transcript path so compaction can reference it.
+     * Set the transcript path so compaction can reference it. The
+     * tool-results directory lives alongside the transcript file:
+     *   <transcriptDir>/tool-results/<toolUseId>.txt
      */
     setTranscriptPath(path: string): void;
+    /**
+     * Initialize tool-result-persistence state from already-loaded messages.
+     * Call this once per session, after setTranscriptPath, when resuming so
+     * the manager re-enters the same "frozen decision" state it had on the
+     * previous run. Without this, a resumed session would re-evaluate
+     * every result against the current threshold and might flip choices.
+     */
+    initReplacementStateFromMessages(messages: Message[]): void;
     /**
      * Apply progressive context management (sync path).
      * For Tier 2 (LLM summary), call manageAsync instead.
@@ -67,6 +98,12 @@ export declare class ContextManager {
      * Call this when you have access to the LLM (between turns).
      */
     manageAsync(messages: Message[]): Promise<Message[]>;
+    /**
+     * Persist large tool_result blocks to disk and replace them with a
+     * preview + filepath. No-op when transcript path hasn't been set
+     * (e.g. unit tests that exercise compaction directly without a session).
+     */
+    private persistLargeToolResults;
     /**
      * Truncate oversized tool results in messages.
      */

package/dist/context/tool-result-storage.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Tool-result persistence — write large tool_result content to disk and
+ * replace the in-context message with a reference + preview.
+ *
+ * Mirrors Claude Code's services/compact/microcompact.ts + utils/toolResultStorage.ts
+ * approach, simplified for codeshell:
+ *
+ *   • One file per tool_use_id (UUID), so the same id always maps to the
+ *     same file — guarantees byte-identical preview on every turn.
+ *   • Decision state (ContentReplacementState) is held by the caller and
+ *     mutated in place. Once a result is "seen", its fate is frozen for
+ *     the rest of the session (prevents flapping replacement choices that
+ *     would constantly invalidate the prompt prefix).
+ *   • No transcript persistence / no fork-subagent gap-fill. Resume just
+ *     re-derives the seenIds set from the loaded messages.
+ *
+ * Strategy:
+ *   • Per-result cap (DEFAULT_PERSIST_THRESHOLD): when a single tool_result
+ *     exceeds it, persist + replace.
+ *   • Per-message aggregate cap (PER_MESSAGE_AGGREGATE_CAP): when a single
+ *     user message's tool_results together exceed it (e.g. a batch of
+ *     parallel Read results), persist the largest ones first until under.
+ */
+import type { Message } from "../types.js";
+/** Per-result threshold. Larger than this → persist + replace. */
+export declare const DEFAULT_PERSIST_THRESHOLD = 50000;
+/** Per-message aggregate cap (sum of tool_result content sizes in one user msg). */
+export declare const PER_MESSAGE_AGGREGATE_CAP = 200000;
+/** Preview length included in the replacement string. */
+export declare const PREVIEW_SIZE = 2000;
+/**
+ * Per-session decision state for tool-result persistence.
+ *
+ *  seenIds       — every tool_use_id we've evaluated; once seen, its fate
+ *                  (persisted or not) is fixed for the rest of the session.
+ *  replacements  — subset of seenIds that were persisted, mapped to the
+ *                  EXACT replacement string sent to the model. Re-applying
+ *                  is a Map lookup, never re-reads the file, guarantees
+ *                  byte-identical output.
+ */
+export interface ContentReplacementState {
+    seenIds: Set<string>;
+    replacements: Map<string, string>;
+}
+export declare function createContentReplacementState(): ContentReplacementState;
+/**
+ * Rebuild a state object by walking the loaded message history.
+ * Used on resume so the budget makes the same decisions it made before.
+ * Replacements are taken from the messages themselves (we identify them
+ * by the PERSISTED_OPEN sentinel), so we don't need a side-channel log.
+ */
+export declare function reconstructContentReplacementState(messages: Message[]): ContentReplacementState;
+/**
+ * Resolve the directory tool results are written to, given the engine's
+ * transcript path. Layout:  <transcriptDir>/tool-results/
+ */
+export declare function resolveToolResultsDir(transcriptPath: string): string;
+interface PersistOptions {
+    /** Per-result threshold; default DEFAULT_PERSIST_THRESHOLD. */
+    perResultThreshold?: number;
+    /** Per-message aggregate cap; default PER_MESSAGE_AGGREGATE_CAP. */
+    perMessageCap?: number;
+    /** Directory to write tool-result files to. Required. */
+    toolResultsDir: string;
+    /** Decision state, mutated in place. */
+    state: ContentReplacementState;
+    /** Optional callback fired when a result is freshly persisted. */
+    onPersist?: (info: {
+        toolUseId: string;
+        filepath: string;
+        originalSize: number;
+        reason: "per-result-cap" | "per-message-budget";
+    }) => void;
+}
+/**
+ * Walk each user message, decide which tool_result blocks should be
+ * persisted (per-result cap OR per-message aggregate), persist them,
+ * and return a new message array with those blocks replaced.
+ *
+ * Frozen decisions:
+ *  - If a tool_use_id is already in state.replacements, that exact
+ *    replacement is re-applied (no I/O).
+ *  - If it's in state.seenIds but NOT replacements, it was decided
+ *    "don't persist" on an earlier pass — leave it unreplaced even if
+ *    it now exceeds the threshold (changing the decision mid-session
+ *    would invalidate any model state built on the prior content).
+ *
+ * @returns the new messages array, with replacements applied.
+ */
+export declare function applyToolResultPersistence(messages: Message[], options: PersistOptions): Message[];
+/**
+ * Public test helper: check whether content already wears the persisted
+ * sentinel. Used by tests to assert idempotency.
+ */
+export declare function isPersistedReplacement(s: string): boolean;
+export {};

package/dist/devtools-T2NIZBJK.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+var _chunkKS3RYAYLcjs = require('./chunk-KS3RYAYL.cjs');
+
+// src/render/devtools.ts
+_chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );

package/dist/{devtools-IRQQPIRY.js → devtools-YXWHOVKR.js}

@@ -1,6 +1,6 @@
 import {
   init_esm_shims
-} from "./chunk-DI7RDLOS.js";
+} from "./chunk-MD32R22I.js";
 
 // src/render/devtools.ts
 init_esm_shims();

package/dist/engine/engine.d.ts

@@ -36,6 +36,13 @@ export interface EngineConfig {
      * Engine doesn't persist cost state — it's a UI concern.
      */
     costStore?: CostStateStore;
+    /**
+     * True when the Engine runs in a no-UI / one-shot context (e.g. the `run`
+     * command). Currently controls InvestigationGuard soft-mode: in headless
+     * we never hard-block a tool call because there is no human to retry.
+     * Defaults to false.
+     */
+    headless?: boolean;
 }
 export interface EngineHookConfig {
     event: HookEventName;
@@ -64,8 +71,29 @@ export declare class Engine {
     private lastSessionId;
     private compactedMessagesBySession;
     private activePermission;
+    /** Public accessor so UI/clients can read the resolved per-model window. */
+    get maxContextTokens(): number;
     private resolveMaxContextTokens;
     constructor(config: EngineConfig);
+    /**
+     * Load models[] / providers[] from settings into the active ModelPool and
+     * resync this.config.llm with the matching entry. Called from the ctor and
+     * from reloadModelPool() (e.g. after onboarding writes new entries to disk).
+     */
+    private populateModelPoolFromSettings;
+    /**
+     * Re-read settings and refresh the model pool. Used after onboarding /login
+     * writes new providers[] / models[] to disk so the running engine picks them
+     * up without a process restart. Existing pool entries are kept (re-registering
+     * the same key overwrites them), so callers don't need to clear first.
+     */
+    reloadModelPool(): void;
+    /**
+     * Auto-populate the model pool when settings.models[] is empty but
+     * the user has configured an API key. Detects the provider from the
+     * key prefix / baseUrl and registers all its known models.
+     */
+    private autoPopulatePool;
     /**
      * Register a custom tool (from product adapter) into the tool registry.
      * Must be called before run().
@@ -89,8 +117,23 @@ export declare class Engine {
     /**
      * Switch the active model by pool key. Takes effect on the next run() call.
      * Returns the new model entry.
+     *
+     * Persists settings.activeKey (and a legacy settings.model.* mirror) so the
+     * next process startup defaults to the same model — without this, switches
+     * only live in memory and every restart reverts to the previously persisted
+     * activeKey.
      */
     switchModel(key: string): ModelEntry;
+    /**
+     * Write the active model selection to ~/.code-shell/settings.json.
+     *
+     * We mirror into the legacy settings.model.* block (provider/name/apiKey/
+     * baseUrl) because boot paths in cli/main.ts, repl.ts, run.ts still read it.
+     * The mirror uses resolved llm values (not raw entry.*) so credentials that
+     * live on settings.providers[] flow through correctly — entry.apiKey is
+     * undefined when the entry resolves via providerCatalog.
+     */
+    private persistActiveModel;
     /** Get the model pool. */
     getModelPool(): ModelPool;
     /** Get the current model name (full path). */
@@ -102,6 +145,10 @@ export declare class Engine {
      * Inject context into a session's transcript without triggering a LLM turn.
      * The injected content appears as an assistant message so the LLM can see it
      * in subsequent conversations. The transcript auto-flushes to disk.
+     *
+     * Also updates the in-memory compacted message cache so the next
+     * engine.run() call for this session picks up the injected content
+     * instead of a stale snapshot from the previous run.
      */
     injectContext(sessionId: string, content: string): void;
     /**

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

@@ -16,6 +16,12 @@ export interface TurnLoopConfig {
     tokenBudget?: number;
     onStream?: StreamCallback;
     signal?: AbortSignal;
+    /**
+     * Fired after each turn boundary is recorded. Lets the engine flush an
+     * up-to-date snapshot to state.json mid-run, so a long run doesn't leave
+     * the on-disk turnCount/status frozen at the last completion.
+     */
+    onTurnBoundary?: (turnCount: number) => void;
 }
 export interface TurnLoopDeps {
     model: ModelFacade;