auditor-lambda 0.3.37 → 0.3.39

package/dist/orchestrator/designReviewPrompt.js

@@ -0,0 +1,151 @@
+function summarizeUnits(bundle) {
+    const units = bundle.unit_manifest?.units ?? [];
+    if (units.length === 0)
+        return "No units identified.";
+    const lines = units.map((unit) => {
+        const lenses = unit.required_lenses.join(", ") || "none";
+        return `- ${unit.unit_id} (${unit.files.length} files, lenses: ${lenses})`;
+    });
+    return [
+        `${units.length} units:`,
+        ...lines.slice(0, 40),
+        ...(units.length > 40 ? [`  ... and ${units.length - 40} more`] : []),
+    ].join("\n");
+}
+function summarizeGraph(bundle) {
+    const graphs = bundle.graph_bundle?.graphs;
+    if (!graphs)
+        return "No dependency graph available.";
+    const counts = [];
+    for (const [kind, edges] of Object.entries(graphs)) {
+        if (Array.isArray(edges) && edges.length > 0) {
+            counts.push(`${kind}: ${edges.length} edges`);
+        }
+    }
+    if (counts.length === 0)
+        return "Dependency graph is empty.";
+    return `Dependency graph: ${counts.join(", ")}.`;
+}
+function summarizeFlows(bundle) {
+    const flows = bundle.critical_flows?.flows ?? [];
+    if (flows.length === 0)
+        return "No critical flows identified.";
+    const lines = flows.map((flow) => `- ${flow.name}: ${flow.paths.length} files, concerns: ${flow.concerns.join(", ") || "none"}`);
+    return [`${flows.length} critical flows:`, ...lines].join("\n");
+}
+function summarizeRisk(bundle) {
+    const items = bundle.risk_register?.items ?? [];
+    if (items.length === 0)
+        return "No risk items.";
+    const sorted = [...items].sort((a, b) => b.risk_score - a.risk_score);
+    const top = sorted.slice(0, 10);
+    const lines = top.map((item) => `- ${item.unit_id}: score ${item.risk_score}, signals: ${item.signals.join(", ") || "none"}`);
+    return [
+        `${items.length} risk items (top ${top.length} by score):`,
+        ...lines,
+    ].join("\n");
+}
+function summarizeSurfaces(bundle) {
+    const surfaces = bundle.surface_manifest?.surfaces ?? [];
+    if (surfaces.length === 0)
+        return "No externally reachable surfaces identified.";
+    const lines = surfaces.map((surface) => `- ${surface.id} (${surface.kind}): ${surface.entrypoint}${surface.methods?.length ? ` [${surface.methods.join(", ")}]` : ""}`);
+    return [`${surfaces.length} surfaces:`, ...lines].join("\n");
+}
+function summarizeFiles(bundle) {
+    const files = bundle.repo_manifest?.files ?? [];
+    if (files.length === 0)
+        return "No files in manifest.";
+    const byLanguage = new Map();
+    for (const file of files) {
+        const lang = file.language || "unknown";
+        byLanguage.set(lang, (byLanguage.get(lang) ?? 0) + 1);
+    }
+    const langSummary = [...byLanguage.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([lang, count]) => `${lang}: ${count}`)
+        .join(", ");
+    return `${files.length} files (${langSummary}).`;
+}
+function formatDeterministicFindings(findings) {
+    if (findings.length === 0)
+        return "No structural issues detected by deterministic analysis.";
+    const lines = findings.map((finding) => `- [${finding.severity}] ${finding.title}: ${finding.summary}`);
+    return [
+        `${findings.length} structural findings from deterministic analysis:`,
+        ...lines,
+    ].join("\n");
+}
+export function renderDesignReviewPrompt(bundle) {
+    const deterministicFindings = bundle.design_assessment?.findings ?? [];
+    return [
+        "# Project design review",
+        "",
+        "You are reviewing the overall design of this project. The deterministic audit pipeline has already analyzed the codebase structure. Your job is to provide qualitative, big-picture design observations that static analysis cannot produce.",
+        "",
+        "## Project context",
+        "",
+        `Repository: ${bundle.repo_manifest?.repository?.name ?? "unknown"}`,
+        "",
+        "### File inventory",
+        "",
+        summarizeFiles(bundle),
+        "",
+        "### Unit structure",
+        "",
+        summarizeUnits(bundle),
+        "",
+        "### Dependency graph",
+        "",
+        summarizeGraph(bundle),
+        "",
+        "### Externally reachable surfaces",
+        "",
+        summarizeSurfaces(bundle),
+        "",
+        "### Critical flows",
+        "",
+        summarizeFlows(bundle),
+        "",
+        "### Risk profile",
+        "",
+        summarizeRisk(bundle),
+        "",
+        "### Deterministic structural findings",
+        "",
+        formatDeterministicFindings(deterministicFindings),
+        "",
+        "## What to assess",
+        "",
+        "Read the project source to understand what it does and how it works, then produce findings about:",
+        "",
+        "- **Tool and library opportunities**: third-party tools, libraries, or frameworks that would improve the project. Concrete suggestions with rationale, not generic advice.",
+        "- **Architecture pattern improvements**: structural changes that would improve extensibility, testability, or maintainability. Consider whether the current abstractions match the problem domain.",
+        "- **Design simplification**: areas where the design is over-engineered or where simpler alternatives would work. Conversely, areas that are under-designed for their importance.",
+        "- **Integration and generalization**: opportunities to make the project more portable, composable, or protocol-aligned (e.g., MCP, standard APIs, plugin architectures).",
+        "- **Missing capabilities**: gaps in the design that would become pain points as the project evolves.",
+        "",
+        "## Output format",
+        "",
+        "Produce a JSON array of findings. Each finding must conform to:",
+        "",
+        "```json",
+        "{",
+        '  "id": "DR-001",',
+        '  "title": "short descriptive title",',
+        '  "category": "one of: tool_opportunity, architecture_pattern, design_simplification, integration, missing_capability",',
+        '  "severity": "one of: critical, high, medium, low, info",',
+        '  "confidence": "one of: high, medium, low",',
+        '  "lens": "architecture",',
+        '  "summary": "detailed explanation of the observation and the recommended change",',
+        '  "affected_files": [{"path": "relevant/file.ts"}],',
+        '  "systemic": true',
+        "}",
+        "```",
+        "",
+        "Write the JSON array to the design review results path provided below. Use finding IDs starting with DR-001.",
+        "",
+        "Focus on substantive, actionable observations. Prefer fewer high-quality findings over many surface-level ones.",
+        "",
+    ].join("\n");
+}

package/dist/orchestrator/executors.js

@@ -9,6 +9,16 @@ export const EXECUTOR_REGISTRY = [
         obligation_ids: ["structure_artifacts"],
         description: "Build structure artifacts such as units, surfaces, graphs, flows, and risk.",
     },
+    {
+        id: "design_assessment_executor",
+        obligation_ids: ["design_assessment_current"],
+        description: "Run deterministic structural analysis to assess overall project design.",
+    },
+    {
+        id: "design_review",
+        obligation_ids: ["design_review_completed"],
+        description: "Pause the pipeline and delegate a holistic project design review to the active LLM agent.",
+    },
     {
         id: "planning_executor",
         obligation_ids: ["planning_artifacts"],

package/dist/orchestrator/internalExecutors.d.ts

@@ -13,6 +13,8 @@ export declare function resolveRuntimeValidationSpawnCommand(command: string[],
 };
 export declare function runIntakeExecutor(bundle: ArtifactBundle, root: string): Promise<ExecutorRunResult>;
 export declare function runStructureExecutor(bundle: ArtifactBundle, root?: string): Promise<ExecutorRunResult>;
+export declare function runDesignAssessmentExecutor(bundle: ArtifactBundle): ExecutorRunResult;
+export declare function runDesignReviewAutoComplete(bundle: ArtifactBundle): ExecutorRunResult;
 export declare function runPlanningExecutor(bundle: ArtifactBundle, root: string, lineIndex?: Record<string, number>): Promise<ExecutorRunResult>;
 export declare function runResultIngestionExecutor(bundle: ArtifactBundle, results: AuditResult[]): ExecutorRunResult;
 export declare function runRuntimeValidationExecutor(bundle: ArtifactBundle, root: string): Promise<ExecutorRunResult>;

package/dist/orchestrator/internalExecutors.js

@@ -15,6 +15,7 @@ import { buildUnitManifest } from "./unitBuilder.js";
 import { buildRepoManifestFromFs } from "../extractors/fsIntake.js";
 import { loadIgnoreFile } from "../extractors/ignore.js";
 import { ingestAuditResults, updateAuditTaskStatuses, } from "./resultIngestion.js";
+import { buildDesignAssessment } from "../extractors/designAssessment.js";
 import { buildSelectiveDeepeningTasks } from "./selectiveDeepening.js";
 import { updateRuntimeValidationReport } from "./runtimeValidationUpdate.js";
 import { autoCompleteTrivialCoverage } from "./trivialAudit.js";
@@ -178,6 +179,47 @@ export async function runStructureExecutor(bundle, root) {
                 : ""),
     };
 }
+export function runDesignAssessmentExecutor(bundle) {
+    if (!bundle.unit_manifest ||
+        !bundle.graph_bundle ||
+        !bundle.critical_flows ||
+        !bundle.risk_register) {
+        throw new Error("Cannot run design assessment executor without structure artifacts");
+    }
+    const designAssessment = buildDesignAssessment({
+        unitManifest: bundle.unit_manifest,
+        graphBundle: bundle.graph_bundle,
+        criticalFlows: bundle.critical_flows,
+        riskRegister: bundle.risk_register,
+    });
+    return {
+        updated: {
+            ...bundle,
+            design_assessment: designAssessment,
+        },
+        artifacts_written: ["design_assessment.json"],
+        progress_summary: `Design assessment complete: ${designAssessment.findings.length} structural finding(s).`,
+    };
+}
+export function runDesignReviewAutoComplete(bundle) {
+    const existing = bundle.design_assessment;
+    if (!existing) {
+        throw new Error("Cannot auto-complete design review without design_assessment artifact");
+    }
+    const updated = {
+        ...existing,
+        reviewed: true,
+        review_findings: existing.review_findings ?? [],
+    };
+    return {
+        updated: {
+            ...bundle,
+            design_assessment: updated,
+        },
+        artifacts_written: ["design_assessment.json"],
+        progress_summary: "Design review auto-completed (host-agent review available via next-step).",
+    };
+}
 export async function runPlanningExecutor(bundle, root, lineIndex = {}) {
     if (!bundle.repo_manifest) {
         throw new Error("Cannot run planning executor without repo_manifest");
@@ -409,6 +451,7 @@ export function runSynthesisExecutor(bundle, results) {
         coverageMatrix: bundle.coverage_matrix,
         runtimeValidationReport: bundle.runtime_validation_report,
         externalAnalyzerResults: bundle.external_analyzer_results,
+        designAssessment: bundle.design_assessment,
     });
     return {
         updated: {

package/dist/orchestrator/nextStep.js

@@ -6,6 +6,8 @@ const PRIORITY = [
     "auto_fixes_applied",
     "syntax_resolved",
     "structure_artifacts",
+    "design_assessment_current",
+    "design_review_completed",
     "planning_artifacts",
     "audit_tasks_completed",
     "audit_results_ingested",

package/dist/orchestrator/state.js

@@ -29,6 +29,8 @@ export function deriveAuditState(bundle) {
         "critical_flows.json",
         "risk_register.json",
     ], structureReady)));
+    obligations.push(obligation("design_assessment_current", staleOrSatisfied(staleArtifacts, ["design_assessment.json"], has(bundle.design_assessment))));
+    obligations.push(obligation("design_review_completed", bundle.design_assessment?.reviewed ? "satisfied" : "missing"));
     const planningReady = has(bundle.coverage_matrix) &&
         has(bundle.flow_coverage) &&
         has(bundle.runtime_validation_tasks) &&

package/dist/providers/types.d.ts

@@ -21,7 +21,13 @@ export interface LaunchFreshSessionResult {
     stderrPath?: string;
     error?: string;
 }
+export interface ProviderRateLimits {
+    requests_per_minute?: number | null;
+    input_tokens_per_minute?: number | null;
+    output_tokens_per_minute?: number | null;
+}
 export interface FreshSessionProvider {
     name: string;
     launch(input: LaunchFreshSessionInput): Promise<LaunchFreshSessionResult>;
+    queryLimits?(model: string | null): Promise<ProviderRateLimits | null>;
 }

package/dist/quota/discoveredLimits.d.ts

@@ -0,0 +1,21 @@
+export interface DiscoveredRateLimits {
+    requests_per_minute?: number | null;
+    input_tokens_per_minute?: number | null;
+    output_tokens_per_minute?: number | null;
+    source: string;
+}
+export interface DiscoveredLimitsCacheEntry {
+    requests_per_minute?: number;
+    input_tokens_per_minute?: number;
+    discovered_at: string;
+    source: string;
+}
+export interface DiscoveredLimitsCache {
+    version: 1;
+    entries: Record<string, DiscoveredLimitsCacheEntry>;
+}
+export declare function readDiscoveredLimitsCache(): Promise<DiscoveredLimitsCache>;
+export declare function writeDiscoveredLimitsCache(cache: DiscoveredLimitsCache): Promise<void>;
+export declare function updateDiscoveredLimits(providerModelKey: string, limits: DiscoveredRateLimits): Promise<void>;
+export declare function lookupDiscoveredLimits(providerModelKey: string): Promise<DiscoveredRateLimits | null>;
+export declare function mergeDiscoveredLimits(...sources: (DiscoveredRateLimits | null | undefined)[]): DiscoveredRateLimits | null;

package/dist/quota/discoveredLimits.js

@@ -0,0 +1,74 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getQuotaStatePath } from "./state.js";
+function getCachePath() {
+    return getQuotaStatePath().replace(/quota-state\.json$/, "discovered-limits.json");
+}
+export async function readDiscoveredLimitsCache() {
+    try {
+        const raw = await readFile(getCachePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed !== null &&
+            typeof parsed === "object" &&
+            !Array.isArray(parsed) &&
+            parsed["version"] === 1) {
+            return parsed;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            process.stderr.write(`[quota] ignoring unreadable discovered-limits cache: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    return { version: 1, entries: {} };
+}
+export async function writeDiscoveredLimitsCache(cache) {
+    const cachePath = getCachePath();
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, JSON.stringify(cache, null, 2) + "\n", "utf8");
+}
+export async function updateDiscoveredLimits(providerModelKey, limits) {
+    const cache = await readDiscoveredLimitsCache();
+    const existing = cache.entries[providerModelKey];
+    const entry = {
+        ...existing,
+        discovered_at: new Date().toISOString(),
+        source: limits.source,
+    };
+    if (limits.requests_per_minute != null) {
+        entry.requests_per_minute = limits.requests_per_minute;
+    }
+    if (limits.input_tokens_per_minute != null) {
+        entry.input_tokens_per_minute = limits.input_tokens_per_minute;
+    }
+    cache.entries[providerModelKey] = entry;
+    await writeDiscoveredLimitsCache(cache);
+}
+export async function lookupDiscoveredLimits(providerModelKey) {
+    const cache = await readDiscoveredLimitsCache();
+    const entry = cache.entries[providerModelKey];
+    if (!entry)
+        return null;
+    if (entry.requests_per_minute == null && entry.input_tokens_per_minute == null)
+        return null;
+    return {
+        requests_per_minute: entry.requests_per_minute ?? null,
+        input_tokens_per_minute: entry.input_tokens_per_minute ?? null,
+        source: entry.source,
+    };
+}
+export function mergeDiscoveredLimits(...sources) {
+    let merged = null;
+    for (const source of sources) {
+        if (!source)
+            continue;
+        if (!merged) {
+            merged = { ...source };
+            continue;
+        }
+        merged.requests_per_minute ??= source.requests_per_minute;
+        merged.input_tokens_per_minute ??= source.input_tokens_per_minute;
+        merged.output_tokens_per_minute ??= source.output_tokens_per_minute;
+    }
+    return merged;
+}

package/dist/quota/headerExtraction.d.ts

@@ -0,0 +1,8 @@
+export interface ExtractedRateLimits {
+    requests_per_minute: number | null;
+    input_tokens_per_minute: number | null;
+    remaining_requests: number | null;
+    remaining_tokens: number | null;
+    reset_at: string | null;
+}
+export declare function extractRateLimitHeaders(text: string): ExtractedRateLimits | null;

package/dist/quota/headerExtraction.js

@@ -0,0 +1,140 @@
+const HEADER_PATTERNS = [
+    // Standard x-ratelimit-* (OpenAI, Anthropic, and others)
+    { pattern: /x-ratelimit-limit-requests:\s*(\d+)/i, field: "requests_per_minute" },
+    { pattern: /x-ratelimit-limit-tokens:\s*(\d+)/i, field: "input_tokens_per_minute" },
+    { pattern: /x-ratelimit-remaining-requests:\s*(\d+)/i, field: "remaining_requests" },
+    { pattern: /x-ratelimit-remaining-tokens:\s*(\d+)/i, field: "remaining_tokens" },
+    { pattern: /x-ratelimit-reset-requests:\s*(.+)/i, field: "reset_at", transform: parseResetValue },
+    { pattern: /x-ratelimit-reset-tokens:\s*(.+)/i, field: "reset_at", transform: parseResetValue },
+    // Anthropic-specific header naming
+    { pattern: /anthropic-ratelimit-requests-limit:\s*(\d+)/i, field: "requests_per_minute" },
+    { pattern: /anthropic-ratelimit-tokens-limit:\s*(\d+)/i, field: "input_tokens_per_minute" },
+    { pattern: /anthropic-ratelimit-requests-remaining:\s*(\d+)/i, field: "remaining_requests" },
+    { pattern: /anthropic-ratelimit-tokens-remaining:\s*(\d+)/i, field: "remaining_tokens" },
+    { pattern: /anthropic-ratelimit-requests-reset:\s*(.+)/i, field: "reset_at", transform: parseResetValue },
+    { pattern: /anthropic-ratelimit-tokens-reset:\s*(.+)/i, field: "reset_at", transform: parseResetValue },
+];
+function parseResetValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    // ISO timestamp
+    if (/^\d{4}-\d{2}-\d{2}/.test(trimmed))
+        return trimmed;
+    // Relative seconds (e.g. "42s", "42")
+    const seconds = parseFloat(trimmed);
+    if (Number.isFinite(seconds) && seconds > 0) {
+        return new Date(Date.now() + seconds * 1000).toISOString();
+    }
+    return trimmed;
+}
+function parseNumericValue(value) {
+    const n = parseInt(value, 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+}
+export function extractRateLimitHeaders(text) {
+    const result = {
+        requests_per_minute: null,
+        input_tokens_per_minute: null,
+        remaining_requests: null,
+        remaining_tokens: null,
+        reset_at: null,
+    };
+    let found = false;
+    for (const { pattern, field, transform } of HEADER_PATTERNS) {
+        const match = pattern.exec(text);
+        if (!match || !match[1])
+            continue;
+        if (result[field] != null)
+            continue; // first match wins
+        if (transform) {
+            const transformed = transform(match[1]);
+            if (transformed != null) {
+                result[field] = transformed;
+                found = true;
+            }
+        }
+        else {
+            const numeric = parseNumericValue(match[1]);
+            if (numeric != null) {
+                result[field] = numeric;
+                found = true;
+            }
+        }
+    }
+    // Also try JSON objects that embed header-like fields
+    if (!found) {
+        const jsonResult = extractFromJson(text);
+        if (jsonResult)
+            return jsonResult;
+    }
+    return found ? result : null;
+}
+function extractFromJson(text) {
+    const jsonPattern = /\{[^{}]*"(?:x-ratelimit|anthropic-ratelimit|ratelimit)[^{}]*\}/gi;
+    for (const match of text.matchAll(jsonPattern)) {
+        try {
+            const obj = JSON.parse(match[0]);
+            return extractFromHeaderObject(obj);
+        }
+        catch {
+            // not valid JSON
+        }
+    }
+    // Try line-by-line JSON (Claude Code stderr format)
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        try {
+            const obj = JSON.parse(trimmed);
+            const headers = obj["headers"] ??
+                obj["response_headers"];
+            if (headers) {
+                const extracted = extractFromHeaderObject(headers);
+                if (extracted)
+                    return extracted;
+            }
+        }
+        catch {
+            // not valid JSON
+        }
+    }
+    return null;
+}
+function extractFromHeaderObject(headers) {
+    const get = (keys) => {
+        for (const key of keys) {
+            const val = headers[key] ?? headers[key.toLowerCase()];
+            if (val != null) {
+                const n = typeof val === "number" ? val : parseInt(String(val), 10);
+                if (Number.isFinite(n) && n > 0)
+                    return n;
+            }
+        }
+        return null;
+    };
+    const rpm = get([
+        "x-ratelimit-limit-requests",
+        "anthropic-ratelimit-requests-limit",
+    ]);
+    const tpm = get([
+        "x-ratelimit-limit-tokens",
+        "anthropic-ratelimit-tokens-limit",
+    ]);
+    if (rpm == null && tpm == null)
+        return null;
+    return {
+        requests_per_minute: rpm,
+        input_tokens_per_minute: tpm,
+        remaining_requests: get([
+            "x-ratelimit-remaining-requests",
+            "anthropic-ratelimit-requests-remaining",
+        ]),
+        remaining_tokens: get([
+            "x-ratelimit-remaining-tokens",
+            "anthropic-ratelimit-tokens-remaining",
+        ]),
+        reset_at: null,
+    };
+}

package/dist/quota/headerExtractors/claudeCodeHeaderExtractor.d.ts

@@ -0,0 +1,6 @@
+import type { ExtractedRateLimits } from "../headerExtraction.js";
+import type { HeaderExtractor } from "./genericHeaderExtractor.js";
+export declare class ClaudeCodeHeaderExtractor implements HeaderExtractor {
+    readonly name = "claude-code";
+    extract(stderr: string): ExtractedRateLimits | null;
+}

package/dist/quota/headerExtractors/claudeCodeHeaderExtractor.js

@@ -0,0 +1,28 @@
+import { extractRateLimitHeaders } from "../headerExtraction.js";
+export class ClaudeCodeHeaderExtractor {
+    name = "claude-code";
+    extract(stderr) {
+        // Claude Code emits structured JSON lines to stderr. Collect all lines
+        // that might contain header data and feed them to the agnostic parser.
+        const candidates = [];
+        for (const line of stderr.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("{"))
+                continue;
+            try {
+                const obj = JSON.parse(trimmed);
+                if (obj["headers"] || obj["response_headers"]) {
+                    candidates.push(trimmed);
+                }
+            }
+            catch {
+                // not JSON
+            }
+        }
+        if (candidates.length > 0) {
+            return extractRateLimitHeaders(candidates.join("\n"));
+        }
+        // Fall back to scanning the full text for raw header lines
+        return extractRateLimitHeaders(stderr);
+    }
+}

package/dist/quota/headerExtractors/genericHeaderExtractor.d.ts

@@ -0,0 +1,9 @@
+import type { ExtractedRateLimits } from "../headerExtraction.js";
+export interface HeaderExtractor {
+    readonly name: string;
+    extract(stderr: string): ExtractedRateLimits | null;
+}
+export declare class GenericHeaderExtractor implements HeaderExtractor {
+    readonly name = "generic";
+    extract(stderr: string): ExtractedRateLimits | null;
+}

package/dist/quota/headerExtractors/genericHeaderExtractor.js

@@ -0,0 +1,7 @@
+import { extractRateLimitHeaders } from "../headerExtraction.js";
+export class GenericHeaderExtractor {
+    name = "generic";
+    extract(stderr) {
+        return extractRateLimitHeaders(stderr);
+    }
+}

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

@@ -0,0 +1,5 @@
+export type { HeaderExtractor } from "./genericHeaderExtractor.js";
+export { GenericHeaderExtractor } from "./genericHeaderExtractor.js";
+export { ClaudeCodeHeaderExtractor } from "./claudeCodeHeaderExtractor.js";
+import type { HeaderExtractor } from "./genericHeaderExtractor.js";
+export declare function getHeaderExtractorForProvider(providerName: string): HeaderExtractor;

package/dist/quota/headerExtractors/index.js

@@ -0,0 +1,12 @@
+export { GenericHeaderExtractor } from "./genericHeaderExtractor.js";
+export { ClaudeCodeHeaderExtractor } from "./claudeCodeHeaderExtractor.js";
+import { GenericHeaderExtractor } from "./genericHeaderExtractor.js";
+import { ClaudeCodeHeaderExtractor } from "./claudeCodeHeaderExtractor.js";
+const PROVIDER_EXTRACTORS = {
+    "claude-code": () => new ClaudeCodeHeaderExtractor(),
+};
+const genericExtractor = new GenericHeaderExtractor();
+export function getHeaderExtractorForProvider(providerName) {
+    const factory = PROVIDER_EXTRACTORS[providerName];
+    return factory ? factory() : genericExtractor;
+}

package/dist/quota/index.d.ts

@@ -16,4 +16,10 @@ 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 { lookupDiscoveredLimits, updateDiscoveredLimits, mergeDiscoveredLimits, readDiscoveredLimitsCache, writeDiscoveredLimitsCache, } from "./discoveredLimits.js";
+export type { DiscoveredRateLimits, DiscoveredLimitsCache, DiscoveredLimitsCacheEntry } from "./discoveredLimits.js";
+export { extractRateLimitHeaders } from "./headerExtraction.js";
+export type { ExtractedRateLimits } from "./headerExtraction.js";
+export type { HeaderExtractor } from "./headerExtractors/index.js";
+export { GenericHeaderExtractor, ClaudeCodeHeaderExtractor, getHeaderExtractorForProvider } from "./headerExtractors/index.js";
 export type { ResolvedLimits, LimitSource, LimitConfidence, HostConcurrencyLimit, HostConcurrencyLimitSource, QuotaState, QuotaStateEntry, ConcurrencyBucket, WaveSchedule, DispatchQuota, ObservedWaveOutcome, } from "./types.js";

package/dist/quota/index.js

@@ -9,3 +9,6 @@ export { probeProvider } from "./probe.js";
 export { GenericErrorParser, ClaudeCodeErrorParser, getErrorParserForProvider } from "./errorParsers/index.js";
 export { LearnedQuotaSource } from "./learnedQuotaSource.js";
 export { CompositeQuotaSource } from "./compositeQuotaSource.js";
+export { lookupDiscoveredLimits, updateDiscoveredLimits, mergeDiscoveredLimits, readDiscoveredLimitsCache, writeDiscoveredLimitsCache, } from "./discoveredLimits.js";
+export { extractRateLimitHeaders } from "./headerExtraction.js";
+export { GenericHeaderExtractor, ClaudeCodeHeaderExtractor, getHeaderExtractorForProvider } from "./headerExtractors/index.js";

package/dist/quota/scheduler.d.ts

@@ -1,6 +1,7 @@
 import type { ResolvedProviderName, SessionConfig } from "../types/sessionConfig.js";
 import type { HostConcurrencyLimit, QuotaStateEntry, WaveSchedule } from "./types.js";
 import type { QuotaUsageSnapshot } from "./quotaSource.js";
+import type { DiscoveredRateLimits } from "./discoveredLimits.js";
 export interface ScheduleWaveOptions {
     providerName: ResolvedProviderName;
     sessionConfig: SessionConfig;
@@ -13,6 +14,8 @@ export interface ScheduleWaveOptions {
     quotaStateEntry?: QuotaStateEntry | null;
     hostConcurrencyLimit?: HostConcurrencyLimit | null;
     quotaSourceSnapshot?: QuotaUsageSnapshot | null;
+    /** RPM/TPM discovered from provider queries or response header extraction. */
+    discoveredLimits?: DiscoveredRateLimits | null;
 }
 export declare function scheduleWave(options: ScheduleWaveOptions): WaveSchedule;
 /** Build the state key used for indexing quota-state.json entries. */