audit-tools 0.32.8 → 0.32.9

package/dist/remediate/steps/dispatch.js

@@ -9,6 +9,7 @@ import { verifyPairingForFinding } from "../contractPipeline/changeClassificatio
 import { spawnSync } from "node:child_process";
 import { StateStore } from "../state/store.js";
 import { REMEDIATION_STEP, isClarificationCategory, } from "../state/types.js";
+import { computeDispatchAdmission, createReservationLedger, tierRank } from "audit-tools/shared";
 import { withFileLock } from "audit-tools/shared";
 import { captureStepBoundaryFriction } from "audit-tools/shared";
 import { findingLead, renderFindingBadgeBody } from "audit-tools/shared";
@@ -264,7 +265,39 @@ export async function buildConfirmedPools(input) {
     primaryPools.push(...sourcePools);
     return primaryPools;
 }
-export function buildDispatchQuota(runId, phase, schedule, quotaStateEntry) {
+/**
+ * Build the `AdmissionPool[]` the admission loop admits against from a schedule's
+ * per-pool capacity summaries — the remediate analog of audit's `finalizeDispatchQuota`
+ * pool mapping (both feed the single-sourced `computeDispatchAdmission`, so the two
+ * orchestrators can't drift). Budget = the pool's live remaining token budget
+ * (null ⇒ optimistic +Inf); declared cap = its host in-flight cap passed VERBATIM
+ * (null ⇒ none — the only place an explicit agent-count exists); cost/capability rank
+ * from its tier; capacity = its context window (a packet's input+output envelope must fit).
+ */
+function admissionPoolsFromSchedule(schedule) {
+    return (schedule.capacity_pools ?? []).map((pool) => {
+        const rankNum = tierRank(pool.rank);
+        return {
+            poolId: pool.pool_id,
+            resourceKey: pool.pool_id,
+            budget: pool.remaining_token_budget ?? Number.POSITIVE_INFINITY,
+            declaredCap: pool.host_concurrency_limit?.active_subagents ?? null,
+            costRank: rankNum,
+            capabilityRank: rankNum,
+            capacityTokens: pool.resolved_limits.context_tokens,
+        };
+    });
+}
+export async function buildDispatchQuota(runId, phase, schedule, admissionPackets, 
+/**
+ * Whether to LEASE the granted set against the shared reservation ledger. The
+ * host-subagent path passes `true` (the host dispatches the grant across processes,
+ * so the tool reserves-before-dispatch and reconciles at accept-node). The
+ * in-process rolling engine passes `false`: it admits + leases per-packet itself, so
+ * a host-grant lease here would double-count the same work. Mirrors audit's
+ * `finalizeDispatchQuota` grantLeases parameterization.
+ */
+grantLeases, quotaStateEntry) {
     let backoffState = null;
     const count = quotaStateEntry?.consecutive_429_count ?? 0;
     if (count > 0) {
@@ -274,12 +307,23 @@ export function buildDispatchQuota(runId, phase, schedule, quotaStateEntry) {
             current_failure_weight: computeBackoffFailureWeight(count),
         };
     }
+    // Admission control: instead of a computed `max_concurrent_agents`, GRANT the
+    // affordable admitted set (cost-first-capable, ledger-leased). Per-packet reservation
+    // = input estimate + output envelope (declared output cap; the learned ratio refines
+    // it once a provider reports usage — dormant on the always-on claude-code host).
+    const admission = await computeDispatchAdmission({
+        packets: admissionPackets,
+        pools: admissionPoolsFromSchedule(schedule),
+        outputCap: schedule.resolved_limits.output_tokens,
+        grantLeases,
+        ledger: createReservationLedger(),
+    });
     return {
         contract_version: REMEDIATION_DISPATCH_QUOTA_CONTRACT_VERSION,
         run_id: runId,
         phase,
         host_concurrency_limit: schedule.host_concurrency_limit,
-        max_concurrent_agents: schedule.max_concurrent,
+        admission,
         estimated_wave_tokens: schedule.estimated_wave_tokens,
         model: schedule.model,
         confidence: schedule.confidence,
@@ -2332,6 +2376,7 @@ export async function prepareImplementDispatch(options, runId, onlyBlockId, wave
         items,
     };
     await writeJsonFile(dispatchPlanPath(options.artifactsDir, runId, "implement"), plan);
+    const estimatedSlotTokens = itemReadFileLists.map((files) => estimateImplementSlotTokens(files, options.root));
     const schedule = await scheduleWave({
         hostMaxConcurrent: waveOptions?.hostMaxConcurrent,
         sessionConfig: waveOptions?.sessionConfig ?? null,
@@ -2340,11 +2385,20 @@ export async function prepareImplementDispatch(options, runId, onlyBlockId, wave
         hostModels: waveOptions?.hostModels,
         hostModelId: waveOptions?.hostModelId,
         itemCount: items.length,
-        estimatedSlotTokens: itemReadFileLists.map((files) => estimateImplementSlotTokens(files, options.root)),
+        estimatedSlotTokens,
     });
-    process.stderr.write(`[remediate-code] dispatch: implement max_concurrent=${schedule.max_concurrent} of ${items.length} item(s) ` +
+    // Admission packets in plan order: id = the node's block id (what
+    // `admission.granted_packet_ids` references and the host matches to nodes),
+    // inputTokens = its estimated slot cost, complexity = the remediate default 0.5.
+    // Keyed by block_id (same filter the frontier builder uses), so a granted id always
+    // resolves to a frontier node.
+    const admissionPackets = items
+        .map((item, i) => ({ item, inputTokens: estimatedSlotTokens[i] ?? 0 }))
+        .filter((p) => typeof p.item.block_id === "string")
+        .map((p) => ({ id: p.item.block_id, inputTokens: p.inputTokens, complexity: 0.5 }));
+    process.stderr.write(`[remediate-code] dispatch: implement ${items.length} item(s) ` +
         `source=${schedule.source} cap=${schedule.binding_cap ?? "none"}\n`);
-    const quota = buildDispatchQuota(runId, "implement", schedule);
+    const quota = await buildDispatchQuota(runId, "implement", schedule, admissionPackets, waveOptions?.grantLeases ?? true);
     await writeJsonFile(join(dir, "dispatch-quota.json"), quota);
     return plan;
 }
@@ -2870,7 +2924,37 @@ function obligationIdsForFinding(state, findingId) {
         ...(finding.verification_obligation_ids ?? []),
     ];
 }
+/**
+ * Reconcile (free) the reservation-ledger leases the dispatch grant took for this
+ * run's granted set — the "reconcile at result-ingest" half of admission control
+ * (spec/audit/dispatch-admission-control.md), the remediate analog of audit's
+ * `reconcileAdmissionLeases`. The host has now reported the granted set's results, so
+ * those reservations are no longer in flight and their budget returns to the shared
+ * account for the NEXT grant. Best-effort + token-checked (a missing/already-freed
+ * lease is a no-op), so a lost reconcile self-heals via the lease TTL and never blocks
+ * the merge. Only the host-subagent grant persists leases (`grantLeases: true`); the
+ * in-process path leases per-packet in the engine and reconciles there.
+ */
+async function reconcileAdmissionLeases(artifactsDir, runId) {
+    const quotaPath = join(runDir(artifactsDir, runId, "implement"), "dispatch-quota.json");
+    const quota = await readOptionalJsonFile(quotaPath);
+    const leases = quota?.admission?.leases;
+    if (!leases || leases.length === 0)
+        return;
+    const ledger = createReservationLedger();
+    for (const lease of leases) {
+        try {
+            await ledger.reconcile(lease.resource_key, lease.lease_id);
+        }
+        catch {
+            // Best-effort: the lease TTL reclaims budget if a reconcile is lost.
+        }
+    }
+}
 export async function mergeImplementResults(options, runId) {
+    // Free the grant's reservation-ledger leases now that the host has reported the
+    // granted set's results — returns the reserved budget for the next grant.
+    await reconcileAdmissionLeases(options.artifactsDir, runId);
     const plan = await readJsonFile(dispatchPlanPath(options.artifactsDir, runId, "implement"));
     if (plan.contract_version !== REMEDIATION_DISPATCH_PLAN_CONTRACT_VERSION ||
         plan.phase !== "implement") {