audit-tools 0.28.0

package/dist/shared/quota/capacity.d.ts

@@ -0,0 +1,283 @@
+import { z } from "zod";
+import type { ResolvedProviderName, SessionConfig } from "../types/sessionConfig.js";
+import type { DispatchModelTier } from "../types/stepContract.js";
+import type { HostConcurrencyLimit, QuotaStateEntry, WaveBindingCap, WaveSchedule } from "./types.js";
+import type { QuotaUsageSnapshot } from "./quotaSource.js";
+import { type DiscoveredRateLimitsInput } from "./scheduler.js";
+/**
+ * Reason a partial-completion terminal fired on the dispatch engine.
+ * - `empty_pool`: no capacity pools are available (pool list is empty or every
+ *   pool reports zero slots) and the engine cannot dispatch remaining items.
+ * - `livelock_guard`: N consecutive waves passed with zero progress (all items
+ *   remain undispatchable despite pools being present) and the guard tripped.
+ */
+export type PartialCompletionReason = "empty_pool" | "livelock_guard";
+/**
+ * Consumer-neutral signal that the dispatch engine reached a terminal it cannot
+ * recover from on its own. The caller must route stranded items through a
+ * consumer-specific handler (e.g. audit marks them uncovered and proceeds to
+ * synthesis; remediate marks them blocked and proceeds to close).
+ *
+ * Produced by {@link detectLivelock} and persisted on the active-dispatch
+ * artifact so both the audit and remediation orchestrators can inspect it in
+ * their state-derivation logic.
+ */
+export interface PartialCompletionTerminal {
+    reason: PartialCompletionReason;
+    /** task/unit IDs the engine could not dispatch. */
+    stranded_ids: string[];
+}
+/**
+ * Detect a livelock or empty-pool condition after a series of no-progress waves
+ * and return a {@link PartialCompletionTerminal} if one is found.
+ *
+ * Call this after each dispatch wave where no items were dispatched. When
+ * `consecutiveNoProgressWaves` reaches or exceeds `noProgressLimit` (default
+ * 3), the engine is declared livelocked and a terminal is returned. If
+ * `pendingIds` is empty the terminal reason is `empty_pool` regardless of the
+ * wave count (no work remains to stall on). Returns `null` when the condition
+ * has not yet been reached.
+ *
+ * The caller is responsible for persisting the returned terminal and routing
+ * stranded items through its consumer-specific handler.
+ */
+export declare function detectLivelock(options: {
+    pendingIds: string[];
+    consecutiveNoProgressWaves: number;
+    noProgressLimit?: number;
+}): PartialCompletionTerminal | null;
+/**
+ * Produce an `empty_pool` {@link PartialCompletionTerminal} for the given IDs.
+ * Call this when `computeDispatchCapacity` would throw because no pools are
+ * available, so the caller can record the terminal and route stranded items
+ * without crashing.
+ */
+export declare function buildEmptyPoolTerminal(strandedIds: string[]): PartialCompletionTerminal;
+/**
+ * A dispatch capacity pool: one backend (a provider + host model) that runs
+ * review/worker subagents in parallel, each in its own fresh session with its
+ * own context window. The conversation host's own subagents are one pool; a
+ * different IDE model, another CLI provider, or another host lane is another.
+ * {@link computeDispatchCapacity} allocates the pending work across all of them.
+ * A pool carries everything {@link scheduleWave} needs to size that one backend,
+ * so per-pool limits never have to be threaded separately at the call site.
+ */
+export interface CapacityPool {
+    /** Stable identifier, e.g. the provider/model key. */
+    id: string;
+    providerName: ResolvedProviderName;
+    hostModel: string | null;
+    /**
+     * Relative rank this pool serves when the host reported a model roster at
+     * the handshake (aligned with `DispatchModelHint.tier`). Absent for the
+     * single-window handshake.
+     */
+    rank?: DispatchModelTier;
+    /**
+     * Hard ceiling on simultaneously active subagents for this pool, if the host
+     * reported one (e.g. `--host-max-active-subagents`, or `parallel_workers` from
+     * session-config). null leaves only the rate / learned / first-contact caps.
+     */
+    hostConcurrencyLimit: HostConcurrencyLimit | null;
+    /** Learned quota-state entry for this pool's provider/model key, if any. */
+    quotaStateEntry?: QuotaStateEntry | null;
+    /** RPM/TPM discovered for this pool (provider query or response headers). */
+    discoveredLimits?: DiscoveredRateLimitsInput | null;
+    /** Real-time usage snapshot for this pool, if available. */
+    quotaSourceSnapshot?: QuotaUsageSnapshot | null;
+}
+/** One pool's slice of the overall dispatch capacity. */
+export interface PoolDispatchAllocation {
+    pool_id: string;
+    /** Relative rank this pool serves, when the host reported a roster. */
+    rank?: DispatchModelTier;
+    /** Concurrent dispatch slots this pool can sustain right now. */
+    slots: number;
+    /** Full wave schedule for this pool (resolved limits, binding cap, cooldown). */
+    schedule: WaveSchedule;
+}
+/** Compact, serializable view of one pool allocation for dispatch-quota files. */
+export declare const DispatchCapacityPoolSummarySchema: z.ZodObject<{
+    pool_id: z.ZodString;
+    rank: z.ZodOptional<z.ZodEnum<["small", "standard", "deep"]>>;
+    slots: z.ZodNumber;
+    model: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    source: z.ZodEnum<["explicit_config", "discovered_capability", "cli_flags", "provider_default", "learned", "default"]>;
+    resolved_limits: z.ZodObject<{
+        context_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        requests_per_minute: z.ZodNullable<z.ZodNumber>;
+        input_tokens_per_minute: z.ZodNullable<z.ZodNumber>;
+        output_tokens_per_minute: z.ZodNullable<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        requests_per_minute: number | null;
+        input_tokens_per_minute: number | null;
+        context_tokens: number;
+        output_tokens: number;
+        output_tokens_per_minute: number | null;
+    }, {
+        requests_per_minute: number | null;
+        input_tokens_per_minute: number | null;
+        context_tokens: number;
+        output_tokens: number;
+        output_tokens_per_minute: number | null;
+    }>;
+    host_concurrency_limit: z.ZodNullable<z.ZodObject<{
+        active_subagents: z.ZodNumber;
+        source: z.ZodEnum<["cli_flags", "host_reported", "session_config", "environment"]>;
+        description: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        source: "cli_flags" | "host_reported" | "session_config" | "environment";
+        active_subagents: number;
+        description: string;
+    }, {
+        source: "cli_flags" | "host_reported" | "session_config" | "environment";
+        active_subagents: number;
+        description: string;
+    }>>;
+    cooldown_until: z.ZodNullable<z.ZodString>;
+    estimated_wave_tokens: z.ZodNumber;
+    binding_cap: z.ZodEnum<["rpm", "tpm", "learned", "fallback", "first_contact", "cooldown", "host_concurrency", "none"]>;
+    quota_source_snapshot: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        remaining_pct: z.ZodNullable<z.ZodNumber>;
+        reset_at: z.ZodNullable<z.ZodString>;
+        requests_remaining: z.ZodNullable<z.ZodNumber>;
+        tokens_remaining: z.ZodNullable<z.ZodNumber>;
+        captured_at: z.ZodString;
+        source: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        remaining_pct: number | null;
+        reset_at: string | null;
+        requests_remaining: number | null;
+        tokens_remaining: number | null;
+        captured_at: string;
+        source: string;
+    }, {
+        remaining_pct: number | null;
+        reset_at: string | null;
+        requests_remaining: number | null;
+        tokens_remaining: number | null;
+        captured_at: string;
+        source: string;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    confidence: "high" | "low" | "medium";
+    source: "default" | "explicit_config" | "discovered_capability" | "cli_flags" | "provider_default" | "learned";
+    cooldown_until: string | null;
+    pool_id: string;
+    slots: number;
+    model: string | null;
+    resolved_limits: {
+        requests_per_minute: number | null;
+        input_tokens_per_minute: number | null;
+        context_tokens: number;
+        output_tokens: number;
+        output_tokens_per_minute: number | null;
+    };
+    host_concurrency_limit: {
+        source: "cli_flags" | "host_reported" | "session_config" | "environment";
+        active_subagents: number;
+        description: string;
+    } | null;
+    estimated_wave_tokens: number;
+    binding_cap: "none" | "learned" | "rpm" | "tpm" | "fallback" | "first_contact" | "cooldown" | "host_concurrency";
+    rank?: "deep" | "small" | "standard" | undefined;
+    quota_source_snapshot?: {
+        remaining_pct: number | null;
+        reset_at: string | null;
+        requests_remaining: number | null;
+        tokens_remaining: number | null;
+        captured_at: string;
+        source: string;
+    } | null | undefined;
+}, {
+    confidence: "high" | "low" | "medium";
+    source: "default" | "explicit_config" | "discovered_capability" | "cli_flags" | "provider_default" | "learned";
+    cooldown_until: string | null;
+    pool_id: string;
+    slots: number;
+    model: string | null;
+    resolved_limits: {
+        requests_per_minute: number | null;
+        input_tokens_per_minute: number | null;
+        context_tokens: number;
+        output_tokens: number;
+        output_tokens_per_minute: number | null;
+    };
+    host_concurrency_limit: {
+        source: "cli_flags" | "host_reported" | "session_config" | "environment";
+        active_subagents: number;
+        description: string;
+    } | null;
+    estimated_wave_tokens: number;
+    binding_cap: "none" | "learned" | "rpm" | "tpm" | "fallback" | "first_contact" | "cooldown" | "host_concurrency";
+    rank?: "deep" | "small" | "standard" | undefined;
+    quota_source_snapshot?: {
+        remaining_pct: number | null;
+        reset_at: string | null;
+        requests_remaining: number | null;
+        tokens_remaining: number | null;
+        captured_at: string;
+        source: string;
+    } | null | undefined;
+}>;
+export type DispatchCapacityPoolSummary = z.infer<typeof DispatchCapacityPoolSummarySchema>;
+/**
+ * The just-in-time dispatch capacity: how many pending items can be dispatched
+ * concurrently right now, across all available pools, given each pool's current
+ * quota / rate limits and the projected token cost of the pending work. It is
+ * computed immediately before a dispatch and is never persisted as a fixed plan
+ * — recomputing it each step is what lets a run be picked up by a different host
+ * (other models, other providers) without inheriting a stale wave size.
+ */
+export interface DispatchCapacity {
+    /** Total concurrent dispatch slots across every pool. */
+    total_slots: number;
+    /** Per-pool allocation. One entry today; one per backend under multi-dispatch. */
+    pools: PoolDispatchAllocation[];
+    /**
+     * The pool whose resolved limits summarize the dispatch at the contract level.
+     * Single pool today; under multi-dispatch this is the primary/most-capable pool
+     * and the lean contract still summarizes from it until the contract grows a
+     * per-pool view.
+     */
+    primary: PoolDispatchAllocation;
+    /** Most-constraining cap across pools, for attribution. */
+    binding_cap: WaveBindingCap;
+    /** Earliest cooldown across pools, if any pool is throttled. */
+    cooldown_until: string | null;
+    /** Estimated input tokens for one wave at the resolved capacity (summed across pools). */
+    estimated_wave_tokens: number;
+}
+export interface ComputeDispatchCapacityInput {
+    /** Non-empty set of dispatch pools available to this invocation. */
+    pools: CapacityPool[];
+    sessionConfig: SessionConfig;
+    /**
+     * Projected per-item input-token cost for the pending work — one entry per
+     * dispatchable item (packet/task). This is "all the pending tasks laid out with
+     * their token costs": capacity is computed against this layout rather than
+     * against a preset wave size, so the answer reflects the actual work waiting and
+     * the tools currently available.
+     */
+    pendingItemTokens: number[];
+}
+/**
+ * Compute just-in-time dispatch capacity across the available pools.
+ *
+ * The pending layout is partitioned across pools in caller order, with each pool
+ * receiving the largest remaining item estimates that fit in its current wave.
+ * Each pool is then scheduled independently, so RPM, TPM, learned limits, cooldowns,
+ * and real-time quota snapshots remain per-backend.
+ *
+ * The host concurrency limit (e.g. `--host-max-active-subagents`) is GLOBAL: it
+ * constrains the total across all pools, not each pool independently. When multiple
+ * pools share the same conversation host, a global budget is derived from their
+ * host limits and enforced as a ceiling on cumulative slot allocation so the host is
+ * never over-subscribed. Independent backends with distinct pool IDs are treated as
+ * separate lanes; each backend's per-backend limits remain per-pool.
+ */
+export declare function computeDispatchCapacity(input: ComputeDispatchCapacityInput): DispatchCapacity;
+export declare function summarizeDispatchCapacityPools(capacity: DispatchCapacity): DispatchCapacityPoolSummary[];
+//# sourceMappingURL=capacity.d.ts.map

package/dist/shared/quota/capacity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacity.d.ts","sourceRoot":"","sources":["../../../src/shared/quota/capacity.ts"],"names":[],"mappings":"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"}

package/dist/shared/quota/capacity.js

@@ -0,0 +1,290 @@
+import { z } from "zod";
+import { DispatchModelTierSchema } from "../types/stepContract.js";
+import { HostConcurrencyLimitSchema, LimitConfidenceSchema, LimitSourceSchema, ResolvedLimitsSchema, WaveBindingCapSchema, } from "./types.js";
+import { QuotaUsageSnapshotSchema } from "./quotaSource.js";
+import { scheduleWave } from "./scheduler.js";
+/**
+ * Detect a livelock or empty-pool condition after a series of no-progress waves
+ * and return a {@link PartialCompletionTerminal} if one is found.
+ *
+ * Call this after each dispatch wave where no items were dispatched. When
+ * `consecutiveNoProgressWaves` reaches or exceeds `noProgressLimit` (default
+ * 3), the engine is declared livelocked and a terminal is returned. If
+ * `pendingIds` is empty the terminal reason is `empty_pool` regardless of the
+ * wave count (no work remains to stall on). Returns `null` when the condition
+ * has not yet been reached.
+ *
+ * The caller is responsible for persisting the returned terminal and routing
+ * stranded items through its consumer-specific handler.
+ */
+export function detectLivelock(options) {
+    const { pendingIds, consecutiveNoProgressWaves, noProgressLimit = 3 } = options;
+    if (pendingIds.length === 0) {
+        return null; // nothing stranded — no terminal needed
+    }
+    if (consecutiveNoProgressWaves >= noProgressLimit) {
+        return {
+            reason: "livelock_guard",
+            stranded_ids: [...pendingIds],
+        };
+    }
+    return null;
+}
+/**
+ * Produce an `empty_pool` {@link PartialCompletionTerminal} for the given IDs.
+ * Call this when `computeDispatchCapacity` would throw because no pools are
+ * available, so the caller can record the terminal and route stranded items
+ * without crashing.
+ */
+export function buildEmptyPoolTerminal(strandedIds) {
+    return {
+        reason: "empty_pool",
+        stranded_ids: [...strandedIds],
+    };
+}
+/** Compact, serializable view of one pool allocation for dispatch-quota files. */
+export const DispatchCapacityPoolSummarySchema = z
+    .object({
+    pool_id: z.string().min(1),
+    rank: DispatchModelTierSchema.optional(),
+    slots: z.number().int().min(1),
+    model: z.string().nullable(),
+    confidence: LimitConfidenceSchema,
+    source: LimitSourceSchema,
+    resolved_limits: ResolvedLimitsSchema,
+    host_concurrency_limit: HostConcurrencyLimitSchema.nullable(),
+    cooldown_until: z.string().nullable(),
+    estimated_wave_tokens: z.number().int().min(0),
+    binding_cap: WaveBindingCapSchema,
+    quota_source_snapshot: QuotaUsageSnapshotSchema.nullable().optional(),
+})
+    .strict();
+/** Higher number = more constraining; used to pick the binding cap across pools. */
+const CAP_PRIORITY = {
+    cooldown: 6,
+    host_concurrency: 5,
+    tpm: 4,
+    rpm: 3,
+    learned: 2,
+    first_contact: 1,
+    fallback: 1,
+    none: 0,
+};
+/**
+ * Derive the global host-concurrency budget that applies across ALL pools, when
+ * the pools are routing through the SAME conversation host.
+ *
+ * A host concurrency limit (`--host-max-active-subagents`, `AUDIT_CODE_HOST_MAX_ACTIVE_SUBAGENTS`,
+ * or `parallel_workers` in session-config) constrains the TOTAL number of simultaneously
+ * active subagents the conversation host can sustain — not a per-pool ceiling. When
+ * multiple pools (e.g. small/standard/deep ranks) are all dispatching through the same
+ * host, their combined slot usage must stay within this shared global limit.
+ *
+ * Detection heuristic: if ALL pools that carry a host concurrency limit report the
+ * SAME `{active_subagents, source}` pair, they are sharing the same host signal.
+ * In this case the shared value is returned as the global budget. When pools carry
+ * DIFFERENT limits (indicating independent backends with their own concurrency
+ * envelopes), `null` is returned so each pool's limit applies independently.
+ *
+ * A single-pool setup is unaffected: the pool's own `hostConcurrencyLimit` already
+ * applies at `scheduleWave` time.
+ */
+function deriveGlobalHostBudget(pools) {
+    if (pools.length <= 1)
+        return null;
+    const limitsWithLimit = pools.filter((p) => p.hostConcurrencyLimit !== null);
+    if (limitsWithLimit.length === 0)
+        return null;
+    // All pools with limits must report the same active_subagents AND source to be
+    // treated as a shared global limit from the same conversation host.
+    const first = limitsWithLimit[0].hostConcurrencyLimit;
+    const allSame = limitsWithLimit.every((p) => p.hostConcurrencyLimit.active_subagents === first.active_subagents &&
+        p.hostConcurrencyLimit.source === first.source);
+    if (!allSame)
+        return null;
+    // Only apply global budget when ALL pools (including those without limits) are
+    // covered. If some pools lack a limit, they are independent backends that can
+    // exceed the shared budget — so we don't enforce a global cap.
+    if (limitsWithLimit.length !== pools.length)
+        return null;
+    return first.active_subagents;
+}
+/**
+ * Compute just-in-time dispatch capacity across the available pools.
+ *
+ * The pending layout is partitioned across pools in caller order, with each pool
+ * receiving the largest remaining item estimates that fit in its current wave.
+ * Each pool is then scheduled independently, so RPM, TPM, learned limits, cooldowns,
+ * and real-time quota snapshots remain per-backend.
+ *
+ * The host concurrency limit (e.g. `--host-max-active-subagents`) is GLOBAL: it
+ * constrains the total across all pools, not each pool independently. When multiple
+ * pools share the same conversation host, a global budget is derived from their
+ * host limits and enforced as a ceiling on cumulative slot allocation so the host is
+ * never over-subscribed. Independent backends with distinct pool IDs are treated as
+ * separate lanes; each backend's per-backend limits remain per-pool.
+ */
+export function computeDispatchCapacity(input) {
+    if (input.pools.length === 0) {
+        throw new TypeError("computeDispatchCapacity requires at least one capacity pool.");
+    }
+    const pendingTokens = [...input.pendingItemTokens]
+        .map((n) => Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0)
+        .sort((a, b) => b - a);
+    // Global host-concurrency budget: when multiple pools share the same conversation
+    // host, the total slots across all pools must not exceed this limit.
+    const globalHostBudget = deriveGlobalHostBudget(input.pools);
+    let remainingGlobalBudget = globalHostBudget;
+    const allocations = [];
+    if (pendingTokens.length === 0) {
+        allocations.push(schedulePool(input.pools[0], input.sessionConfig, []));
+    }
+    else {
+        let cursor = 0;
+        for (const pool of input.pools) {
+            if (cursor >= pendingTokens.length)
+                break;
+            if (remainingGlobalBudget !== null && remainingGlobalBudget <= 0)
+                break;
+            const remaining = pendingTokens.slice(cursor);
+            const allocation = schedulePoolConverging(pool, input.sessionConfig, remaining, remainingGlobalBudget);
+            allocations.push(allocation);
+            cursor += allocation.slots;
+            if (remainingGlobalBudget !== null) {
+                remainingGlobalBudget -= allocation.slots;
+            }
+        }
+    }
+    const total = allocations.reduce((sum, a) => sum + a.slots, 0);
+    // When a global host budget was in effect, ensure the aggregate total never
+    // exceeds it (the loop above already enforces this, but guard defensively).
+    const effectiveTotal = globalHostBudget !== null
+        ? Math.min(total, globalHostBudget)
+        : total;
+    const primary = choosePrimaryAllocation(allocations);
+    const bindingCap = allocations.reduce((worst, a) => {
+        const cap = a.schedule.binding_cap ?? "none";
+        return CAP_PRIORITY[cap] > CAP_PRIORITY[worst] ? cap : worst;
+    }, "none");
+    // When the global budget is the binding constraint, record it.
+    const effectiveBindingCap = globalHostBudget !== null && effectiveTotal < total && effectiveTotal === globalHostBudget
+        ? "host_concurrency"
+        : bindingCap;
+    const cooldownUntil = allocations
+        .map((a) => a.schedule.cooldown_until)
+        .filter((c) => c != null)
+        .sort()[0] ?? null;
+    const estimatedWaveTokens = allocations.reduce((sum, a) => sum + a.schedule.estimated_wave_tokens, 0);
+    return {
+        total_slots: Math.max(1, effectiveTotal),
+        pools: allocations,
+        primary,
+        binding_cap: effectiveBindingCap,
+        cooldown_until: cooldownUntil,
+        estimated_wave_tokens: estimatedWaveTokens,
+    };
+}
+/**
+ * Schedule a single pool against the items it has been allocated, converging on
+ * a consistent slot count via a three-pass algorithm:
+ *
+ *  1. **Exploratory pass** — call `schedulePool` over ALL remaining items to get
+ *     an unconstrained slot estimate and the full binding-cap attribution (RPM,
+ *     TPM, learned, etc.). Using the full remaining set lets the TPM budget see
+ *     the realistic token landscape rather than only the items already assigned.
+ *
+ *  2. **Initial assigned-slice pass** — narrow the token list to `assignedCount`
+ *     items (clamped by the exploratory result and the global host budget) and
+ *     re-schedule. Scheduling only the assigned slice can be MORE restrictive than
+ *     the exploratory pass, because the TPM cap iterates over the actual slot costs.
+ *
+ *  3. **Convergence loop** — if the second pass returns fewer slots than items
+ *     assigned (the assigned slice was still over-budget), trim to the returned
+ *     slot count and re-schedule until assignment and slots agree. Each iteration
+ *     removes at least one item, so the loop always terminates.
+ *
+ * The binding cap from the exploratory pass is preserved on the final allocation
+ * when the narrowed slice loses its cap signal (e.g. the slice is so small that
+ * it fits within any limit).
+ */
+function schedulePoolConverging(pool, sessionConfig, remaining, remainingGlobalBudget) {
+    // Pass 1: exploratory — full remaining set for cap attribution.
+    const exploratory = schedulePool(pool, sessionConfig, remaining);
+    let assignedCount = Math.max(1, Math.min(exploratory.slots, remaining.length));
+    // Clamp to the remaining global host budget before narrowing with the pool schedule.
+    if (remainingGlobalBudget !== null) {
+        assignedCount = Math.min(assignedCount, remainingGlobalBudget);
+    }
+    // Pass 2: initial assigned-slice.
+    let assignedTokens = remaining.slice(0, assignedCount);
+    let allocation = schedulePool(pool, sessionConfig, assignedTokens);
+    // Pass 3: convergence — trim until assignment and slots agree.
+    while (assignedTokens.length > 1 && allocation.slots < assignedTokens.length) {
+        assignedCount = allocation.slots;
+        assignedTokens = assignedTokens.slice(0, assignedCount);
+        allocation = schedulePool(pool, sessionConfig, assignedTokens);
+    }
+    // Preserve the exploratory binding cap when the narrowed slice lost its cap signal.
+    if ((allocation.schedule.binding_cap ?? "none") === "none" &&
+        (exploratory.schedule.binding_cap ?? "none") !== "none") {
+        allocation = {
+            ...allocation,
+            schedule: {
+                ...allocation.schedule,
+                binding_cap: exploratory.schedule.binding_cap,
+            },
+        };
+    }
+    return allocation;
+}
+function schedulePool(pool, sessionConfig, itemTokens) {
+    const schedule = scheduleWave({
+        providerName: pool.providerName,
+        sessionConfig,
+        hostModel: pool.hostModel,
+        requestedConcurrency: Math.max(1, itemTokens.length),
+        estimatedSlotTokens: itemTokens,
+        quotaStateEntry: pool.quotaStateEntry ?? null,
+        hostConcurrencyLimit: pool.hostConcurrencyLimit,
+        discoveredLimits: pool.discoveredLimits ?? null,
+        quotaSourceSnapshot: pool.quotaSourceSnapshot ?? null,
+    });
+    return {
+        pool_id: pool.id,
+        ...(pool.rank ? { rank: pool.rank } : {}),
+        slots: itemTokens.length > 0
+            ? Math.min(schedule.max_concurrent, itemTokens.length)
+            : schedule.max_concurrent,
+        schedule,
+    };
+}
+function choosePrimaryAllocation(allocations) {
+    return allocations.reduce((best, candidate) => {
+        if (candidate.slots !== best.slots) {
+            return candidate.slots > best.slots ? candidate : best;
+        }
+        const candidateContext = candidate.schedule.resolved_limits.context_tokens;
+        const bestContext = best.schedule.resolved_limits.context_tokens;
+        if (candidateContext !== bestContext) {
+            return candidateContext > bestContext ? candidate : best;
+        }
+        return candidate.pool_id < best.pool_id ? candidate : best;
+    }, allocations[0]);
+}
+export function summarizeDispatchCapacityPools(capacity) {
+    return capacity.pools.map((allocation) => ({
+        pool_id: allocation.pool_id,
+        ...(allocation.rank ? { rank: allocation.rank } : {}),
+        slots: allocation.slots,
+        model: allocation.schedule.model,
+        confidence: allocation.schedule.confidence,
+        source: allocation.schedule.source,
+        resolved_limits: allocation.schedule.resolved_limits,
+        host_concurrency_limit: allocation.schedule.host_concurrency_limit,
+        cooldown_until: allocation.schedule.cooldown_until,
+        estimated_wave_tokens: allocation.schedule.estimated_wave_tokens,
+        binding_cap: allocation.schedule.binding_cap ?? "none",
+        quota_source_snapshot: allocation.schedule.quota_source_snapshot ?? null,
+    }));
+}
+//# sourceMappingURL=capacity.js.map

package/dist/shared/quota/capacity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacity.js","sourceRoot":"","sources":["../../../src/shared/quota/capacity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAOnE,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAkC,MAAM,gBAAgB,CAAC;AA2B9E;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAAC,OAI9B;IACC,MAAM,EAAE,UAAU,EAAE,0BAA0B,EAAE,eAAe,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC;IAEhF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,IAAI,CAAC,CAAC,wCAAwC;IACvD,CAAC;IAED,IAAI,0BAA0B,IAAI,eAAe,EAAE,CAAC;QAClD,OAAO;YACL,MAAM,EAAE,gBAAgB;YACxB,YAAY,EAAE,CAAC,GAAG,UAAU,CAAC;SAC9B,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,WAAqB;IAC1D,OAAO;QACL,MAAM,EAAE,YAAY;QACpB,YAAY,EAAE,CAAC,GAAG,WAAW,CAAC;KAC/B,CAAC;AACJ,CAAC;AA+CD,kFAAkF;AAClF,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC;KAC/C,MAAM,CAAC;IACN,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,IAAI,EAAE,uBAAuB,CAAC,QAAQ,EAAE;IACxC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,UAAU,EAAE,qBAAqB;IACjC,MAAM,EAAE,iBAAiB;IACzB,eAAe,EAAE,oBAAoB;IACrC,sBAAsB,EAAE,0BAA0B,CAAC,QAAQ,EAAE;IAC7D,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9C,WAAW,EAAE,oBAAoB;IACjC,qBAAqB,EAAE,wBAAwB,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CACtE,CAAC;KACD,MAAM,EAAE,CAAC;AA+CZ,oFAAoF;AACpF,MAAM,YAAY,GAAmC;IACnD,QAAQ,EAAE,CAAC;IACX,gBAAgB,EAAE,CAAC;IACnB,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,OAAO,EAAE,CAAC;IACV,aAAa,EAAE,CAAC;IAChB,QAAQ,EAAE,CAAC;IACX,IAAI,EAAE,CAAC;CACR,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAS,sBAAsB,CAAC,KAAqB;IACnD,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,MAAM,eAAe,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,oBAAoB,KAAK,IAAI,CAAC,CAAC;IAC7E,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9C,+EAA+E;IAC/E,oEAAoE;IACpE,MAAM,KAAK,GAAG,eAAe,CAAC,CAAC,CAAE,CAAC,oBAAqB,CAAC;IACxD,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,CACnC,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,oBAAqB,CAAC,gBAAgB,KAAK,KAAK,CAAC,gBAAgB;QACnE,CAAC,CAAC,oBAAqB,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAClD,CAAC;IACF,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B,+EAA+E;IAC/E,8EAA8E;IAC9E,+DAA+D;IAC/D,IAAI,eAAe,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzD,OAAO,KAAK,CAAC,gBAAgB,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAmC;IAEnC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,SAAS,CAAC,8DAA8D,CAAC,CAAC;IACtF,CAAC;IAED,MAAM,aAAa,GAAG,CAAC,GAAG,KAAK,CAAC,iBAAiB,CAAC;SAC/C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/D,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAEzB,kFAAkF;IAClF,qEAAqE;IACrE,MAAM,gBAAgB,GAAG,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7D,IAAI,qBAAqB,GAAG,gBAAgB,CAAC;IAE7C,MAAM,WAAW,GAA6B,EAAE,CAAC;IACjD,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/B,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC,CAAC;IAC3E,CAAC;SAAM,CAAC;QACN,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAC/B,IAAI,MAAM,IAAI,aAAa,CAAC,MAAM;gBAAE,MAAM;YAC1C,IAAI,qBAAqB,KAAK,IAAI,IAAI,qBAAqB,IAAI,CAAC;gBAAE,MAAM;YAExE,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC9C,MAAM,UAAU,GAAG,sBAAsB,CACvC,IAAI,EACJ,KAAK,CAAC,aAAa,EACnB,SAAS,EACT,qBAAqB,CACtB,CAAC;YAEF,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7B,MAAM,IAAI,UAAU,CAAC,KAAK,CAAC;YAC3B,IAAI,qBAAqB,KAAK,IAAI,EAAE,CAAC;gBACnC,qBAAqB,IAAI,UAAU,CAAC,KAAK,CAAC;YAC5C,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC/D,4EAA4E;IAC5E,4EAA4E;IAC5E,MAAM,cAAc,GAAG,gBAAgB,KAAK,IAAI;QAC9C,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,gBAAgB,CAAC;QACnC,CAAC,CAAC,KAAK,CAAC;IACV,MAAM,OAAO,GAAG,uBAAuB,CAAC,WAAW,CAAC,CAAC;IACrD,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,CAAiB,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;QACjE,MAAM,GAAG,GAAG,CAAC,CAAC,QAAQ,CAAC,WAAW,IAAI,MAAM,CAAC;QAC7C,OAAO,YAAY,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/D,CAAC,EAAE,MAAM,CAAC,CAAC;IACX,+DAA+D;IAC/D,MAAM,mBAAmB,GACvB,gBAAgB,KAAK,IAAI,IAAI,cAAc,GAAG,KAAK,IAAI,cAAc,KAAK,gBAAgB;QACxF,CAAC,CAAC,kBAAkB;QACpB,CAAC,CAAC,UAAU,CAAC;IACjB,MAAM,aAAa,GACjB,WAAW;SACR,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC;SACrC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC;SACrC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IACvB,MAAM,mBAAmB,GAAG,WAAW,CAAC,MAAM,CAC5C,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,QAAQ,CAAC,qBAAqB,EAClD,CAAC,CACF,CAAC;IAEF,OAAO;QACL,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,cAAc,CAAC;QACxC,KAAK,EAAE,WAAW;QAClB,OAAO;QACP,WAAW,EAAE,mBAAmB;QAChC,cAAc,EAAE,aAAa;QAC7B,qBAAqB,EAAE,mBAAmB;KAC3C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAS,sBAAsB,CAC7B,IAAkB,EAClB,aAA4B,EAC5B,SAAmB,EACnB,qBAAoC;IAEpC,gEAAgE;IAChE,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC;IACjE,IAAI,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/E,qFAAqF;IACrF,IAAI,qBAAqB,KAAK,IAAI,EAAE,CAAC;QACnC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,qBAAqB,CAAC,CAAC;IACjE,CAAC;IAED,kCAAkC;IAClC,IAAI,cAAc,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;IACvD,IAAI,UAAU,GAAG,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,cAAc,CAAC,CAAC;IAEnE,+DAA+D;IAC/D,OAAO,cAAc,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU,CAAC,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC;QAC7E,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC;QACjC,cAAc,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QACxD,UAAU,GAAG,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,cAAc,CAAC,CAAC;IACjE,CAAC;IAED,oFAAoF;IACpF,IACE,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,IAAI,MAAM,CAAC,KAAK,MAAM;QACtD,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,IAAI,MAAM,CAAC,KAAK,MAAM,EACvD,CAAC;QACD,UAAU,GAAG;YACX,GAAG,UAAU;YACb,QAAQ,EAAE;gBACR,GAAG,UAAU,CAAC,QAAQ;gBACtB,WAAW,EAAE,WAAW,CAAC,QAAQ,CAAC,WAAW;aAC9C;SACF,CAAC;IACJ,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAS,YAAY,CACnB,IAAkB,EAClB,aAA4B,EAC5B,UAAoB;IAEpB,MAAM,QAAQ,GAAG,YAAY,CAAC;QAC5B,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,aAAa;QACb,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,oBAAoB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC;QACpD,mBAAmB,EAAE,UAAU;QAC/B,eAAe,EAAE,IAAI,CAAC,eAAe,IAAI,IAAI;QAC7C,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;QAC/C,gBAAgB,EAAE,IAAI,CAAC,gBAAgB,IAAI,IAAI;QAC/C,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,IAAI,IAAI;KACtD,CAAC,CAAC;IACH,OAAO;QACL,OAAO,EAAE,IAAI,CAAC,EAAE;QAChB,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,KAAK,EAAE,UAAU,CAAC,MAAM,GAAG,CAAC;YAC1B,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC,MAAM,CAAC;YACtD,CAAC,CAAC,QAAQ,CAAC,cAAc;QAC3B,QAAQ;KACT,CAAC;AACJ,CAAC;AAED,SAAS,uBAAuB,CAC9B,WAAqC;IAErC,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE;QAC5C,IAAI,SAAS,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACnC,OAAO,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;QACzD,CAAC;QACD,MAAM,gBAAgB,GAAG,SAAS,CAAC,QAAQ,CAAC,eAAe,CAAC,cAAc,CAAC;QAC3E,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,cAAc,CAAC;QACjE,IAAI,gBAAgB,KAAK,WAAW,EAAE,CAAC;YACrC,OAAO,gBAAgB,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3D,CAAC;QACD,OAAO,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7D,CAAC,EAAE,WAAW,CAAC,CAAC,CAAE,CAAC,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,8BAA8B,CAC5C,QAA0B;IAE1B,OAAO,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QACzC,OAAO,EAAE,UAAU,CAAC,OAAO;QAC3B,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACrD,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,KAAK,EAAE,UAAU,CAAC,QAAQ,CAAC,KAAK;QAChC,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC,UAAU;QAC1C,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,MAAM;QAClC,eAAe,EAAE,UAAU,CAAC,QAAQ,CAAC,eAAe;QACpD,sBAAsB,EAAE,UAAU,CAAC,QAAQ,CAAC,sBAAsB;QAClE,cAAc,EAAE,UAAU,CAAC,QAAQ,CAAC,cAAc;QAClD,qBAAqB,EAAE,UAAU,CAAC,QAAQ,CAAC,qBAAqB;QAChE,WAAW,EAAE,UAAU,CAAC,QAAQ,CAAC,WAAW,IAAI,MAAM;QACtD,qBAAqB,EAAE,UAAU,CAAC,QAAQ,CAAC,qBAAqB,IAAI,IAAI;KACzE,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/shared/quota/claudeCodeJsonLines.d.ts

@@ -0,0 +1,15 @@
+/**
+ * claude-code emits structured JSON, one object per line, interleaved with
+ * non-JSON noise on stderr. Both claude-code strategies — the shared error
+ * parser and audit-code's header extractor — scanned that stream with a
+ * near-identical loop: split on newlines, trim, keep only `{`-prefixed lines,
+ * `JSON.parse` each, and silently skip the ones that are not valid JSON objects.
+ *
+ * `collectClaudeCodeJsonLines` is that single scan (drift-plan E5). It returns
+ * every successfully-parsed JSON *object* line as a plain record; callers apply
+ * their own field predicate (rate-limit fields, header fields, …). Non-object
+ * JSON (arrays, bare numbers/strings) and parse failures are skipped — the
+ * claude-code contract only emits objects per line.
+ */
+export declare function collectClaudeCodeJsonLines(stderr: string): Record<string, unknown>[];
+//# sourceMappingURL=claudeCodeJsonLines.d.ts.map

package/dist/shared/quota/claudeCodeJsonLines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCodeJsonLines.d.ts","sourceRoot":"","sources":["../../../src/shared/quota/claudeCodeJsonLines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAiB3B"}

package/dist/shared/quota/claudeCodeJsonLines.js

@@ -0,0 +1,34 @@
+/**
+ * claude-code emits structured JSON, one object per line, interleaved with
+ * non-JSON noise on stderr. Both claude-code strategies — the shared error
+ * parser and audit-code's header extractor — scanned that stream with a
+ * near-identical loop: split on newlines, trim, keep only `{`-prefixed lines,
+ * `JSON.parse` each, and silently skip the ones that are not valid JSON objects.
+ *
+ * `collectClaudeCodeJsonLines` is that single scan (drift-plan E5). It returns
+ * every successfully-parsed JSON *object* line as a plain record; callers apply
+ * their own field predicate (rate-limit fields, header fields, …). Non-object
+ * JSON (arrays, bare numbers/strings) and parse failures are skipped — the
+ * claude-code contract only emits objects per line.
+ */
+export function collectClaudeCodeJsonLines(stderr) {
+    const objects = [];
+    for (const line of stderr.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            // Not valid JSON — skip (matches the prior best-effort scan).
+            continue;
+        }
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            objects.push(parsed);
+        }
+    }
+    return objects;
+}
+//# sourceMappingURL=claudeCodeJsonLines.js.map

package/dist/shared/quota/claudeCodeJsonLines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCodeJsonLines.js","sourceRoot":"","sources":["../../../src/shared/quota/claudeCodeJsonLines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,0BAA0B,CACxC,MAAc;IAEd,MAAM,OAAO,GAA8B,EAAE,CAAC;IAC9C,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,SAAS;QACvC,IAAI,MAAe,CAAC;QACpB,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC;QAAC,MAAM,CAAC;YACP,8DAA8D;YAC9D,SAAS;QACX,CAAC;QACD,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5E,OAAO,CAAC,IAAI,CAAC,MAAiC,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}