auditor-lambda 0.3.33 → 0.3.36

package/dist/cli.js

@@ -28,11 +28,11 @@ import { buildAuditCodeHandoff, writeAuditCodeHandoffArtifacts, } from "./superv
 import { getSessionConfigPath, loadSessionConfig, readSessionConfigFile, } from "./supervisor/sessionConfig.js";
 import { clearDispatchFiles, buildRunId, ensureSupervisorDirs, getRunPaths, writeDispatchBatchFiles, writeWorkerTaskFiles, } from "./io/runArtifacts.js";
 import { renderWorkerPrompt } from "./prompts/renderWorkerPrompt.js";
-import { buildReviewPackets, orderTasksForPacketReview, } from "./orchestrator/reviewPackets.js";
+import { buildReviewPackets, orderTasksForPacketReview, estimateTaskGroupTokens, } from "./orchestrator/reviewPackets.js";
 import { buildFileAnchorSummary, } from "./orchestrator/fileAnchors.js";
 import { LOCAL_SUBPROCESS_PROVIDER_NAME } from "./providers/constants.js";
 import { runAuditCodeMcpServer } from "./mcp/server.js";
-import { scheduleWave, buildProviderModelKey, readQuotaState, recordWaveOutcome, resolveLimits, resolveHostActiveSubagentLimit, probeProvider, computeMaxSafeConcurrency, getQuotaStatePath, } from "./quota/index.js";
+import { scheduleWave, buildProviderModelKey, readQuotaState, recordWaveOutcome, resolveLimits, resolveHostActiveSubagentLimit, probeProvider, computeMaxSafeConcurrency, getQuotaStatePath, detectRateLimitError, computeCooldownUntil, runSlidingWindow, LearnedQuotaSource, CompositeQuotaSource, } from "./quota/index.js";
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const ADVANCE_AUDIT_CONTRACT_VERSION = "audit-code/v1alpha1";
 const WORKER_RESULT_CONTRACT_VERSION = "audit-code-worker-result/v1alpha1";
@@ -101,7 +101,7 @@ export function resolveHostDispatchCapability(options) {
     if (options.sessionConfig.host_can_dispatch_subagents !== undefined) {
         return options.sessionConfig.host_can_dispatch_subagents;
     }
-    return optionalBooleanEnv((options.env ?? process.env).AUDIT_CODE_HOST_CAN_DISPATCH) ?? false;
+    return optionalBooleanEnv((options.env ?? process.env).AUDIT_CODE_HOST_CAN_DISPATCH) ?? true;
 }
 function toBase64Url(value) {
     return Buffer.from(value, "utf8").toString("base64url");
@@ -228,18 +228,6 @@ function getQuotaProbeMode(argv, sessionConfig) {
         return raw;
     return "auto";
 }
-function detectRateLimitError(errorText) {
-    const lower = errorText.toLowerCase();
-    return lower.includes("429") || lower.includes("rate limit") || lower.includes("rate_limit");
-}
-function defaultCooldownUntil(resetAtHeader) {
-    if (resetAtHeader) {
-        const t = new Date(resetAtHeader).getTime();
-        if (!Number.isNaN(t))
-            return new Date(t).toISOString();
-    }
-    return new Date(Date.now() + 60_000).toISOString();
-}
 function resolveRunProviderName(argv, sessionConfig) {
     return resolveFreshSessionProviderName(getExplicitProvider(argv), sessionConfig);
 }
@@ -1294,12 +1282,25 @@ async function cmdRunToCompletion(argv) {
     let pendingRuntimeUpdatesPath = getFlag(argv, "--updates");
     let pendingExternalAnalyzerPath = getFlag(argv, "--external-analyzer-results");
     let runCount = 0;
+    let deepeningCycles = 0;
+    const MAX_DEEPENING_CYCLES = 3;
     let anyProgress = false;
     let lastResult = null;
     const artifactsWritten = new Set();
     while (runCount < maxRuns) {
         const bundle = await loadArtifactBundle(artifactsDir);
         const decision = decideNextStep(bundle);
+        if (decision.selected_executor === "agent" &&
+            bundle.audit_tasks?.some((t) => t.tags?.includes("selective_deepening") &&
+                t.status !== "complete") &&
+            !bundle.audit_tasks?.some((t) => !t.tags?.includes("selective_deepening") &&
+                t.status !== "complete")) {
+            deepeningCycles++;
+            if (deepeningCycles > MAX_DEEPENING_CYCLES) {
+                process.stderr.write(`[audit-code] Reached max deepening cycles (${MAX_DEEPENING_CYCLES}). Stopping to prevent churn.\n`);
+                break;
+            }
+        }
         let preferredExecutor = decision.selected_executor;
         let obligationId = decision.selected_obligation;
         let auditResultsPath;
@@ -1422,11 +1423,15 @@ async function cmdRunToCompletion(argv) {
             const quotaState = await readQuotaState();
             const providerModelKey = buildProviderModelKey(provider.name, hostModel);
             const quotaStateEntry = quotaState.entries[providerModelKey] ?? null;
+            const allCandidateTasks = buildPendingAuditTasks(bundle);
+            const candidateGroups = chunkArray(allCandidateTasks.slice(0, parallelWorkers * agentBatchSize), agentBatchSize);
+            const slotTokenEstimates = candidateGroups.map((g) => estimateTaskGroupTokens(g));
             const waveSchedule = scheduleWave({
                 providerName: resolveFreshSessionProviderName(getExplicitProvider(argv), sessionConfig),
                 sessionConfig,
                 hostModel,
                 requestedConcurrency: parallelWorkers,
+                estimatedSlotTokens: slotTokenEstimates,
                 quotaStateEntry,
             });
             const waveSize = waveSchedule.wave_size;
@@ -1438,8 +1443,7 @@ async function cmdRunToCompletion(argv) {
                     await new Promise((r) => setTimeout(r, cappedWait));
                 }
             }
-            const allPendingTasks = buildPendingAuditTasks(bundle);
-            const taskGroups = chunkArray(allPendingTasks.slice(0, waveSize * agentBatchSize), agentBatchSize);
+            const taskGroups = candidateGroups.slice(0, waveSize);
             const workerSlots = [];
             for (const rawGroup of taskGroups) {
                 const group = await addFileLineCountHints(root, rawGroup);
@@ -1478,7 +1482,7 @@ async function cmdRunToCompletion(argv) {
                 pending_audit_tasks_path: slot.pendingTasksPath,
             })), workerSlots.flatMap((slot) => slot.group));
             const parallelStartedAt = new Date().toISOString();
-            const launchResults = await Promise.allSettled(workerSlots.map((slot) => provider.launch({
+            const { results: launchResults } = await runSlidingWindow(workerSlots.map((slot) => () => provider.launch({
                 repoRoot: root,
                 runId: slot.runId,
                 obligationId,
@@ -1489,7 +1493,7 @@ async function cmdRunToCompletion(argv) {
                 stderrPath: slot.paths.stderrPath,
                 uiMode,
                 timeoutMs,
-            })));
+            })), waveSize);
             const launchErrorsByRunId = new Map();
             for (let index = 0; index < launchResults.length; index++) {
                 const outcome = launchResults[index];
@@ -1601,12 +1605,14 @@ async function cmdRunToCompletion(argv) {
             }
             // Record outcome for adaptive learning (best-effort — never blocks dispatch)
             {
-                const hasRateLimit = batchErrors.some(detectRateLimitError);
+                const rateLimitResults = batchErrors.map((e) => detectRateLimitError(e));
+                const rateLimitHit = rateLimitResults.find((r) => r.isRateLimited);
+                const retryAfterMs = rateLimitHit?.retryAfterMs ?? null;
                 await recordWaveOutcome(providerModelKey, {
                     concurrency: workerSlots.length,
-                    estimated_tokens: waveSize * agentBatchSize * 900,
-                    outcome: hasRateLimit ? "rate_limited" : batchErrors.length > 0 ? "timeout" : "success",
-                    cooldown_until: hasRateLimit ? defaultCooldownUntil(null) : null,
+                    estimated_tokens: slotTokenEstimates.slice(0, workerSlots.length).reduce((a, b) => a + b, 0),
+                    outcome: rateLimitHit ? "rate_limited" : batchErrors.length > 0 ? "timeout" : "success",
+                    cooldown_until: rateLimitHit ? computeCooldownUntil(retryAfterMs) : null,
                 }, sessionConfig.quota?.empirical_half_life_hours ?? 24).catch(() => undefined);
             }
             if (batchErrors.length > 0) {
@@ -2455,12 +2461,10 @@ async function prepareDispatchArtifacts(params) {
     });
     // Compute and write dispatch-quota.json
     const hostModel = params.hostModel ?? null;
-    const avgPacketTokens = plan.length > 0
-        ? Math.floor(plan.reduce((s, p) => s + p.complexity.estimated_tokens, 0) / plan.length)
-        : 0;
+    const perPacketTokens = plan.map((p) => p.complexity.estimated_tokens);
     const quotaProviderName = resolveFreshSessionProviderName(undefined, sessionConfig);
     const quotaProviderKey = buildProviderModelKey(quotaProviderName, hostModel);
-    const quotaState = await readQuotaState().catch(() => ({ version: 1, entries: {} }));
+    const quotaState = await readQuotaState().catch(() => ({ version: 2, entries: {} }));
     const quotaStateEntry = quotaState.entries[quotaProviderKey] ?? null;
     const hostConcurrencyLimit = resolveHostActiveSubagentLimit({
         explicitLimit: params.hostActiveSubagentLimit,
@@ -2471,12 +2475,12 @@ async function prepareDispatchArtifacts(params) {
         sessionConfig,
         hostModel,
         requestedConcurrency: sessionConfig.parallel_workers ?? plan.length,
-        estimatedPacketTokens: avgPacketTokens,
+        estimatedSlotTokens: perPacketTokens,
         quotaStateEntry,
         hostConcurrencyLimit,
     });
     const dispatchQuota = {
-        contract_version: "audit-code-dispatch-quota/v1alpha1",
+        contract_version: "audit-code-dispatch-quota/v1alpha2",
         run_id: runId,
         model: hostModel,
         resolved_limits: waveSchedule.resolved_limits,
@@ -2486,6 +2490,8 @@ async function prepareDispatchArtifacts(params) {
         wave_size: waveSchedule.wave_size,
         estimated_wave_tokens: waveSchedule.estimated_wave_tokens,
         cooldown_until: waveSchedule.cooldown_until,
+        quota_source_snapshot: waveSchedule.quota_source_snapshot ?? null,
+        backoff_state: null,
     };
     const dispatchQuotaPath = join(runDir, "dispatch-quota.json");
     await writeJsonFile(dispatchQuotaPath, dispatchQuota);
@@ -3212,13 +3218,15 @@ async function cmdQuota(argv) {
     const providerModelKey = buildProviderModelKey(providerName, hostModel);
     const { limits, source, confidence } = resolveLimits({ providerName, sessionConfig, hostModel });
     const probeResult = await probeProvider(providerName, probeMode);
-    const quotaState = await readQuotaState().catch(() => ({ version: 1, entries: {} }));
+    const quotaState = await readQuotaState().catch(() => ({ version: 2, entries: {} }));
     const quotaStateEntry = quotaState.entries[providerModelKey] ?? null;
     const halfLifeHours = sessionConfig.quota?.empirical_half_life_hours ?? 24;
     const hostConcurrencyLimit = resolveHostActiveSubagentLimit({
         explicitLimit: getHostMaxActiveSubagents(argv),
         sessionConfig,
     });
+    const quotaSource = new CompositeQuotaSource([new LearnedQuotaSource(halfLifeHours)]);
+    const quotaSourceSnapshot = await quotaSource.queryCurrentUsage(providerModelKey).catch(() => null);
     const waveSchedule = scheduleWave({
         providerName,
         sessionConfig,
@@ -3226,6 +3234,7 @@ async function cmdQuota(argv) {
         requestedConcurrency: sessionConfig.parallel_workers ?? 1,
         quotaStateEntry,
         hostConcurrencyLimit,
+        quotaSourceSnapshot,
     });
     console.log(JSON.stringify({
         provider: providerName,
@@ -3243,6 +3252,7 @@ async function cmdQuota(argv) {
                 last_429_at: quotaStateEntry.last_429_at,
             }
             : null,
+        quota_source_snapshot: quotaSourceSnapshot,
         wave_schedule: waveSchedule,
         quota_state_path: getQuotaStatePath(),
     }, null, 2));

package/dist/orchestrator/reviewPackets.d.ts

@@ -1,6 +1,9 @@
 import type { AuditTask } from "../types.js";
 import type { AuditPlanMetrics, ReviewPacket } from "../types/reviewPlanning.js";
 import type { GraphBundle } from "../types/graph.js";
+export declare const ESTIMATED_TOKENS_PER_LINE = 4;
+export declare const ESTIMATED_PACKET_PROMPT_TOKENS = 900;
+export declare function estimateTaskGroupTokens(tasks: AuditTask[]): number;
 export interface BuildReviewPacketOptions {
     graphBundle?: GraphBundle;
     lineIndex?: Record<string, number>;

package/dist/orchestrator/reviewPackets.js

@@ -2,8 +2,19 @@ import { createHash } from "node:crypto";
 import { LENS_ORDER } from "./unitBuilder.js";
 const DEFAULT_MAX_TASKS_PER_PACKET = 0;
 const DEFAULT_TARGET_PACKET_LINES = 8000;
-const ESTIMATED_TOKENS_PER_LINE = 4;
-const ESTIMATED_PACKET_PROMPT_TOKENS = 900;
+export const ESTIMATED_TOKENS_PER_LINE = 4;
+export const ESTIMATED_PACKET_PROMPT_TOKENS = 900;
+export function estimateTaskGroupTokens(tasks) {
+    let totalLines = 0;
+    for (const task of tasks) {
+        if (task.file_line_counts) {
+            for (const count of Object.values(task.file_line_counts)) {
+                totalLines += count;
+            }
+        }
+    }
+    return ESTIMATED_PACKET_PROMPT_TOKENS + totalLines * ESTIMATED_TOKENS_PER_LINE;
+}
 const PACKET_EXPANSION_MIN_CONFIDENCE = 0.65;
 const HIGH_FAN_DEGREE_THRESHOLD = 12;
 const HIGH_FAN_EXPANSION_CONFIDENCE = 0.99;

package/dist/orchestrator/selectiveDeepening.d.ts

@@ -9,10 +9,12 @@ export interface BuildSelectiveDeepeningTaskOptions {
     runtimeValidationReport?: RuntimeValidationReport;
     externalAnalyzerResults?: ExternalAnalyzerResults;
     maxTasks?: number;
+    maxTotalDeepeningTasks?: number;
 }
 export declare function buildSelectiveDeepeningTasks(options: BuildSelectiveDeepeningTaskOptions): AuditTask[];
 export declare const selectiveDeepeningTestUtils: {
     DEEPENING_TAG: string;
     LENS_VERIFICATION_TAG: string;
     LENS_VERIFICATION_FOLLOWUP_TAG: string;
+    DEFAULT_MAX_TOTAL_DEEPENING_TASKS: number;
 };

package/dist/orchestrator/selectiveDeepening.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 const DEFAULT_MAX_DEEPENING_TASKS = 6;
+const DEFAULT_MAX_TOTAL_DEEPENING_TASKS = 24;
 const DEEPENING_TAG = "selective_deepening";
 const LENS_VERIFICATION_TAG = "lens_verification";
 const LENS_VERIFICATION_FOLLOWUP_TAG = "lens_verification_followup";
@@ -649,9 +650,16 @@ export function buildSelectiveDeepeningTasks(options) {
     const existingTasks = options.existingTasks ?? [];
     const existingIds = new Set(taskById.keys());
     const maxTasks = options.maxTasks ?? DEFAULT_MAX_DEEPENING_TASKS;
+    const maxTotalDeepeningTasks = options.maxTotalDeepeningTasks ?? DEFAULT_MAX_TOTAL_DEEPENING_TASKS;
+    const existingDeepeningCount = existingTasks.filter((task) => isDeepeningTask(task)).length;
+    if (existingDeepeningCount >= maxTotalDeepeningTasks) {
+        return [];
+    }
+    const remainingBudget = maxTotalDeepeningTasks - existingDeepeningCount;
+    const effectiveMax = Math.min(maxTasks, remainingBudget);
     const created = [];
     function pushIfNew(task) {
-        if (created.length >= maxTasks || existingIds.has(task.task_id)) {
+        if (created.length >= effectiveMax || existingIds.has(task.task_id)) {
             return;
         }
         existingIds.add(task.task_id);
@@ -748,4 +756,5 @@ export const selectiveDeepeningTestUtils = {
     DEEPENING_TAG,
     LENS_VERIFICATION_TAG,
     LENS_VERIFICATION_FOLLOWUP_TAG,
+    DEFAULT_MAX_TOTAL_DEEPENING_TASKS,
 };

package/dist/orchestrator/state.js

@@ -42,31 +42,16 @@ export function deriveAuditState(bundle) {
         "audit_tasks.json",
         "requeue_tasks.json",
     ], planningReady)));
-    const hasRequiredCoverage = bundle.coverage_matrix?.files.every((f) => f.required_lenses.every((req) => f.completed_lenses.includes(req))) ?? true;
     const completedTaskIds = new Set((bundle.audit_results ?? []).map((result) => result.task_id));
     const hasPendingAuditTasks = bundle.audit_tasks?.some((task) => task.status !== "complete" && !completedTaskIds.has(task.task_id)) ?? false;
-    const hasCompletedTaskStatuses = bundle.audit_tasks?.length
-        ? bundle.audit_tasks.every((task) => task.status === "complete")
-        : false;
-    const hasResultForEveryTask = bundle.audit_tasks?.length && bundle.audit_results
-        ? bundle.audit_tasks.every((task) => bundle.audit_results?.some((result) => result.task_id === task.task_id))
-        : false;
     if (hasPendingAuditTasks) {
         obligations.push(obligation("audit_tasks_completed", "missing"));
     }
-    else if (!hasRequiredCoverage &&
-        !hasCompletedTaskStatuses &&
-        !hasResultForEveryTask &&
-        has(bundle.audit_tasks) &&
-        (bundle.audit_tasks?.length ?? 0) > 0) {
-        obligations.push(obligation("audit_tasks_completed", "missing"));
-    }
-    else if ((hasRequiredCoverage || hasCompletedTaskStatuses || hasResultForEveryTask) &&
-        has(bundle.audit_tasks)) {
+    else if (has(bundle.audit_tasks)) {
         obligations.push(obligation("audit_tasks_completed", "satisfied"));
     }
     obligations.push(obligation("audit_results_ingested", (bundle.audit_tasks?.length ?? 0) === 0 || has(bundle.audit_results)
-        ? "present"
+        ? "satisfied"
         : "missing"));
     const runtimeTasks = bundle.runtime_validation_tasks?.tasks ?? [];
     const runtimeResults = bundle.runtime_validation_report?.results ?? [];

package/dist/providers/opencodeProvider.js

@@ -1,5 +1,24 @@
 import { readFile } from "node:fs/promises";
 import { spawnLoggedCommand } from "./spawnLoggedCommand.js";
+function resolveOpenCodeSpawnCommand(command, args, platform = process.platform, shellCommand = process.env.ComSpec ?? "cmd.exe") {
+    if (platform !== "win32") {
+        return { command, args };
+    }
+    const base = command.replace(/\.(cmd|bat|exe)$/i, "").toLowerCase();
+    if (base === "opencode" || base === "npx" || command.endsWith(".cmd")) {
+        return {
+            command: shellCommand,
+            args: ["/d", "/s", "/c", [command, ...args].map(quoteCmdArg).join(" ")],
+        };
+    }
+    return { command, args };
+}
+function quoteCmdArg(value) {
+    if (/^[A-Za-z0-9_./:=+-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/(["^&|<>%])/g, "^$1")}"`;
+}
 export class OpenCodeProvider {
     name = "opencode";
     config;
@@ -8,8 +27,9 @@ export class OpenCodeProvider {
     }
     async launch(input) {
         const prompt = await readFile(input.promptPath, "utf8");
-        const command = this.config.command ?? "opencode";
-        const args = ["run", prompt, ...(this.config.extra_args ?? [])];
-        return await spawnLoggedCommand(command, args, input);
+        const baseCommand = this.config.command ?? "opencode";
+        const baseArgs = ["run", prompt, ...(this.config.extra_args ?? [])];
+        const resolved = resolveOpenCodeSpawnCommand(baseCommand, baseArgs);
+        return await spawnLoggedCommand(resolved.command, resolved.args, input);
     }
 }

package/dist/providers/spawnLoggedCommand.js

@@ -152,13 +152,8 @@ export async function spawnLoggedCommand(command, args, input, env, options = {}
         });
         spawnedChild.on("error", fail);
         spawnedChild.on("exit", (code, signal) => {
-            if (!timedOut) {
-                return;
-            }
-            childClosed = true;
             closeCode = code;
             closeSignal = signal;
-            maybeSettleFromClose();
         });
         spawnedChild.on("close", (code, signal) => {
             childClosed = true;

package/dist/quota/compositeQuotaSource.d.ts

@@ -0,0 +1,7 @@
+import type { QuotaSource, QuotaUsageSnapshot } from "./quotaSource.js";
+export declare class CompositeQuotaSource implements QuotaSource {
+    readonly name = "composite";
+    private sources;
+    constructor(sources: QuotaSource[]);
+    queryCurrentUsage(providerModelKey: string): Promise<QuotaUsageSnapshot | null>;
+}

package/dist/quota/compositeQuotaSource.js

@@ -0,0 +1,20 @@
+export class CompositeQuotaSource {
+    name = "composite";
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    async queryCurrentUsage(providerModelKey) {
+        for (const source of this.sources) {
+            try {
+                const snapshot = await source.queryCurrentUsage(providerModelKey);
+                if (snapshot)
+                    return snapshot;
+            }
+            catch {
+                // Skip failing sources, try next
+            }
+        }
+        return null;
+    }
+}

package/dist/quota/errorParsers/claudeCodeErrorParser.d.ts

@@ -0,0 +1,6 @@
+import type { RateLimitDetectionResult } from "../errorParsing.js";
+import type { ErrorParser } from "./genericErrorParser.js";
+export declare class ClaudeCodeErrorParser implements ErrorParser {
+    readonly name = "claude-code";
+    parse(text: string): RateLimitDetectionResult;
+}

package/dist/quota/errorParsers/claudeCodeErrorParser.js

@@ -0,0 +1,39 @@
+export class ClaudeCodeErrorParser {
+    name = "claude-code";
+    parse(text) {
+        for (const line of text.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("{"))
+                continue;
+            try {
+                const obj = JSON.parse(trimmed);
+                const level = obj["level"];
+                const type = obj["type"];
+                const message = obj["message"] ?? "";
+                const statusCode = obj["status_code"];
+                if (statusCode === 429 ||
+                    type === "rate_limit_error" ||
+                    (level === "error" && /\brate.?limit/i.test(message))) {
+                    const retryAfter = obj["retry_after"];
+                    const retryAfterMs = obj["retry_after_ms"];
+                    let extractedMs = null;
+                    if (retryAfterMs != null && retryAfterMs > 0) {
+                        extractedMs = retryAfterMs;
+                    }
+                    else if (retryAfter != null && retryAfter > 0) {
+                        extractedMs = retryAfter < 600 ? retryAfter * 1000 : retryAfter;
+                    }
+                    return {
+                        isRateLimited: true,
+                        retryAfterMs: extractedMs,
+                        rawMatch: `claude-code-stderr:${statusCode ?? type ?? "rate_limit"}`,
+                    };
+                }
+            }
+            catch {
+                // Not valid JSON, skip
+            }
+        }
+        return { isRateLimited: false, retryAfterMs: null, rawMatch: null };
+    }
+}

package/dist/quota/errorParsers/genericErrorParser.d.ts

@@ -0,0 +1,9 @@
+import type { RateLimitDetectionResult } from "../errorParsing.js";
+export interface ErrorParser {
+    readonly name: string;
+    parse(text: string): RateLimitDetectionResult;
+}
+export declare class GenericErrorParser implements ErrorParser {
+    readonly name = "generic";
+    parse(text: string): RateLimitDetectionResult;
+}

package/dist/quota/errorParsers/genericErrorParser.js

@@ -0,0 +1,7 @@
+import { detectRateLimitError } from "../errorParsing.js";
+export class GenericErrorParser {
+    name = "generic";
+    parse(text) {
+        return detectRateLimitError(text);
+    }
+}

package/dist/quota/errorParsers/index.d.ts

@@ -0,0 +1,5 @@
+export type { ErrorParser } from "./genericErrorParser.js";
+export { GenericErrorParser } from "./genericErrorParser.js";
+export { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
+import type { ErrorParser } from "./genericErrorParser.js";
+export declare function getErrorParserForProvider(providerName: string): ErrorParser;

package/dist/quota/errorParsers/index.js

@@ -0,0 +1,12 @@
+export { GenericErrorParser } from "./genericErrorParser.js";
+export { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
+import { GenericErrorParser } from "./genericErrorParser.js";
+import { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
+const PROVIDER_PARSERS = {
+    "claude-code": () => new ClaudeCodeErrorParser(),
+};
+const genericParser = new GenericErrorParser();
+export function getErrorParserForProvider(providerName) {
+    const factory = PROVIDER_PARSERS[providerName];
+    return factory ? factory() : genericParser;
+}

package/dist/quota/errorParsing.d.ts

@@ -0,0 +1,7 @@
+export interface RateLimitDetectionResult {
+    isRateLimited: boolean;
+    retryAfterMs: number | null;
+    rawMatch: string | null;
+}
+export declare function detectRateLimitError(text: string): RateLimitDetectionResult;
+export declare function computeCooldownUntil(retryAfterMs: number | null, defaultMs?: number): string;

package/dist/quota/errorParsing.js

@@ -0,0 +1,69 @@
+const RATE_LIMIT_PATTERNS = [
+    /\b429\b/i,
+    /\btoo many requests\b/i,
+    /\brate.?limit/i,
+    /\boverloaded\b/i,
+    /\bresource.?exhausted\b/i,
+    /\bquota.?exceeded\b/i,
+];
+function tryParseJson(text) {
+    const jsonStart = text.indexOf("{");
+    if (jsonStart === -1)
+        return null;
+    try {
+        return JSON.parse(text.slice(jsonStart));
+    }
+    catch {
+        return null;
+    }
+}
+function extractRetryAfterMs(obj) {
+    const headers = obj["headers"];
+    const retryAfter = headers?.["retry-after"] ??
+        headers?.["Retry-After"] ??
+        obj["retry_after"] ??
+        obj["retry_after_ms"];
+    if (retryAfter == null)
+        return null;
+    const val = typeof retryAfter === "string" ? Number(retryAfter) : retryAfter;
+    if (!Number.isFinite(val) || val <= 0)
+        return null;
+    // If the value looks like seconds (< 600), convert to ms
+    return val < 600 ? val * 1000 : val;
+}
+function detectFromJson(text) {
+    const obj = tryParseJson(text);
+    if (!obj)
+        return null;
+    const status = obj["status"];
+    const type = obj["type"];
+    const errorObj = obj["error"];
+    const errorType = errorObj?.["type"];
+    const isRateLimited = status === 429 ||
+        type === "rate_limit_error" ||
+        errorType === "rate_limit_error";
+    if (!isRateLimited)
+        return null;
+    return {
+        isRateLimited: true,
+        retryAfterMs: extractRetryAfterMs(obj),
+        rawMatch: `json:${status === 429 ? "status=429" : `type=${type ?? errorType}`}`,
+    };
+}
+export function detectRateLimitError(text) {
+    const jsonResult = detectFromJson(text);
+    if (jsonResult)
+        return jsonResult;
+    for (const pattern of RATE_LIMIT_PATTERNS) {
+        const match = pattern.exec(text);
+        if (match) {
+            return { isRateLimited: true, retryAfterMs: null, rawMatch: match[0] };
+        }
+    }
+    return { isRateLimited: false, retryAfterMs: null, rawMatch: null };
+}
+const DEFAULT_COOLDOWN_MS = 60_000;
+export function computeCooldownUntil(retryAfterMs, defaultMs = DEFAULT_COOLDOWN_MS) {
+    const ms = retryAfterMs != null && retryAfterMs > 0 ? retryAfterMs : defaultMs;
+    return new Date(Date.now() + ms).toISOString();
+}

package/dist/quota/fileLock.d.ts

@@ -0,0 +1,6 @@
+export declare class FileLockTimeoutError extends Error {
+    constructor(lockPath: string);
+}
+export declare function acquireLock(lockPath: string, timeoutMs?: number): Promise<void>;
+export declare function releaseLock(lockPath: string): Promise<void>;
+export declare function withFileLock<T>(lockPath: string, fn: () => Promise<T>, timeoutMs?: number): Promise<T>;

package/dist/quota/fileLock.js

@@ -0,0 +1,64 @@
+import { open, unlink, stat } from "node:fs/promises";
+const STALE_LOCK_MS = 30_000;
+const RETRY_INTERVAL_MS = 50;
+const DEFAULT_TIMEOUT_MS = 10_000;
+export class FileLockTimeoutError extends Error {
+    constructor(lockPath) {
+        super(`Timed out acquiring lock: ${lockPath}`);
+        this.name = "FileLockTimeoutError";
+    }
+}
+async function isLockStale(lockPath) {
+    try {
+        const info = await stat(lockPath);
+        return Date.now() - info.mtimeMs > STALE_LOCK_MS;
+    }
+    catch {
+        return false;
+    }
+}
+export async function acquireLock(lockPath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            const fd = await open(lockPath, "wx");
+            await fd.close();
+            return;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+        }
+        if (await isLockStale(lockPath)) {
+            try {
+                await unlink(lockPath);
+                continue;
+            }
+            catch {
+                // Another process may have already cleaned it up
+            }
+        }
+        if (Date.now() >= deadline) {
+            throw new FileLockTimeoutError(lockPath);
+        }
+        await new Promise((r) => setTimeout(r, RETRY_INTERVAL_MS));
+    }
+}
+export async function releaseLock(lockPath) {
+    try {
+        await unlink(lockPath);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+}
+export async function withFileLock(lockPath, fn, timeoutMs) {
+    await acquireLock(lockPath, timeoutMs);
+    try {
+        return await fn();
+    }
+    finally {
+        await releaseLock(lockPath);
+    }
+}

package/dist/quota/index.d.ts

@@ -1,9 +1,19 @@
 export { resolveLimits, lookupKnownModel, classifyProvider } from "./limits.js";
 export type { LimitResolutionResult, ResolveLimitsOptions, ProviderType } from "./limits.js";
 export { detectHostActiveSubagentLimit, resolveHostActiveSubagentLimit, } from "./hostLimits.js";
-export { readQuotaState, writeQuotaState, computeMaxSafeConcurrency, recordWaveOutcome, getQuotaStatePath, decayWeight, applyDecayToEntry, } from "./state.js";
+export { readQuotaState, writeQuotaState, computeMaxSafeConcurrency, recordWaveOutcome, getQuotaStatePath, decayWeight, applyDecayToEntry, computeBackoffCooldownMs, computeBackoffFailureWeight, computeRampUpConcurrency, } from "./state.js";
 export { scheduleWave, buildProviderModelKey } from "./scheduler.js";
 export type { ScheduleWaveOptions } from "./scheduler.js";
+export { detectRateLimitError, computeCooldownUntil } from "./errorParsing.js";
+export { acquireLock, releaseLock, withFileLock, FileLockTimeoutError } from "./fileLock.js";
+export { runSlidingWindow } from "./slidingWindow.js";
+export type { SlidingWindowResult } from "./slidingWindow.js";
+export type { RateLimitDetectionResult } from "./errorParsing.js";
 export { probeProvider } from "./probe.js";
 export type { ProbeResult } from "./probe.js";
+export type { QuotaSource, QuotaUsageSnapshot } from "./quotaSource.js";
+export type { ErrorParser } from "./errorParsers/index.js";
+export { GenericErrorParser, ClaudeCodeErrorParser, getErrorParserForProvider } from "./errorParsers/index.js";
+export { LearnedQuotaSource } from "./learnedQuotaSource.js";
+export { CompositeQuotaSource } from "./compositeQuotaSource.js";
 export type { ResolvedLimits, LimitSource, LimitConfidence, HostConcurrencyLimit, HostConcurrencyLimitSource, QuotaState, QuotaStateEntry, ConcurrencyBucket, WaveSchedule, DispatchQuota, ObservedWaveOutcome, } from "./types.js";