@vybestack/llxprt-code-core 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/core/tokenLimits.ts

@@ -4,123 +4,84 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ModelLimitsCatalogSchema } from './model-limits.schema.js';
+import type { ModelLimitsCatalog } from './model-limits.schema.js';
+import catalogData from './model-limits.json' with { type: 'json' };
+
 type Model = string;
 type TokenCount = number;
 
-/**
- * Conservative fallback for unrecognized models.
- *
- * Lowered from 1M to 200K (issue #2270 / #2527): the overwhelmingly common
- * real-world floor is 200K (Claude, many GLM/Gemini variants). Defaulting to
- * 200K instead of 1M makes the unrecognized-model case fail-safe — proactive
- * compression fires conservatively rather than silently overrunning a
- * sub-200K backend.
- */
-export const DEFAULT_TOKEN_LIMIT = 200_000;
-
-const OPENAI_128K_PREFIXES = [
-  'o4-mini',
-  'gpt-4o-mini',
-  'gpt-4o-realtime',
-  'gpt-4o',
-  'gpt-4-turbo',
-];
+// Catalog corruption is a release/configuration error. Validate eagerly so an
+// invalid package fails deterministically instead of silently using stale limits.
+const CATALOG = ModelLimitsCatalogSchema.parse(catalogData);
 
-const OPENAI_200K_PREFIXES = ['o3-pro', 'o3-mini', 'o1-mini', 'o3', 'o1'];
+export const DEFAULT_TOKEN_LIMIT: TokenCount = CATALOG.defaultLimit;
 
-interface PrefixLimit {
-  prefix: string;
-  limit: TokenCount;
+function matchesAnyPrefix(model: string, prefixes: readonly string[]): boolean {
+  return prefixes.some((prefix) => model.startsWith(prefix));
 }
 
-const PREFIX_LIMITS: PrefixLimit[] = [
-  { prefix: 'gpt-4.1', limit: 1_000_000 },
-  { prefix: 'gpt-3.5-turbo', limit: 16_385 },
-  // Gemini 2.x variants (experimental, preview, dated snapshots) — all 1M.
-  // Exact entries above take precedence, so the 32K image-generation variant
-  // is unaffected. Prevents the lowered DEFAULT_TOKEN_LIMIT from silently
-  // shrinking recognized Gemini variants (issue #2527).
-  { prefix: 'gemini-2.5-pro', limit: 1_048_576 },
-  { prefix: 'gemini-2.5-flash', limit: 1_048_576 },
-  { prefix: 'gemini-2.0-flash', limit: 1_048_576 },
-  // GLM-5 family — 200K context window (z.ai API docs)
-  { prefix: 'glm-5', limit: 200_000 },
-  // GLM-4 family — 128K context window (z.ai API docs)
-  { prefix: 'glm-4', limit: 128_000 },
-];
-
-const EXACT_LIMITS: Record<string, TokenCount> = {
-  // GLM (z.ai) models — exact entries for commonly used variants.
-  // The GLM-5 family (glm-5, glm-5.1, glm-5.2, …) exposes a 200K context
-  // window; the GLM-4 family (glm-4, glm-4.5, glm-4.6, …) exposes 128K.
-  // Prefix-based fallbacks below cover future/dated variants.
-  'glm-5.2': 200_000,
-  'glm-5.1': 200_000,
-  'glm-5': 200_000,
-  'glm-4.6': 128_000,
-  'glm-4.5': 128_000,
-  'glm-4': 128_000,
-
-  // Gemini models
-  'gemini-1.5-pro': 2_097_152,
-  'gemini-1.5-flash': 1_048_576,
-  'gemini-2.5-pro-preview-05-06': 1_048_576,
-  'gemini-2.5-pro-preview-06-05': 1_048_576,
-  'gemini-2.5-pro': 1_048_576,
-  'gemini-2.5-flash-preview-05-20': 1_048_576,
-  'gemini-2.5-flash': 1_048_576,
-  'gemini-2.5-flash-lite': 1_048_576,
-  'gemini-2.0-flash': 1_048_576,
-  'gemini-2.0-flash-preview-image-generation': 32_000,
-
-  // Claude Opus 5 and Opus 4.6/4.7/4.8 default to the Claude Code /
-  // subscription 200K context window. The 1M window is API-only and
-  // plan-gated; override via /set or a profile (context-limit).
-  'claude-opus-5': 200_000,
-  'claude-opus-5-latest': 200_000,
-  'claude-opus-4-8': 200_000,
-  'claude-opus-4-7': 200_000,
-  'claude-opus-4-6': 200_000,
-  'claude-opus-4-latest': 200_000,
-  'claude-sonnet-4-6': 200_000,
-  'claude-sonnet-4-latest': 400_000,
-  // Claude Sonnet 5 defaults to the Claude Code / subscription 200K context
-  // window. The advertised 1M window is API-only and plan-gated; override via
-  // /set or a profile (context-limit).
-  'claude-sonnet-5': 200_000,
-  'claude-sonnet-5-latest': 200_000,
-  // Claude Fable 5 defaults to the Claude Code / subscription 200K context
-  // window. The advertised 1M window is API-only and plan-gated; override via
-  // /set or a profile (context-limit). Mirrors getContextWindowForModel.
-  'claude-fable-5': 200_000,
-  'claude-fable-5-latest': 200_000,
-  'claude-3-7-opus-20250115': 300_000,
-  'claude-3-7-sonnet-20250115': 300_000,
-  'claude-3-opus-20240229': 200_000,
-  'claude-3-sonnet-20240229': 200_000,
-  'claude-3-haiku-20240307': 200_000,
-  'claude-3.5-sonnet-20240620': 200_000,
-  'claude-3.5-sonnet-20241022': 200_000,
-  'claude-3.5-haiku-20241022': 200_000,
-  'claude-3-5-sonnet-20241022': 200_000,
-  'claude-3-5-haiku-20241022': 200_000,
-};
-
-function matchesAnyPrefix(model: string, prefixes: string[]): boolean {
-  return prefixes.some((prefix) => model.startsWith(prefix));
+function assertUnreachableRule(rule: never): never {
+  throw new Error(`Unsupported model-limit rule: ${JSON.stringify(rule)}`);
 }
 
-function resolvePrefixLimit(
+/**
+ * Resolve a single catalog's ordered rules against a model id + provider
+ * prefix. Exported so that the case-insensitive normalization can be tested
+ * with any catalog (including mixed-case fixtures) without type assertions.
+ */
+export function resolveOrderedRuleFromCatalog(
+  catalog: ModelLimitsCatalog,
   modelWithoutPrefix: string,
+  providerPrefix: string,
 ): TokenCount | undefined {
-  for (const { prefix, limit } of PREFIX_LIMITS) {
-    if (modelWithoutPrefix.startsWith(prefix)) {
-      return limit;
+  for (const rule of catalog.orderedRules) {
+    switch (rule.type) {
+      case 'substring':
+        if (modelWithoutPrefix.includes(rule.substring)) {
+          return rule.limit;
+        }
+        break;
+      case 'substringOrProviderPrefix':
+        if (
+          modelWithoutPrefix.includes(rule.substring) ||
+          providerPrefix === rule.providerPrefix
+        ) {
+          return rule.limit;
+        }
+        break;
+      case 'prefixGroup':
+        if (matchesAnyPrefix(modelWithoutPrefix, rule.prefixes)) {
+          return rule.limit;
+        }
+        break;
+      case 'substringCaseInsensitive':
+        if (
+          modelWithoutPrefix
+            .toLowerCase()
+            .includes(rule.substring.toLowerCase())
+        ) {
+          return rule.limit;
+        }
+        break;
+      default:
+        return assertUnreachableRule(rule);
     }
   }
   return undefined;
 }
 
+function resolveOrderedRule(
+  modelWithoutPrefix: string,
+  providerPrefix: string,
+): TokenCount | undefined {
+  return resolveOrderedRuleFromCatalog(
+    CATALOG,
+    modelWithoutPrefix,
+    providerPrefix,
+  );
+}
+
 export function tokenLimit(
   model: Model,
   userContextLimit?: number,
@@ -137,57 +98,22 @@ export function tokenLimit(
     colonIndex !== -1 ? model.slice(colonIndex + 1) : model;
 
   // Check exact model matches first
-  if (modelWithoutPrefix in EXACT_LIMITS) {
-    return EXACT_LIMITS[modelWithoutPrefix];
+  const exactLimit = CATALOG.exactLimits[modelWithoutPrefix];
+  if (typeof exactLimit === 'number') {
+    return exactLimit;
   }
 
   // Check prefix-based limits
-  const prefixLimit = resolvePrefixLimit(modelWithoutPrefix);
-  if (prefixLimit !== undefined) {
-    return prefixLimit;
-  }
-
-  // Codex models default to 256K context (per composition/aliases/codex.config).
-  // variant has a smaller 128K window and must be checked first since its ID
-  // also contains the substring "codex". Non-suffixed codex model IDs
-  // (gpt-5.5, gpt-5.4, gpt-5.2, gpt-5.1) are only resolvable when the
-  // provider prefix is explicitly "codex" — a bare ID is ambiguous and could
-  // belong to the regular OpenAI provider.
-  if (modelWithoutPrefix.includes('codex-spark')) {
-    return 131_072;
-  }
-  if (modelWithoutPrefix.includes('codex') || providerPrefix === 'codex') {
-    return 262_144;
-  }
-
-  // Check OpenAI 200K models (includes o3, o1 series)
-  if (matchesAnyPrefix(modelWithoutPrefix, OPENAI_200K_PREFIXES)) {
-    return 200_000;
-  }
-
-  // Check OpenAI 128K models
-  if (matchesAnyPrefix(modelWithoutPrefix, OPENAI_128K_PREFIXES)) {
-    return 128_000;
-  }
-
-  // Claude Sonnet 5 dated snapshot variants (e.g. claude-sonnet-5-YYYYMMDD)
-  // are not individually exact-keyed above; resolve them to the same
-  // subscription-safe 200K default as the bare alias and -latest. Mirrors
-  // getContextWindowForModel in the anthropic package.
-  if (modelWithoutPrefix.toLowerCase().includes('claude-sonnet-5')) {
-    return 200_000;
-  }
-
-  // Claude Opus 5 dated snapshot variants (e.g. claude-opus-5-YYYYMMDD)
-  // resolve to the same subscription-safe 200K default.
-  if (modelWithoutPrefix.toLowerCase().includes('claude-opus-5')) {
-    return 200_000;
+  for (const { prefix, limit } of CATALOG.prefixLimits) {
+    if (modelWithoutPrefix.startsWith(prefix)) {
+      return limit;
+    }
   }
 
-  // Claude Fable 5 dated snapshot variants (e.g. claude-fable-5-YYYYMMDD)
-  // resolve to the same subscription-safe 200K default.
-  if (modelWithoutPrefix.toLowerCase().includes('claude-fable-5')) {
-    return 200_000;
+  // Check ordered data-driven rules (codex, OpenAI groups, Claude substrings)
+  const orderedLimit = resolveOrderedRule(modelWithoutPrefix, providerPrefix);
+  if (orderedLimit !== undefined) {
+    return orderedLimit;
   }
 
   return DEFAULT_TOKEN_LIMIT;

package/src/core/turn.ts

@@ -199,10 +199,19 @@ export enum CompressionStatus {
   /** The compression failed due to an error counting tokens */
   COMPRESSION_FAILED_TOKEN_COUNT_ERROR = 3,
 
-  /** The compression failed because the model returned an empty summary */
-  COMPRESSION_FAILED_EMPTY_SUMMARY,
+  /**
+   * The compression failed because the model returned an empty summary.
+   * Explicit value to avoid colliding with NOOP (issue #2602).
+   */
+  COMPRESSION_FAILED_EMPTY_SUMMARY = 7,
 
-  /** The compression was not necessary and no action was taken */
+  /**
+   * Structural compression was a no-op: the strategy determined it could not
+   * produce a valid compressed candidate (e.g. no valid middle after split /
+   * tool-boundary / last-user-prompt preservation) and returned the history
+   * unchanged. Distinct serialized value from COMPRESSION_FAILED_EMPTY_SUMMARY
+   * (issue #2602).
+   */
   NOOP = 4,
 
   /** Compression ran recently and did not reduce tokens further */
@@ -224,6 +233,14 @@ export enum PerformCompressionResult {
   SKIPPED_EMPTY = 'skipped_empty',
   /** Compression skipped due to cooldown after repeated failures */
   SKIPPED_COOLDOWN = 'skipped_cooldown',
+  /**
+   * Structural compression was a no-op: the configured strategy (and, for
+   * middle-out, the one-shot fallback) determined it could not produce a valid
+   * compressed candidate and returned history unchanged. Distinct from skips
+   * (which never attempted) and from FAILED (which attempted and threw).
+   * (issue #2602)
+   */
+  NOOP = 'noop',
   /** Compression was attempted but all strategies failed */
   FAILED = 'failed',
 }

package/src/hooks/hookRegistry.ts

@@ -55,9 +55,11 @@ export class HookRegistry {
   /**
    * Initialize the registry by processing hooks from config
    */
-  async initialize(): Promise<void> {
+  async initialize(signal?: AbortSignal): Promise<void> {
+    signal?.throwIfAborted();
     this.entries = [];
     this.processHooksFromConfig();
+    signal?.throwIfAborted();
 
     debugLogger.log(
       `Hook registry initialized with ${this.entries.length} hook entries`,

package/src/hooks/hookRunner.ts

@@ -299,7 +299,7 @@ export class HookRunner {
 
       const child = this.spawnHookProcess(hookConfig, input);
 
-      const timeoutHandle = this.setupKillTimeout(child, timeout, () => {
+      const timeoutControl = this.setupKillTimeout(child, timeout, () => {
         timedOut = true;
       });
 
@@ -314,7 +314,7 @@ export class HookRunner {
       });
 
       child.on('close', (exitCode) => {
-        clearTimeout(timeoutHandle);
+        timeoutControl.clear();
         const duration = Date.now() - startTime;
         if (timedOut) {
           resolve(
@@ -342,7 +342,7 @@ export class HookRunner {
       });
 
       child.on('error', (error) => {
-        clearTimeout(timeoutHandle);
+        timeoutControl.clear();
         resolve(
           this.errorResult(
             hookConfig,
@@ -373,20 +373,37 @@ export class HookRunner {
     };
   }
 
+  /**
+   * Sends SIGTERM after `timeout`, then escalates to SIGKILL if the child is
+   * still running. Do not use `child.killed` for escalation — Node sets that
+   * when a signal is *sent*, not when the process exits, so SIGTERM-ignoring
+   * hooks would never receive SIGKILL and could hang forever.
+   */
   private setupKillTimeout(
     child: ReturnType<typeof spawn>,
     timeout: number,
     onTimeout: () => void,
-  ): NodeJS.Timeout {
-    return setTimeout(() => {
+  ): { clear: () => void } {
+    let forceKillHandle: NodeJS.Timeout | undefined;
+    const timeoutHandle = setTimeout(() => {
       onTimeout();
       child.kill('SIGTERM');
-      setTimeout(() => {
-        if (!child.killed) {
+      forceKillHandle = setTimeout(() => {
+        // Still running only when both exit indicators remain null.
+        if (child.exitCode === null && child.signalCode === null) {
           child.kill('SIGKILL');
         }
       }, 5000);
     }, timeout);
+
+    return {
+      clear: () => {
+        clearTimeout(timeoutHandle);
+        if (forceKillHandle !== undefined) {
+          clearTimeout(forceKillHandle);
+        }
+      },
+    };
   }
 
   private timeoutResult(

package/src/hooks/hookSystem.ts

@@ -53,6 +53,14 @@ export class HookSystem {
   private readonly runner: HookRunner;
   private readonly aggregator: HookAggregator;
   private eventHandler: HookEventHandler | null = null;
+  private initializationPromise: Promise<void> | undefined;
+  private initializationGeneration = 0;
+  private readonly initializationSignals = new Map<
+    number,
+    AbortSignal | undefined
+  >();
+  private lifecycleGeneration = 0;
+  private readonly disposalController = new AbortController();
 
   /**
    * @plan PLAN-20250218-HOOKSYSTEM.P03
@@ -97,22 +105,65 @@ export class HookSystem {
    * @requirement:HOOK-003 - Calls HookRegistry.initialize() to load hooks from config
    * @requirement:HOOK-008 - Called by trigger functions on first event fire
    */
-  async initialize(): Promise<void> {
-    debugLogger.debug('Initializing HookSystem');
+  initialize(signal?: AbortSignal): Promise<void> {
+    if (this.lifecycleGeneration > 0) {
+      return Promise.reject(new Error('HookSystem has been disposed.'));
+    }
+    if (signal?.aborted === true) {
+      return Promise.reject(signal.reason);
+    }
+    const generation = ++this.initializationGeneration;
+    this.initializationSignals.set(generation, signal);
+    if (this.initializationPromise !== undefined) {
+      return this.initializationPromise;
+    }
+    const initialization = this.runInitializationGenerations().finally(() => {
+      if (this.initializationPromise === initialization) {
+        this.initializationPromise = undefined;
+      }
+    });
+    this.initializationPromise = initialization;
+    return initialization;
+  }
 
-    // Dispose old event handler to prevent MessageBus subscription leaks.
-    // LLxprt enhancement: Upstream Gemini doesn't need this because their
-    // HookEventHandler doesn't subscribe to MessageBus. LLxprt added MessageBus
-    // integration in PLAN-20250218-HOOKSYSTEM.P03 (DELTA-HEVT-001).
-    // Without disposal, each re-init creates a new subscription without
-    // unsubscribing the old one, causing memory leaks.
-    this.dispose();
+  private async runInitializationGenerations(): Promise<void> {
+    let completedGeneration = 0;
+    while (completedGeneration < this.initializationGeneration) {
+      const generation = this.initializationGeneration;
+      const requestedSignal = this.initializationSignals.get(generation);
+      const signal = requestedSignal
+        ? AbortSignal.any([requestedSignal, this.disposalController.signal])
+        : this.disposalController.signal;
+      try {
+        await this.initializeGeneration(signal);
+        completedGeneration = generation;
+      } finally {
+        this.deleteInitializationSignalsThrough(generation);
+      }
+    }
+  }
 
-    // Initialize the registry (loads hooks from config)
-    await this.registry.initialize();
+  private deleteInitializationSignalsThrough(generation: number): void {
+    for (const queuedGeneration of this.initializationSignals.keys()) {
+      if (queuedGeneration <= generation) {
+        this.initializationSignals.delete(queuedGeneration);
+      }
+    }
+  }
 
-    // Create the event handler now that registry is ready,
-    // forwarding injected dependencies per DELTA-HSYS-001
+  private async initializeGeneration(signal?: AbortSignal): Promise<void> {
+    const lifecycleGeneration = this.lifecycleGeneration;
+    if (lifecycleGeneration > 0) {
+      throw new Error('HookSystem has been disposed.');
+    }
+    signal?.throwIfAborted();
+    debugLogger.debug('Initializing HookSystem');
+    this.disposeEventHandler();
+    await this.registry.initialize(signal);
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      throw new Error('HookSystem has been disposed.');
+    }
+    signal?.throwIfAborted();
     this.eventHandler = new HookEventHandler(
       this.config,
       this.registry,
@@ -387,6 +438,15 @@ export class HookSystem {
    * @requirement DELTA-HEVT-004
    */
   dispose(): void {
+    this.lifecycleGeneration++;
+    this.initializationGeneration++;
+    this.disposalController.abort(new Error('HookSystem has been disposed.'));
+    this.initializationSignals.clear();
+    this.disposeEventHandler();
+  }
+
+  private disposeEventHandler(): void {
     this.eventHandler?.dispose();
+    this.eventHandler = null;
   }
 }

package/src/index.ts

@@ -146,6 +146,7 @@ export {
 } from './utils/generateContentResponseUtilities.js';
 export * from './utils/filesearch/fileSearch.js';
 export * from './utils/secure-browser-launcher.js';
+export * from './utils/browser-profile-discovery.js';
 export * from './utils/errorParsing.js';
 export * from './utils/ignorePatterns.js';
 export { INITIAL_HISTORY_LENGTH } from './utils/environmentContext.js';

package/src/llm-types/geminiContent.ts

@@ -61,6 +61,9 @@ export interface GeminiPartExtension {
    * May also contain arbitrary user-configured field names (issue #2488).
    */
   llxprtSourceField?: string;
+  llxprtThoughtBlockId?: string;
+  llxprtThoughtBlockStatus?: 'delta' | 'complete';
+  llxprtThoughtIsHidden?: boolean;
 }
 
 /**

package/src/policy/config.ts

@@ -78,13 +78,15 @@ export async function createPolicyEngineConfig(
 export async function createPolicyEngineConfig(
   settings: PolicySettings,
   approvalMode: ApprovalMode,
-  defaultPoliciesDir?: string,
+  defaultPoliciesDir: string | undefined,
+  trustedFolder: boolean,
 ): Promise<PolicyEngineConfig>;
 
 export async function createPolicyEngineConfig(
   configOrSettings: PolicyConfigSource | PolicySettings,
   approvalModeParam?: ApprovalMode,
   defaultPoliciesDir?: string,
+  trustedFolder?: boolean,
 ): Promise<PolicyEngineConfig> {
   const isPolicyConfigSource =
     typeof (configOrSettings as PolicyConfigSource).getApprovalMode ===
@@ -97,6 +99,7 @@ export async function createPolicyEngineConfig(
     configOrSettings as PolicySettings,
     approvalModeParam!,
     defaultPoliciesDir,
+    trustedFolder ?? false,
   );
 }
 
@@ -150,7 +153,8 @@ async function loadUserPolicyRules(
 async function buildSettingsRules(
   settings: PolicySettings,
   approvalMode: ApprovalMode,
-  defaultPoliciesDir?: string,
+  defaultPoliciesDir: string | undefined,
+  trustedFolder: boolean,
 ): Promise<PolicyEngineConfig> {
   const policyDirs = getPolicyDirectories(defaultPoliciesDir);
 
@@ -167,7 +171,9 @@ async function buildSettingsRules(
   addMcpExcludedRules(settings, rules);
   addToolsExcludedRules(settings, rules);
   addToolsAllowedRules(settings, rules);
-  addMcpTrustedRules(settings, rules);
+  if (trustedFolder) {
+    addMcpTrustedRules(settings, rules);
+  }
   addMcpAllowedRules(settings, rules);
 
   return {
@@ -194,7 +200,7 @@ function addMcpExcludedRules(
   if (settings.mcp?.excluded) {
     for (const serverName of settings.mcp.excluded) {
       rules.push({
-        toolName: `${serverName}__*`,
+        toolNamePrefix: `${serverName}__`,
         decision: PolicyDecision.DENY,
         priority: 2.9,
         source: 'Settings (MCP Excluded)',
@@ -293,24 +299,31 @@ function normalizeToolName(toolName: string): string {
   return toolName;
 }
 
+export const MCP_TRUSTED_POLICY_SOURCE = 'Settings (MCP Trusted)';
+
+export function buildMcpTrustedRules(
+  settings: PolicySettings,
+): readonly PolicyRule[] {
+  return Object.entries(settings.mcpServers ?? {}).flatMap(
+    ([serverName, serverConfig]) =>
+      serverConfig.trust === true
+        ? [
+            {
+              toolNamePrefix: `${serverName}__`,
+              decision: PolicyDecision.ALLOW,
+              priority: 2.2,
+              source: MCP_TRUSTED_POLICY_SOURCE,
+            },
+          ]
+        : [],
+  );
+}
+
 function addMcpTrustedRules(
   settings: PolicySettings,
   rules: PolicyRule[],
 ): void {
-  if (settings.mcpServers) {
-    for (const [serverName, serverConfig] of Object.entries(
-      settings.mcpServers,
-    )) {
-      if (serverConfig.trust === true) {
-        rules.push({
-          toolName: `${serverName}__*`,
-          decision: PolicyDecision.ALLOW,
-          priority: 2.2,
-          source: 'Settings (MCP Trusted)',
-        });
-      }
-    }
-  }
+  rules.push(...buildMcpTrustedRules(settings));
 }
 
 function addMcpAllowedRules(
@@ -320,7 +333,7 @@ function addMcpAllowedRules(
   if (settings.mcp?.allowed) {
     for (const serverName of settings.mcp.allowed) {
       rules.push({
-        toolName: `${serverName}__*`,
+        toolNamePrefix: `${serverName}__`,
         decision: PolicyDecision.ALLOW,
         priority: 2.1,
         source: 'Settings (MCP Allowed)',