@cjhyy/code-shell-core 0.8.8 → 0.8.10

package/dist/engine/run-types.d.ts

@@ -32,6 +32,20 @@ export interface RunBehaviorProfile {
     disablePlanMode?: boolean;
     /** When true, MCP servers are neither connected nor exposed for the run. */
     disableMcp?: boolean;
+    /** Skip repository/user instruction discovery for this run. */
+    disableInstructions?: boolean;
+    /** Skip persistent-memory injection for this run. */
+    disableMemoryContext?: boolean;
+    /** Skip capability-owned volatile context providers for this run. */
+    disableCapabilityContext?: boolean;
+    /** Skip bound-source metadata injection for this run. */
+    disableSourcesContext?: boolean;
+    /** Ignore the project's default digital-human profile for this run. */
+    disableWorkspaceProfile?: boolean;
+    /** Skip SessionStart/UserPromptSubmit/SessionEnd hooks for this run. */
+    disableHooks?: boolean;
+    /** Skip auxiliary title generation for this run. */
+    disableSessionTitle?: boolean;
     /**
      * When true, the injected persistent-memory index is trimmed to this run's
      * project: global-layer project-type / dream-scope records tied to other
@@ -67,6 +81,10 @@ export interface RunBehaviorProfile {
 export declare const QUICK_CHAT_RESTRICTED_SYSTEM_PROMPT = "# Side Conversation Boundary\n\nThis is a side conversation, not the main-thread task execution environment.\n- Treat all content before this boundary as reference history only. Do not proactively continue any earlier plan, task, or modification.\n- Default to answering the user's question directly. Use lightweight read-only exploration only when needed.\n- Do not modify files, git state, configuration, or permissions unless the user explicitly asks after this boundary (for example, \"Allow you to modify files, please help me...\" or \"Please directly edit...\"). When explicitly requested, use the normally available tools subject to the current permission and approval mode.\n- Sub-agents are disabled for this side conversation. Do not create or invoke sub-agents.";
 /** The side-conversation restriction expressed as a generic behavior profile. */
 export declare const QUICK_CHAT_RESTRICTED_PROFILE: RunBehaviorProfile;
+export declare const ISOLATED_TASK_BEHAVIOR_MODE: "isolatedTask";
+export declare const ISOLATED_TASK_SYSTEM_PROMPT = "# Isolated Task Boundary\n\nThis is a bounded Task, not a continuation of any user conversation.\n- Use only the explicit Task input, the visible tool surface, and the selected Skill when one is available.\n- Do not infer or search for prior Session history, persistent memory, unrelated Skills, or other projects.\n- Do not create sub-agents or start unrelated work.\n- Finish the requested outcome, then return a concise result suitable for the owning application.";
+/** Minimal, process-local run profile used by host-owned Tasks. */
+export declare const ISOLATED_TASK_PROFILE: RunBehaviorProfile;
 export interface EngineRunOptions {
     cwd?: string;
     onStream?: StreamCallback;
@@ -80,9 +98,24 @@ export interface EngineRunOptions {
     goal?: string | GoalConfig;
     injected?: boolean;
     clientMessageId?: string;
+    /**
+     * Host-requested history boundary to archive after this run's user message
+     * has been appended, but before the first model call. The current
+     * `clientMessageId` is the exclusive end anchor.
+     */
+    archiveBeforeCurrentTurn?: {
+        fromClientMessageId?: string;
+        segmentId?: string;
+    };
     attachments?: InputAttachmentMeta[];
     /** Named per-run behavior profile supplied by interactive product surfaces. */
     behaviorMode?: RunBehaviorMode;
+    /** Per-run hard tool allowlist. An empty list exposes no tools. */
+    toolAllowlist?: readonly string[];
+    /** Per-run hard Skill allowlist. An empty list exposes no Skills. */
+    skillAllowlist?: readonly string[];
+    /** Keep a fresh Session in process memory only and omit it from Session pickers. */
+    ephemeral?: boolean;
     /**
      * Generic per-run parameters consumed by the active behavior profile
      * (createRunServices / buildVisibilityMeta / runtime-context injection).

package/dist/engine/run-types.js

@@ -10,3 +10,24 @@ export const QUICK_CHAT_RESTRICTED_PROFILE = {
     id: "quickChatRestricted",
     systemPromptAppend: QUICK_CHAT_RESTRICTED_SYSTEM_PROMPT,
 };
+export const ISOLATED_TASK_BEHAVIOR_MODE = "isolatedTask";
+export const ISOLATED_TASK_SYSTEM_PROMPT = `# Isolated Task Boundary
+
+This is a bounded Task, not a continuation of any user conversation.
+- Use only the explicit Task input, the visible tool surface, and the selected Skill when one is available.
+- Do not infer or search for prior Session history, persistent memory, unrelated Skills, or other projects.
+- Do not create sub-agents or start unrelated work.
+- Finish the requested outcome, then return a concise result suitable for the owning application.`;
+/** Minimal, process-local run profile used by host-owned Tasks. */
+export const ISOLATED_TASK_PROFILE = {
+    id: ISOLATED_TASK_BEHAVIOR_MODE,
+    systemPromptAppend: ISOLATED_TASK_SYSTEM_PROMPT,
+    disableMcp: true,
+    disableInstructions: true,
+    disableMemoryContext: true,
+    disableCapabilityContext: true,
+    disableSourcesContext: true,
+    disableWorkspaceProfile: true,
+    disableHooks: true,
+    disableSessionTitle: true,
+};

package/dist/engine/run-workspace.js

@@ -93,11 +93,17 @@ export async function resolveRunWorkspace(args) {
             configCwd: args.configCwd,
             processCwd: args.processCwd,
         });
-    const profileState = resolveRunProfileState({
-        sessionWorkspaceProfile,
-        cwd,
-        settings: args.settings,
-    });
+    const profileState = profile?.disableWorkspaceProfile
+        ? {
+            workspaceProfile: undefined,
+            sessionProfileOverrides: undefined,
+            profileMemoryDir: undefined,
+        }
+        : resolveRunProfileState({
+            sessionWorkspaceProfile,
+            cwd,
+            settings: args.settings,
+        });
     return {
         ok: true,
         resolution: {

package/dist/engine/turn-loop.js

@@ -22,7 +22,7 @@ import { COMPLETE_GOAL_TOOL_NAME } from "../tool-system/builtin/complete-goal.js
 import { CANCEL_GOAL_TOOL_NAME } from "../tool-system/builtin/cancel-goal.js";
 import { redactSensitiveToolResultsInMessages, SENSITIVE_TOOL_RESULT_PLACEHOLDER, toolResultForDisplay, toolResultTranscriptText, toolResultsForDisplay, } from "../tool-system/tool-result-redaction.js";
 import { addTokenUsage, cacheHitRateFromUsage, cumulativeCacheHitRate, } from "../session/usage.js";
-import { createGoalBudgetTracker, recordGoalUsage, goalBudgetTerminationReason, applyGoalExtension, limitProximity, isSameGoalVersion, normalizeGoal, GOAL_DEFAULT_MAX_STOP_BLOCKS, } from "../goal/lifecycle.js";
+import { createGoalBudgetTracker, recordGoalUsage, goalBudgetTerminationReason, applyGoalExtension, extendGoalLimit, limitProximity, isSameGoalVersion, normalizeGoal, GOAL_DEFAULT_MAX_STOP_BLOCKS, } from "../goal/lifecycle.js";
 /**
  * 把一个 ToolResult 映射成发给 LLM 的 tool_result ContentBlock。
  * 有 contentBlocks(view_image 的图片块)就原样用作 content;否则
@@ -148,6 +148,9 @@ export class TurnLoop {
      * effective limits.
      */
     extend(opts) {
+        const previousMaxTurns = this.config.maxTurns;
+        const previousTokenBudget = this.goalTracker?.goal.tokenBudget;
+        const previousTimeBudgetMs = this.goalTracker?.goal.timeBudgetMs;
         const elapsedMs = this.goalTracker ? Date.now() - this.goalTracker.startedAtMs : 0;
         const next = applyGoalExtension(this.config.maxTurns, this.goalTracker?.goal, this.goalTracker?.tokensUsed ?? 0, elapsedMs, opts);
         this.config = { ...this.config, maxTurns: next.maxTurns };
@@ -166,18 +169,16 @@ export class TurnLoop {
         // limit that actually bites, so an extend that only bumped maxTurns/budgets
         // couldn't keep it going. Resolve the current cap the same way the loop does.
         const curCap = this.config.maxStopBlocks ?? GOAL_DEFAULT_MAX_STOP_BLOCKS;
-        const nextCap = typeof opts.addStopBlocks === "number" && opts.addStopBlocks > 0
-            ? curCap + Math.floor(opts.addStopBlocks)
-            : curCap;
+        const nextCap = extendGoalLimit(curCap, opts.addStopBlocks);
         this.config = { ...this.config, maxStopBlocks: nextCap };
         // ANY extension resets the consecutive stop-block streak: the user just
         // asked to keep going, so a goal that was repeatedly re-blocked shouldn't be
         // immediately re-capped. (Previously only addTurns reset it, leaving a
         // budget-only extension unable to un-stick a capped goal.)
-        const extended = (opts.addTurns ?? 0) > 0 ||
-            (opts.addStopBlocks ?? 0) > 0 ||
-            (opts.addTokenBudget ?? 0) > 0 ||
-            (opts.addTimeBudgetMs ?? 0) > 0;
+        const extended = next.maxTurns !== previousMaxTurns ||
+            nextCap !== curCap ||
+            next.tokenBudget !== previousTokenBudget ||
+            next.timeBudgetMs !== previousTimeBudgetMs;
         if (extended) {
             this.stopBlockCount = 0;
             // Let the next approach re-announce against the raised ceilings.

package/dist/goal/lifecycle.d.ts

@@ -83,6 +83,8 @@ export type GoalLifecycleV1 = (GoalLifecycleBaseV1 & {
     };
 });
 export type GoalLifecyclePhase = GoalLifecycleV1["phase"];
+/** Add a user-controlled positive integer delta without producing Infinity or an unsafe integer. */
+export declare function extendGoalLimit(current: number, addition: unknown): number;
 /** Build one canonical lifecycle record from the compatibility GoalConfig view. */
 export declare function createGoalLifecycle(goal: GoalConfig, phase?: Exclude<GoalLifecyclePhase, "terminal" | "waiting">, nowMs?: number): GoalLifecycleV1;
 /** Compatibility view consumed by Engine/protocol while persistence uses the union. */

package/dist/goal/lifecycle.js

@@ -11,6 +11,25 @@
  * so an unattended goal run can't burn tokens or wall time without bound.
  */
 import { createHash, randomUUID } from "node:crypto";
+function positiveSafeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= Number.MAX_SAFE_INTEGER;
+}
+function positiveSafeInteger(value) {
+    if (!positiveSafeNumber(value))
+        return undefined;
+    const integer = Math.floor(value);
+    return integer >= 1 ? integer : undefined;
+}
+/** Add a user-controlled positive integer delta without producing Infinity or an unsafe integer. */
+export function extendGoalLimit(current, addition) {
+    const delta = positiveSafeInteger(addition);
+    if (delta === undefined)
+        return current;
+    const safeCurrent = typeof current === "number" && Number.isFinite(current) && current >= 0
+        ? Math.min(Number.MAX_SAFE_INTEGER, Math.floor(current))
+        : Number.MAX_SAFE_INTEGER;
+    return Math.min(Number.MAX_SAFE_INTEGER, safeCurrent + delta);
+}
 function goalLifecycleConfig(goal) {
     const { goalId: _goalId, revision: _revision, paused: _paused, ...config } = goal;
     return config;
@@ -22,7 +41,7 @@ export function createGoalLifecycle(goal, phase = goal.paused === true
     const base = {
         version: 1,
         goalId: goal.goalId ?? randomUUID(),
-        revision: Math.max(1, Math.floor(goal.revision ?? 1)),
+        revision: positiveSafeInteger(goal.revision) ?? 1,
         config: goalLifecycleConfig(goal),
         updatedAtMs: nowMs,
     };
@@ -53,7 +72,7 @@ export function decodeGoalLifecycle(value) {
     if (typeof candidate.goalId !== "string" || candidate.goalId.length === 0)
         return undefined;
     if (typeof candidate.revision !== "number" ||
-        !Number.isInteger(candidate.revision) ||
+        !Number.isSafeInteger(candidate.revision) ||
         candidate.revision < 1) {
         return undefined;
     }
@@ -80,17 +99,19 @@ export function decodeGoalLifecycle(value) {
     for (const key of ["tokenBudget", "timeBudgetMs", "maxTurns", "maxStopBlocks"]) {
         const field = config[key];
         if (field !== undefined &&
-            (typeof field !== "number" || !Number.isFinite(field) || field <= 0)) {
+            !positiveSafeNumber(field)) {
             return undefined;
         }
     }
     for (const key of ["maxTurns", "maxStopBlocks"]) {
         const field = config[key];
-        if (field !== undefined && !Number.isInteger(field))
+        if (field !== undefined && !Number.isSafeInteger(field))
             return undefined;
     }
     if (config.setAtMs !== undefined &&
-        (typeof config.setAtMs !== "number" || !Number.isFinite(config.setAtMs) || config.setAtMs < 0)) {
+        (typeof config.setAtMs !== "number" ||
+            !Number.isSafeInteger(config.setAtMs) ||
+            config.setAtMs < 0)) {
         return undefined;
     }
     const phase = candidate.phase;
@@ -309,11 +330,12 @@ export const INTERACTIVE_DEFAULT_MAX_STOP_BLOCKS = 8;
  * Pure + injectable so engine and tests agree.
  */
 export function resolveMaxStopBlocks(configMaxStopBlocks, goal) {
-    if (typeof configMaxStopBlocks === "number" && configMaxStopBlocks > 0) {
-        return Math.floor(configMaxStopBlocks);
-    }
-    if (goal?.maxStopBlocks && goal.maxStopBlocks > 0)
-        return goal.maxStopBlocks;
+    const configLimit = positiveSafeInteger(configMaxStopBlocks);
+    if (configLimit !== undefined)
+        return configLimit;
+    const goalLimit = positiveSafeInteger(goal?.maxStopBlocks);
+    if (goalLimit !== undefined)
+        return goalLimit;
     return goal ? GOAL_DEFAULT_MAX_STOP_BLOCKS : INTERACTIVE_DEFAULT_MAX_STOP_BLOCKS;
 }
 /**
@@ -340,24 +362,25 @@ export function normalizeGoal(raw) {
     const out = { objective };
     if (typeof obj.goalId === "string" && obj.goalId.trim())
         out.goalId = obj.goalId;
-    if (typeof obj.revision === "number" && obj.revision > 0) {
-        out.revision = Math.floor(obj.revision);
-    }
+    const revision = positiveSafeInteger(obj.revision);
+    if (revision !== undefined)
+        out.revision = revision;
     if (obj.paused === true)
         out.paused = true;
-    if (typeof obj.tokenBudget === "number" && obj.tokenBudget > 0)
+    if (positiveSafeNumber(obj.tokenBudget))
         out.tokenBudget = obj.tokenBudget;
-    if (typeof obj.timeBudgetMs === "number" && obj.timeBudgetMs > 0)
+    if (positiveSafeNumber(obj.timeBudgetMs))
         out.timeBudgetMs = obj.timeBudgetMs;
-    if (typeof obj.maxTurns === "number" && obj.maxTurns > 0)
-        out.maxTurns = Math.floor(obj.maxTurns);
-    if (typeof obj.maxStopBlocks === "number" && obj.maxStopBlocks > 0) {
-        out.maxStopBlocks = Math.floor(obj.maxStopBlocks);
-    }
+    const maxTurns = positiveSafeInteger(obj.maxTurns);
+    if (maxTurns !== undefined)
+        out.maxTurns = maxTurns;
+    const maxStopBlocks = positiveSafeInteger(obj.maxStopBlocks);
+    if (maxStopBlocks !== undefined)
+        out.maxStopBlocks = maxStopBlocks;
     // Preserve a positive goal-set timestamp so a resumed/inherited goal keeps
     // the anchor for relative deadlines. Non-positive/junk is dropped, matching
     // the budget fields (a bogus anchor is worse than none).
-    if (typeof obj.setAtMs === "number" && obj.setAtMs > 0)
+    if (positiveSafeInteger(obj.setAtMs) !== undefined)
         out.setAtMs = obj.setAtMs;
     return out;
 }
@@ -391,10 +414,11 @@ export const INTERACTIVE_DEFAULT_MAX_TURNS = 100;
  * Pure + injectable so the engine and tests agree on the rule.
  */
 export function resolveMaxTurns(configMaxTurns, goal) {
-    if (typeof configMaxTurns === "number" && configMaxTurns > 0)
-        return configMaxTurns;
+    const configLimit = positiveSafeInteger(configMaxTurns);
+    if (configLimit !== undefined)
+        return configLimit;
     if (goal)
-        return goal.maxTurns ?? GOAL_DEFAULT_MAX_TURNS;
+        return positiveSafeInteger(goal.maxTurns) ?? GOAL_DEFAULT_MAX_TURNS;
     return INTERACTIVE_DEFAULT_MAX_TURNS;
 }
 /** Warn when this many turns (or fewer) remain before maxTurns. */
@@ -436,19 +460,17 @@ export function limitProximity(turnCount, maxTurns, stopBlockCount, maxStopBlock
  */
 export function applyGoalExtension(currentMaxTurns, goal, tokensUsed, elapsedMs, ext) {
     let maxTurns = currentMaxTurns;
-    if (typeof ext.addTurns === "number" && ext.addTurns > 0) {
-        maxTurns += Math.floor(ext.addTurns);
-    }
+    maxTurns = extendGoalLimit(maxTurns, ext.addTurns);
     let tokenBudget = goal?.tokenBudget;
     let timeBudgetMs = goal?.timeBudgetMs;
     if (goal) {
-        if (typeof ext.addTokenBudget === "number" && ext.addTokenBudget > 0) {
-            tokenBudget = (tokenBudget ?? tokensUsed) + Math.floor(ext.addTokenBudget);
+        if (positiveSafeInteger(ext.addTokenBudget) !== undefined) {
+            tokenBudget = extendGoalLimit(tokenBudget ?? tokensUsed, ext.addTokenBudget);
         }
-        if (typeof ext.addTimeBudgetMs === "number" && ext.addTimeBudgetMs > 0) {
+        if (positiveSafeInteger(ext.addTimeBudgetMs) !== undefined) {
             // Seed an unset cap from elapsed time (not 0), mirroring the token branch,
             // so the new cap lands above current usage. Fixes B1.
-            timeBudgetMs = (timeBudgetMs ?? elapsedMs) + Math.floor(ext.addTimeBudgetMs);
+            timeBudgetMs = extendGoalLimit(timeBudgetMs ?? elapsedMs, ext.addTimeBudgetMs);
         }
     }
     return { maxTurns, tokenBudget, timeBudgetMs };
@@ -459,8 +481,9 @@ export function createGoalBudgetTracker(goal, nowMs) {
 }
 /** Add this turn's token usage to the running total. */
 export function recordGoalUsage(tracker, turnTokens) {
-    if (turnTokens > 0)
-        tracker.tokensUsed += turnTokens;
+    if (positiveSafeInteger(turnTokens) !== undefined) {
+        tracker.tokensUsed = extendGoalLimit(tracker.tokensUsed, turnTokens);
+    }
 }
 /**
  * Has the run exceeded any configured budget? `nowMs` is injected so callers

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export declare const VERSION = "0.8.8";
+export declare const VERSION = "0.8.10";
 export type { Message, ContentBlock, ToolDefinition, ToolCall, ToolResult, RegisteredTool, TranscriptEvent, TranscriptEventType, SessionState, SessionKind, SessionWorkspace, SessionForkLineage, ContextUsageAnchor, SessionStatus, TokenUsage, CompiledInput, PermissionDecision, PermissionMode, PermissionRule, TurnPhase, TurnResult, TerminalReason, TurnCompletionKind, StreamEvent, StreamCallback, LLMConfig, ClientDefaults, LLMResponse, Settings, MCPServerConfig, } from "./types.js";
 export type { GoalConfig, GoalLifecycleConfig, GoalLifecyclePhase, GoalLifecycleTerminalReason, GoalLifecycleV1, } from "./goal/lifecycle.js";
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
@@ -66,7 +66,7 @@ export { Methods, ErrorCodes, type RpcMessage, type RunResult, type ForkSessionP
 export type * from "./protocol/mobile-remote-types.js";
 export { Transcript } from "./session/transcript.js";
 export { SessionManager, sessionMainRoot, codeShellHome, sessionsRoot, buildForkState, buildForkTranscript, type ForkSessionOptions, type ForkSessionResult, } from "./session/session-manager.js";
-export { FileHistory } from "./session/file-history.js";
+export { FileHistory, type FileSnapshot, type RedoRecord, type TurnUndoPlan, } from "./session/file-history.js";
 export { latestUndoTarget, earliestSnapshotsPerFile, latestTurnUndoTargets, latestRedoTargets, } from "./session/undo-target.js";
 export { diffLines, renderDiffPreview, type DiffLine } from "./session/simple-diff.js";
 export { MemoryManager } from "./session/memory.js";
@@ -74,7 +74,6 @@ export type { MemoryEntry, MemoryOrigin, MemoryScope } from "./session/memory.js
 export type { RouteSessionMessageInput, SessionMessageRouter, SessionMessageTarget, SessionMessageToolService, } from "./session/session-message.js";
 export { runDreamConsolidation, type DreamConsolidationInput, type DreamConsolidationResult, } from "./services/dream-consolidation.js";
 export { authorize, refreshToken, generatePKCE, createHardenedOAuthFetch, type OAuthConfig, type OAuthTokens, type OAuthAuthorizeOptions, type OAuthRefreshOptions, type HardenedOAuthFetchOptions, } from "./services/oauth.js";
-export type { FileSnapshot, RedoRecord } from "./session/file-history.js";
 export { PromptComposer } from "./prompt/composer.js";
 export { SectionCache } from "./prompt/section-cache.js";
 export { scanInstructions, combineInstructions } from "./prompt/instruction-scanner.js";

package/dist/index.internal.d.ts

@@ -12,6 +12,7 @@ export { execFileNoThrow } from "./utils/execFileNoThrow.js";
 export { findExecutable, resolveExecutable, setGitPathOverride, resolveGit, isGitAvailable, resolveGitPath, } from "./utils/exec.js";
 export { gte } from "./utils/semver.js";
 export { lock, lockSync, unlock, check } from "./utils/lockfile.js";
+export { acquireFileLock, acquireLockOnPath, mutateJsonFile } from "./utils/file-mutex.js";
 export { logForDebugging } from "./utils/debug.js";
 export { isEnvTruthy, isEnvDefinedFalsy, getClaudeConfigHomeDir, isBareMode, parseEnvVars, shouldMaintainProjectWorkingDir, getAWSRegion, getDefaultVertexRegion, getVertexRegionForModel, } from "./utils/envUtils.js";
 export { startCapturingEarlyInput, stopCapturingEarlyInput, consumeEarlyInput, hasEarlyInput, seedEarlyInput, isCapturingEarlyInput, } from "./utils/earlyInput.js";

package/dist/index.internal.js

@@ -13,6 +13,7 @@ export { execFileNoThrow } from "./utils/execFileNoThrow.js";
 export { findExecutable, resolveExecutable, setGitPathOverride, resolveGit, isGitAvailable, resolveGitPath, } from "./utils/exec.js";
 export { gte } from "./utils/semver.js";
 export { lock, lockSync, unlock, check } from "./utils/lockfile.js";
+export { acquireFileLock, acquireLockOnPath, mutateJsonFile } from "./utils/file-mutex.js";
 export { logForDebugging } from "./utils/debug.js";
 export { isEnvTruthy, isEnvDefinedFalsy, getClaudeConfigHomeDir, isBareMode, parseEnvVars, shouldMaintainProjectWorkingDir, getAWSRegion, getDefaultVertexRegion, getVertexRegionForModel, } from "./utils/envUtils.js";
 export { startCapturingEarlyInput, stopCapturingEarlyInput, consumeEarlyInput, hasEarlyInput, seedEarlyInput, isCapturingEarlyInput, } from "./utils/earlyInput.js";

package/dist/index.js

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export const VERSION = "0.8.8";
+export const VERSION = "0.8.10";
 // ─── Exceptions ──────────────────────────────────────────────────
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
 // ─── Engine (primary API) ────────────────────────────────────────
@@ -55,7 +55,7 @@ export { Methods, ErrorCodes, } from "./protocol/types.js";
 // ─── Session ─────────────────────────────────────────────────────
 export { Transcript } from "./session/transcript.js";
 export { SessionManager, sessionMainRoot, codeShellHome, sessionsRoot, buildForkState, buildForkTranscript, } from "./session/session-manager.js";
-export { FileHistory } from "./session/file-history.js";
+export { FileHistory, } from "./session/file-history.js";
 export { latestUndoTarget, earliestSnapshotsPerFile, latestTurnUndoTargets, latestRedoTargets, } from "./session/undo-target.js";
 export { diffLines, renderDiffPreview } from "./session/simple-diff.js";
 export { MemoryManager } from "./session/memory.js";

package/dist/links/cli.d.ts

@@ -17,6 +17,8 @@ export interface CliLinkRunOptions {
     signal?: AbortSignal;
     timeoutMs: number;
     input?: string;
+    /** Keep the pipe alive for browser/device login CLIs that inspect stdin. */
+    keepStdinOpen?: boolean;
 }
 export type CliLinkCommandRunner = (providerId: CliLinkProviderId, command: string, args: string[], options: CliLinkRunOptions) => Promise<CliLinkCommandResult>;
 /** App-private CLI location. It never mutates the user's system PATH. */

package/dist/links/cli.js

@@ -103,10 +103,15 @@ export const runCliLinkCommand = (providerId, command, args, options) => new Pro
         }
         resolve({ stdout: String(stdout), stderr: String(stderr) });
     });
-    // All supported flows are deliberately non-interactive (browser/device
-    // authorization or machine-readable API calls). Always close stdin so a
-    // CLI cannot mistake the Electron pipe for pending JSON or a hidden prompt.
-    child.stdin?.end(options.input ?? "");
+    if (options.input !== undefined)
+        child.stdin?.write(options.input);
+    // API calls consume a complete JSON body and must see EOF. Browser/device
+    // login is different: gh/glab prompt before opening the browser and some
+    // versions of Vercel first present a default login method. Feed one Enter
+    // below, but keep the pipe alive so those CLIs do not fail immediately with
+    // EOF while the browser authorization is still in progress.
+    if (!options.keepStdinOpen)
+        child.stdin?.end();
 });
 function parseJson(result, providerId) {
     try {
@@ -289,6 +294,8 @@ export async function connectCliLink(providerId, options, run = runCliLinkComman
                 cwd: options.cwd,
                 signal: options.signal,
                 timeoutMs: 15 * 60_000,
+                input: "\n",
+                keepStdinOpen: true,
             });
         }
         catch (error) {

package/dist/model-catalog/index.js

@@ -8,7 +8,7 @@
  *
  * No remote source this version (design doc §5).
  */
-import { readFileSync, existsSync } from "node:fs";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { userHome } from "../settings/manager.js";
 import { logger } from "../logging/logger.js";
@@ -16,6 +16,7 @@ import { BUILTIN_CATALOG } from "./builtin.js";
 import { userCatalogFileSchema } from "./types.js";
 export { BUILTIN_CATALOG } from "./builtin.js";
 export { saveCatalogEntry, deleteUserCatalogEntry } from "./save-entry.js";
+const MAX_USER_CATALOG_BYTES = 4 * 1024 * 1024;
 /** Path to the user catalog file (source B). */
 export function userCatalogPath() {
     return join(userHome(), ".code-shell", "model-catalog.user.json");
@@ -26,10 +27,18 @@ export function userCatalogPath() {
  */
 export function loadUserCatalog() {
     const path = userCatalogPath();
-    if (!existsSync(path))
-        return [];
+    let descriptor;
     try {
-        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        const metadata = lstatSync(path);
+        if (metadata.isSymbolicLink() || !metadata.isFile() || metadata.size > MAX_USER_CATALOG_BYTES) {
+            throw new Error("model catalog must be a bounded regular file");
+        }
+        descriptor = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const opened = fstatSync(descriptor);
+        if (!opened.isFile() || opened.size > MAX_USER_CATALOG_BYTES) {
+            throw new Error("model catalog must be a bounded regular file");
+        }
+        const parsed = JSON.parse(readFileSync(descriptor, "utf-8"));
         const result = userCatalogFileSchema.safeParse(parsed);
         if (!result.success) {
             logger.warn("model_catalog_user_invalid", { path, issues: result.error.issues.length });
@@ -38,9 +47,15 @@ export function loadUserCatalog() {
         return result.data;
     }
     catch (err) {
+        if (err.code === "ENOENT")
+            return [];
         logger.warn("model_catalog_user_read_failed", { path, error: err.message });
         return [];
     }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
 }
 /**
  * Merged catalog: built-in (A) ∪ user (B), deduped by `id` with user winning.