agentic-qe 3.12.1 → 3.12.3

package/dist/shared/llm/billing-modes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Agentic QE v3 — Billing mode resolution (ADR-123)
+ *
+ * Maps a provider type to how it bills, and provides the human-facing startup
+ * notice text. Kept separate from the provider classes so callers (router,
+ * kernel, `aqe health`) can resolve a billing mode without constructing a
+ * provider, and so a provider that doesn't set `billingMode` still resolves.
+ */
+import type { BillingMode, LLMProvider, LLMProviderType } from './interfaces';
+/**
+ * Resolve a provider's billing mode: the instance's own `billingMode` wins,
+ * else the per-type default, else `metered-api` (the safe, cap-requiring
+ * assumption for an unknown provider).
+ */
+export declare function resolveBillingMode(provider: Pick<LLMProvider, 'type' | 'billingMode'>): BillingMode;
+/** Resolve a billing mode from a bare provider type. */
+export declare function billingModeForType(type: LLMProviderType): BillingMode;
+/**
+ * One-line notice shown at startup / in `aqe health` describing how the
+ * active provider bills, so a user is never surprised (issue #557). Returns
+ * `undefined` for `local` (nothing to warn about).
+ */
+export declare function billingNotice(provider: LLMProviderType, mode: BillingMode): string | undefined;
+//# sourceMappingURL=billing-modes.d.ts.map

package/dist/shared/llm/billing-modes.js

@@ -0,0 +1,56 @@
+/**
+ * Agentic QE v3 — Billing mode resolution (ADR-123)
+ *
+ * Maps a provider type to how it bills, and provides the human-facing startup
+ * notice text. Kept separate from the provider classes so callers (router,
+ * kernel, `aqe health`) can resolve a billing mode without constructing a
+ * provider, and so a provider that doesn't set `billingMode` still resolves.
+ */
+/** Default billing mode per provider type. */
+const BILLING_MODE_BY_TYPE = {
+    claude: 'metered-api',
+    'claude-code': 'subscription',
+    openai: 'metered-api',
+    openrouter: 'metered-api',
+    gemini: 'metered-api',
+    'azure-openai': 'metered-api',
+    bedrock: 'metered-api',
+    cognitum: 'metered-capped',
+    ollama: 'local',
+};
+/**
+ * Resolve a provider's billing mode: the instance's own `billingMode` wins,
+ * else the per-type default, else `metered-api` (the safe, cap-requiring
+ * assumption for an unknown provider).
+ */
+export function resolveBillingMode(provider) {
+    return provider.billingMode ?? BILLING_MODE_BY_TYPE[provider.type] ?? 'metered-api';
+}
+/** Resolve a billing mode from a bare provider type. */
+export function billingModeForType(type) {
+    return BILLING_MODE_BY_TYPE[type] ?? 'metered-api';
+}
+/**
+ * One-line notice shown at startup / in `aqe health` describing how the
+ * active provider bills, so a user is never surprised (issue #557). Returns
+ * `undefined` for `local` (nothing to warn about).
+ */
+export function billingNotice(provider, mode) {
+    switch (mode) {
+        case 'metered-api':
+            return (`⚠️  LLM provider "${provider}" bills a pay-per-token API key (not your Claude ` +
+                `subscription) and has no server-side spend cap. Set a budget with ` +
+                `--max-budget-usd / AQE_MAX_BUDGET_USD, or use AQE_LLM_PROVIDER=claude-code ` +
+                `to run on your Claude Code subscription instead.`);
+        case 'metered-capped':
+            return (`ℹ️  LLM provider "${provider}" bills per-token but enforces a server-side ` +
+                `hard spend cap; it will pause at the cap rather than overspend.`);
+        case 'subscription':
+            return (`ℹ️  LLM provider "${provider}" runs on your Claude Code subscription ` +
+                `(shared plan usage). Worst case is hitting your plan's rate limit and pausing — ` +
+                `no per-token API charges.`);
+        case 'local':
+            return undefined;
+    }
+}
+//# sourceMappingURL=billing-modes.js.map

package/dist/shared/llm/cost-tracker.js

@@ -176,12 +176,14 @@ export class CostTracker {
         const relevantRecords = this.records.filter((r) => r.timestamp >= periodStart && r.timestamp <= periodEnd);
         const byProvider = {
             claude: 0,
+            'claude-code': 0,
             openai: 0,
             ollama: 0,
             openrouter: 0,
             bedrock: 0,
             'azure-openai': 0,
             gemini: 0,
+            cognitum: 0,
         };
         const byModel = {};
         let totalCost = 0;

package/dist/shared/llm/interfaces.d.ts

@@ -11,7 +11,7 @@
 /**
  * Supported LLM provider types
  */
-export type LLMProviderType = 'claude' | 'openai' | 'ollama' | 'openrouter' | 'bedrock' | 'azure-openai' | 'gemini';
+export type LLMProviderType = 'claude' | 'claude-code' | 'openai' | 'ollama' | 'openrouter' | 'bedrock' | 'azure-openai' | 'gemini' | 'cognitum';
 /**
  * Message role in a conversation
  */
@@ -35,6 +35,25 @@ export interface TokenUsage {
     /** ADR-088: tokens served from the prompt cache this request (billed ~0.1x input rate) */
     cacheReadTokens?: number;
 }
+/**
+ * How a provider bills for usage (ADR-123).
+ *
+ * - `metered-api`: pay-per-token against an API key with no server-side cap
+ *   (Anthropic API, OpenAI, OpenRouter, Gemini, Azure, Bedrock). Unbounded
+ *   spend — relies on AQE's local enforced budget.
+ * - `metered-capped`: pay-per-token but the provider enforces its own hard
+ *   spend cap server-side (Cognitum `hardCapUsd`). Worst case: provider pauses.
+ * - `subscription`: draws from a Pro/Max plan's shared usage allowance
+ *   (claude-code provider). Worst case: hit the plan rate limit and pause.
+ * - `local`: on-device compute, no monetary cost (Ollama, ONNX).
+ */
+export type BillingMode = 'metered-api' | 'metered-capped' | 'subscription' | 'local';
+/**
+ * Where a request's cost figure came from (ADR-123). Provider-reported
+ * receipts (e.g. Cognitum's `x_cognitum.price_usd`) are authoritative and
+ * preferred over locally computed price-table estimates.
+ */
+export type CostSource = 'provider-receipt' | 'local-estimate';
 /**
  * Cost information for a request
  */
@@ -43,6 +62,11 @@ export interface CostInfo {
     outputCost: number;
     totalCost: number;
     currency: 'USD';
+    /**
+     * ADR-123: provenance of `totalCost`. Absent is treated as
+     * `local-estimate` for backward compatibility.
+     */
+    source?: CostSource;
 }
 /**
  * LLM generation response
@@ -237,6 +261,25 @@ export interface BedrockConfig extends LLMConfig {
     /** Inference profile ARN (for cross-region inference) */
     inferenceProfileArn?: string;
 }
+/**
+ * Claude Code (subscription) provider configuration (ADR-123).
+ * Runs `claude -p` on the user's Pro/Max subscription instead of an API key.
+ */
+export interface ClaudeCodeConfig extends LLMConfig {
+    /** Path to the `claude` binary (default: 'claude' on PATH). */
+    binaryPath?: string;
+    /** Max concurrent `claude -p` subprocesses. */
+    maxConcurrency?: number;
+    /** Tools to disallow in the headless session (safety). */
+    disallowedTools?: string[];
+}
+/**
+ * Cognitum provider configuration (ADR-123). OpenAI-compatible gateway with
+ * per-request cost receipts and a server-side hard spend cap.
+ */
+export interface CognitumConfig extends LLMConfig {
+    model: 'cognitum-auto' | 'cognitum-low' | 'cognitum-mid' | 'cognitum-high' | string;
+}
 /**
  * Provider manager configuration
  */
@@ -250,19 +293,28 @@ export interface ProviderManagerConfig {
     /** Provider-specific configurations (ADR-043: All 7 providers) */
     providers: {
         claude?: ClaudeConfig;
+        'claude-code'?: ClaudeCodeConfig;
         openai?: OpenAIConfig;
         ollama?: OllamaConfig;
         openrouter?: OpenRouterConfig;
         gemini?: GeminiConfig;
         'azure-openai'?: AzureOpenAIConfig;
         bedrock?: BedrockConfig;
+        cognitum?: CognitumConfig;
     };
     /** Global settings */
     global?: {
-        /** Max total cost per hour in USD */
+        /** Max total cost per hour in USD (ADR-123: enforced cross-process) */
         maxCostPerHour?: number;
-        /** Max total cost per day in USD */
+        /** Max total cost per day in USD (ADR-123: enforced cross-process) */
         maxCostPerDay?: number;
+        /**
+         * ADR-123: max spend for a single run/process in USD. Set via
+         * `--max-budget-usd` or `AQE_MAX_BUDGET_USD`. Enforced against this
+         * process's cumulative spend, so it caps one invocation regardless of the
+         * shared hourly/daily ledger.
+         */
+        maxCostPerRun?: number;
         /** Enable cost tracking */
         enableCostTracking?: boolean;
         /** Enable metrics collection */
@@ -339,6 +391,12 @@ export interface LLMProvider {
     readonly type: LLMProviderType;
     /** Provider display name */
     readonly name: string;
+    /**
+     * ADR-123: how this provider bills. Optional for backward compatibility
+     * with existing/mock implementations; when absent, callers resolve it from
+     * the provider type via `resolveBillingMode()`.
+     */
+    readonly billingMode?: BillingMode;
     /** Check if provider is available and configured */
     isAvailable(): Promise<boolean>;
     /** Health check with latency measurement */

package/dist/shared/llm/provider-manager.d.ts

@@ -11,6 +11,7 @@
  */
 import { LLMProvider, LLMProviderType, ProviderManagerConfig, ProviderMetrics, Message, GenerateOptions, EmbedOptions, CompleteOptions, LLMResponse, EmbeddingResponse, CompletionResponse, HealthCheckResult, CircuitBreakerConfig, LLMCacheConfig } from './interfaces';
 import { CostTracker } from './cost-tracker';
+import { type SpendLedger } from './spend-ledger';
 /**
  * Default provider manager configuration
  */
@@ -28,15 +29,48 @@ export declare class ProviderManager {
     private metrics;
     private roundRobinIndex;
     private initialized;
+    /** ADR-123: cross-process spend ledger (memory.db-backed by default). */
+    private spendLedger?;
+    private injectedLedger?;
+    /** ADR-123: per-run cap in USD (from AQE_MAX_BUDGET_USD or global.maxCostPerRun). */
+    private maxCostPerRun?;
+    private billingNoticeShown;
     constructor(config?: Partial<ProviderManagerConfig>, options?: {
         circuitBreakerConfig?: Partial<CircuitBreakerConfig>;
         cacheConfig?: Partial<LLMCacheConfig>;
         costTracker?: CostTracker;
+        /** ADR-123: inject a ledger (tests / kernel with an open DB handle). */
+        spendLedger?: SpendLedger;
     });
     /**
      * Initialize the provider manager
      */
     initialize(): Promise<void>;
+    /** ADR-123: whether any spend cap is configured. */
+    private budgetConfigured;
+    /**
+     * ADR-123: print a one-line notice describing how the primary provider bills,
+     * once per manager, unless silenced with AQE_LLM_NO_BILLING_NOTICE=1.
+     */
+    private emitBillingNotice;
+    /**
+     * ADR-123: throw COST_LIMIT_EXCEEDED before a call that would breach a
+     * configured budget. Estimate is conservative: prompt tokens from input
+     * length, completion tokens from the requested `maxTokens`. Local providers
+     * ($0) never trip a cap.
+     */
+    private enforceBudget;
+    /** ADR-123: persist a completed charge to the cross-process ledger. */
+    private recordSpend;
+    /**
+     * ADR-123: public budget gate for callers that execute providers WITHOUT
+     * going through `generate()`/`complete()` — notably HybridRouter, which is
+     * the primary QE domain/fleet execution path. Throws COST_LIMIT_EXCEEDED
+     * when a configured cap would be breached; a no-op when no budget is set.
+     */
+    assertWithinBudget(input: string | Message[], options?: GenerateOptions | CompleteOptions): void;
+    /** ADR-123: public spend recorder for those same bypassing callers. */
+    recordResponseSpend(response: LLMResponse): void;
     /**
      * Generate text using the best available provider
      */

package/dist/shared/llm/provider-manager.js

@@ -13,8 +13,12 @@ import { createLLMError, } from './interfaces';
 import { secureRandomInt } from '../utils/crypto-random.js';
 import { CircuitBreakerManager } from './circuit-breaker';
 import { LLMResponseCache } from './cache';
-import { getGlobalCostTracker } from './cost-tracker';
+import { CostTracker, getGlobalCostTracker } from './cost-tracker';
+import { createDefaultSpendLedger, InMemorySpendLedger, } from './spend-ledger';
+import { resolveBillingMode, billingNotice } from './billing-modes';
 import { ClaudeProvider } from './providers/claude';
+import { ClaudeCodeProvider } from './providers/claude-code';
+import { CognitumProvider } from './providers/cognitum';
 import { OpenAIProvider } from './providers/openai';
 import { OllamaProvider } from './providers/ollama';
 import { OpenRouterProvider } from './providers/openrouter';
@@ -48,11 +52,23 @@ export class ProviderManager {
     metrics = new Map();
     roundRobinIndex = 0;
     initialized = false;
+    /** ADR-123: cross-process spend ledger (memory.db-backed by default). */
+    spendLedger;
+    injectedLedger;
+    /** ADR-123: per-run cap in USD (from AQE_MAX_BUDGET_USD or global.maxCostPerRun). */
+    maxCostPerRun;
+    billingNoticeShown = false;
     constructor(config = {}, options) {
         this.config = { ...DEFAULT_PROVIDER_MANAGER_CONFIG, ...config };
         this.circuitBreakers = new CircuitBreakerManager(options?.circuitBreakerConfig);
         this.cache = new LLMResponseCache(options?.cacheConfig);
         this.costTracker = options?.costTracker ?? getGlobalCostTracker();
+        this.injectedLedger = options?.spendLedger;
+        // AQE_MAX_BUDGET_USD env overrides an unset per-run cap.
+        const envRun = Number.parseFloat(process.env.AQE_MAX_BUDGET_USD ?? '');
+        this.maxCostPerRun =
+            this.config.global?.maxCostPerRun ??
+                (Number.isFinite(envRun) && envRun > 0 ? envRun : undefined);
     }
     /**
      * Initialize the provider manager
@@ -67,8 +83,118 @@ export class ProviderManager {
         for (const type of this.providers.keys()) {
             this.initializeMetrics(type);
         }
+        // ADR-123: resolve the spend ledger only when a budget is actually
+        // configured — no DB work for callers who never set a cap.
+        if (this.budgetConfigured()) {
+            this.spendLedger =
+                this.injectedLedger ??
+                    (await createDefaultSpendLedger().catch(() => new InMemorySpendLedger()));
+        }
+        this.emitBillingNotice();
         this.initialized = true;
     }
+    /** ADR-123: whether any spend cap is configured. */
+    budgetConfigured() {
+        const g = this.config.global;
+        return Boolean(this.maxCostPerRun ||
+            (g?.maxCostPerHour && g.maxCostPerHour > 0) ||
+            (g?.maxCostPerDay && g.maxCostPerDay > 0));
+    }
+    /**
+     * ADR-123: print a one-line notice describing how the primary provider bills,
+     * once per manager, unless silenced with AQE_LLM_NO_BILLING_NOTICE=1.
+     */
+    emitBillingNotice() {
+        if (this.billingNoticeShown)
+            return;
+        if ((process.env.AQE_LLM_NO_BILLING_NOTICE ?? '') === '1')
+            return;
+        const primary = this.providers.get(this.config.primary);
+        if (!primary)
+            return;
+        const mode = resolveBillingMode(primary);
+        const notice = billingNotice(primary.type, mode);
+        if (notice) {
+            // eslint-disable-next-line no-console
+            console.error(notice);
+        }
+        this.billingNoticeShown = true;
+    }
+    /**
+     * ADR-123: throw COST_LIMIT_EXCEEDED before a call that would breach a
+     * configured budget. Estimate is conservative: prompt tokens from input
+     * length, completion tokens from the requested `maxTokens`. Local providers
+     * ($0) never trip a cap.
+     */
+    enforceBudget(input, options) {
+        if (!this.budgetConfigured() || !this.spendLedger)
+            return;
+        // Resolve the concrete model that will actually be billed: the caller's
+        // override, else the primary provider's configured model. `config.primary`
+        // is a provider *type*, not a model id, so it can't be priced directly.
+        const model = options?.model ??
+            this.providers.get(this.config.primary)?.getConfig().model ??
+            this.config.primary;
+        const inputStr = typeof input === 'string' ? input : JSON.stringify(input);
+        const estPromptTokens = Math.ceil(inputStr.length / 4);
+        const estCompletionTokens = options?.maxTokens ?? 4096;
+        const estCost = this.costTracker.estimateCost(model, estPromptTokens, estCompletionTokens).totalCost;
+        // Free/local models can't breach a spend cap.
+        if (estCost === 0)
+            return;
+        const g = this.config.global;
+        const checks = [
+            {
+                limit: this.maxCostPerRun,
+                spent: this.costTracker.getCurrentCost('all'),
+                label: 'per-run',
+            },
+            {
+                limit: g?.maxCostPerHour,
+                spent: this.spendLedger.spentSince(3_600_000),
+                label: 'hourly',
+            },
+            {
+                limit: g?.maxCostPerDay,
+                spent: this.spendLedger.spentSince(86_400_000),
+                label: 'daily',
+            },
+        ];
+        for (const { limit, spent, label } of checks) {
+            if (limit && limit > 0 && spent + estCost > limit) {
+                throw createLLMError(`LLM ${label} budget exceeded: $${spent.toFixed(4)} spent + ` +
+                    `$${estCost.toFixed(4)} estimated > $${limit.toFixed(2)} cap. ` +
+                    `Raise --max-budget-usd / maxCost* or switch to a local/subscription provider.`, 'COST_LIMIT_EXCEEDED', { retryable: false });
+            }
+        }
+    }
+    /** ADR-123: persist a completed charge to the cross-process ledger. */
+    recordSpend(response) {
+        if (!this.spendLedger)
+            return;
+        this.spendLedger.record({
+            provider: response.provider,
+            model: response.model,
+            costUsd: response.cost.totalCost,
+            costSource: response.cost.source ?? 'local-estimate',
+            promptTokens: response.usage.promptTokens,
+            completionTokens: response.usage.completionTokens,
+            requestId: response.requestId,
+        });
+    }
+    /**
+     * ADR-123: public budget gate for callers that execute providers WITHOUT
+     * going through `generate()`/`complete()` — notably HybridRouter, which is
+     * the primary QE domain/fleet execution path. Throws COST_LIMIT_EXCEEDED
+     * when a configured cap would be breached; a no-op when no budget is set.
+     */
+    assertWithinBudget(input, options) {
+        this.enforceBudget(input, options);
+    }
+    /** ADR-123: public spend recorder for those same bypassing callers. */
+    recordResponseSpend(response) {
+        this.recordSpend(response);
+    }
     /**
      * Generate text using the best available provider
      */
@@ -87,6 +213,8 @@ export class ProviderManager {
                 return { ...cached, cached: true };
             }
         }
+        // ADR-123: enforce budget before spending anything.
+        this.enforceBudget(input, options);
         // Select provider and execute with failover
         const response = await this.executeWithFailover('generate', async (provider) => provider.generate(input, options), options?.preferredProvider);
         // Cache the response
@@ -99,8 +227,9 @@ export class ProviderManager {
                 systemPrompt: options?.systemPrompt,
             });
         }
-        // Track cost
+        // Track cost (in-process) and persist to the cross-process ledger.
         this.costTracker.recordUsage(response.provider, response.model, response.usage, response.requestId);
+        this.recordSpend(response);
         return response;
     }
     /**
@@ -116,7 +245,8 @@ export class ProviderManager {
             }
         }
         // For embeddings, prefer providers that support them
-        const embeddingProviders = ['openai', 'ollama'];
+        // ADR-123: cognitum exposes /v1/embeddings, so it can serve embeddings too.
+        const embeddingProviders = ['openai', 'ollama', 'cognitum'];
         const response = await this.executeWithFailover('embed', async (provider) => provider.embed(text, options), embeddingProviders.find((p) => this.providers.has(p)));
         // Cache the response
         if (!options?.skipCache) {
@@ -140,6 +270,8 @@ export class ProviderManager {
                 return { ...cached, cached: true };
             }
         }
+        // ADR-123: enforce budget before spending anything.
+        this.enforceBudget(prompt, options);
         const response = await this.executeWithFailover('complete', async (provider) => provider.complete(prompt, options));
         // Cache the response
         if (!options?.skipCache) {
@@ -149,6 +281,19 @@ export class ProviderManager {
                 maxTokens: options?.maxTokens,
             });
         }
+        // ADR-123: persist to the cross-process ledger (completion has usage too).
+        this.costTracker.recordUsage(response.provider, response.model, response.usage, `complete-${response.model}-${Date.now()}`);
+        this.recordSpend({
+            content: response.completion,
+            model: response.model,
+            provider: response.provider,
+            usage: response.usage,
+            cost: CostTracker.calculateCost(response.model, response.usage),
+            latencyMs: response.latencyMs,
+            finishReason: 'stop',
+            cached: response.cached,
+            requestId: `complete-${response.model}-${Date.now()}`,
+        });
         return response;
     }
     /**
@@ -270,6 +415,10 @@ export class ProviderManager {
         switch (type) {
             case 'claude':
                 return new ClaudeProvider(this.config.providers.claude);
+            case 'claude-code':
+                return new ClaudeCodeProvider(this.config.providers['claude-code']);
+            case 'cognitum':
+                return new CognitumProvider(this.config.providers.cognitum);
             case 'openai':
                 return new OpenAIProvider(this.config.providers.openai);
             case 'ollama':

package/dist/shared/llm/providers/claude-code.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Agentic QE v3 — Claude Code (subscription) Provider (ADR-123, issue #557)
+ *
+ * Runs QE analysis on the user's Claude Pro/Max subscription by shelling out
+ * to the Claude Code CLI (`claude -p --output-format json`) instead of calling
+ * `api.anthropic.com` with a paid API key. The CLI authenticates with the
+ * user's existing OAuth login and draws from the subscription's shared usage
+ * allowance, so the worst case is "hit the plan rate limit and pause" rather
+ * than a surprise per-token bill.
+ *
+ * LOAD-BEARING: the child process env has ANTHROPIC_API_KEY / CLAUDE_API_KEY /
+ * ANTHROPIC_AUTH_TOKEN stripped. If any is present, the CLI silently reverts
+ * to API-key billing and this provider would be a lie. `parity` test coverage
+ * asserts the strip.
+ */
+import { LLMProvider, LLMProviderType, BillingMode, ClaudeCodeConfig, Message, GenerateOptions, EmbedOptions, CompleteOptions, LLMResponse, EmbeddingResponse, CompletionResponse, HealthCheckResult } from '../interfaces';
+export type { ClaudeCodeConfig };
+/** Env vars whose presence flips the CLI from subscription to API billing. */
+export declare const API_BILLING_ENV_VARS: readonly ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
+export declare const DEFAULT_CLAUDE_CODE_CONFIG: ClaudeCodeConfig;
+export declare class ClaudeCodeProvider implements LLMProvider {
+    readonly type: LLMProviderType;
+    readonly name: string;
+    readonly billingMode: BillingMode;
+    private config;
+    private requestId;
+    private availabilityCache?;
+    private active;
+    private readonly queue;
+    constructor(config?: Partial<ClaudeCodeConfig>);
+    isAvailable(): Promise<boolean>;
+    healthCheck(): Promise<HealthCheckResult>;
+    generate(input: string | Message[], options?: GenerateOptions): Promise<LLMResponse>;
+    embed(_text: string, _options?: EmbedOptions): Promise<EmbeddingResponse>;
+    complete(prompt: string, options?: CompleteOptions): Promise<CompletionResponse>;
+    getConfig(): ClaudeCodeConfig;
+    getSupportedModels(): string[];
+    getCostPerToken(): {
+        input: number;
+        output: number;
+    };
+    dispose(): Promise<void>;
+    /** Map an AQE canonical/model id to a CLI alias the `claude` binary accepts. */
+    private toCliModel;
+    private flatten;
+    private mapFinishReason;
+    private classifyError;
+    /**
+     * Build the child env with API-billing keys stripped (LOAD-BEARING).
+     * Exported logic tested by parity/env-strip tests.
+     */
+    static childEnv(base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+    private runProcess;
+    /** Simple semaphore so we don't spawn unbounded `claude` subprocesses. */
+    private withConcurrency;
+}
+//# sourceMappingURL=claude-code.d.ts.map