llm-cli-gateway 2.16.0 → 2.17.0

package/.agents/skills/least-cost-routing/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: least-cost-routing
+description: Route a model-agnostic request to the cheapest capable (provider, model) via route_request, subject to a quality-tier floor and a hard budget cap. Use when you do not care WHICH model runs a task, only that it is cheap enough and good enough.
+metadata:
+  author: verivus-oss
+  version: "1.0"
+---
+
+# Least-cost routing (route_request)
+
+`route_request` (sync) and `route_request_async` (async) pick the **cheapest
+eligible `(provider, model)`** candidate that meets your constraints, then
+dispatch it through the normal provider path. They are **dormant by default**:
+registered only when `[least_cost].enabled = true` in
+`~/.llm-cli-gateway/config.toml`. If the tools are absent, routing is off; use a
+specific provider tool instead.
+
+## When to use this vs a named provider tool
+
+- Use `route_request` when the task is model-agnostic (summarize, answer,
+  classify, rewrite) and you want the cheapest model that clears a quality floor.
+- Use `claude_request` / `codex_request` / etc. when you need a SPECIFIC model or
+  provider, a provider-specific flag, session resume, or a worktree. In phase_1
+  `route_request` is fresh one-shot only (no `sessionId` / `workspace` /
+  `worktree`).
+
+## Inputs
+
+- `prompt` (or `promptParts`): the request. Exactly one.
+- `minTier`: `economy | standard | frontier` (default `standard`). A hard floor,
+  never downgraded to save money.
+- `maxCostUsd`: per-request budget cap. Over-budget fails closed.
+- `expectedOutputTokens` / `maxOutputTokens`: tune the ranking and the
+  conservative budget bound.
+- `requiredCapabilities`: `{ images?, attachments?, toolCalling?, jsonSchema?,
+  outputFormat?, effort? }`. A candidate missing a required capability is
+  excluded.
+- `candidates`: an explicit `(provider, model)[]` to restrict the pool (also
+  whitelists otherwise-untiered / maintain-only candidates like cursor/devin).
+- `allowUnpriced` + `budgetWaiver`: BOTH are required to admit an unpriced
+  (`source: "unknown"`) candidate. An unpriced candidate always ranks strictly
+  last and cannot win over any priced candidate.
+- `fallback`: a `(provider, model)` used ONLY when the eligible pool is empty;
+  bypasses cost ranking but still passes eligibility and (unless `budgetWaiver`)
+  the budget gate.
+
+## Reading the result
+
+Every routed response carries a `routing` block in `structuredContent.routing`,
+and a one-line `[routing] chosen=... est=$... (basis, confidence) considered=N
+reroutes=M` banner prepended to the text. Fields: `chosen`, `tier`,
+`estCostUsd`, `costBasis` (`provider-reported | derived-from-tokens |
+pre-flight-estimate`), `confidence`, `nearTie`, `estInputTokens`,
+`estOutputTokens`, `priceAsOf`, `priceSource`, `consideredCount`,
+`rejected: [{candidate, reason}]`, `reroutes`, and (on failure) `error`.
+
+`estCostUsd` is always an ESTIMATE labelled with its inputs, never a billed cost.
+
+## Failure semantics (fail closed)
+
+- Over budget: `routing.error = "BudgetExceeded"`, `isError: true`. Raise
+  `maxCostUsd` rather than expecting a silent downgrade.
+- No eligible candidate: `routing.error = "NoEligibleCandidate"` with the
+  per-candidate rejection reasons (auth / breaker / capacity / capability / tier
+  / price / budget). Loosen `minTier`, add `candidates`, or set
+  `allowUnpriced` + `budgetWaiver`.
+- Transient dispatch failure (breaker trip, timeout): LCR re-selects over the
+  remaining pool up to `[least_cost].max_reroutes`. Non-transient failures drop
+  the candidate and continue.
+
+## Observability (phase_2)
+
+When routing is enabled, three read-only surfaces expose how it is behaving
+(all economics-only, no prompts/secrets/principal):
+
+- `routing://decisions` (MCP resource): the recent routed decisions, each with
+  `provider`/`model`, `estCostUsd`, `costBasis`, `confidence`, `reason`,
+  `considered`, `reroutes`, `at`.
+- `routing://priors` (MCP resource): the learned per-`(provider,model)`
+  output-token priors (median/p90/samples), the per-`(content-type,family)`
+  input calibration `k` + sample count + confidence, and `priceAsOf`. Priors are
+  anonymized model-level economics; `priors_scope` (`global | principal | off`)
+  scopes the learning (or disables it).
+- `llm_process_health` gains a `leastCost` block: per-provider telemetry tier
+  (T1..T4) and per-candidate eligibility (priced? / authed? / breaker? / tier?).
+- `doctor --json` gains a `least_cost` block: pricing `asOf` + staleness,
+  per-provider telemetry tier, per-candidate eligibility, untiered models, and
+  per-`(content-type,family)` calibration quality (`k`/samples/confidence).
+
+API-provider models are priced from a published catalog (`prefer_catalog_price`
+picks catalog over the CLI table when both resolve).
+
+## Cheapest-reviewer selection (phase_3)
+
+`validate_with_models`, `red_team_review`, `consensus_check`, `second_opinion`,
+and `ask_model` accept an OPT-IN `select: "cheapest" | "cheapest_per_tier"`. When
+omitted, the explicit `models`/`model` list is used verbatim (default unchanged).
+When set, the reviewer target list is filled via the LCR selector:
+`cheapest` picks the single cheapest eligible provider; `cheapest_per_tier` picks
+the cheapest provider in each quality tier (economy/standard/frontier). It fails
+closed (no jobs started) when `[least_cost].enabled` is false or nothing is
+eligible.
+
+## Config (operator, `~/.llm-cli-gateway/config.toml`)
+
+```toml
+[least_cost]
+enabled = true                 # nothing routes until this is true
+min_tier = "standard"
+max_cost_usd = 0.50
+allow_unpriced = false
+max_reroutes = 2
+
+[least_cost.tiers]             # (provider:family) -> tier; ships with defaults
+"claude:claude-opus" = "frontier"
+
+[least_cost.candidates]
+allow = []                     # empty = all eligible
+deny = []
+```
+
+See `docs/least-cost-routing-contract.md` for the frozen decisions and
+invariants.

package/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to the llm-cli-gateway project.
 
 ## [Unreleased]
 
+## [2.17.0] - 2026-07-13
+
+### Added
+
+- **Least-cost routing.** `route_request` and `route_request_async` select the
+  cheapest eligible provider and model within a quality floor, budget cap, and
+  current capacity constraints. The router now exposes pricing, estimates,
+  route decisions, health, and learned cost priors through `routing://`
+  resources.
+- **Cheapest eligible validation.** `validate_with_models` can now select a
+  least-cost eligible model rather than requiring callers to name one.
+- **Supply-chain release guards.** Dependency drift, tag-along packages,
+  unexpected install scripts, licenses, and policy changes are checked before
+  release, with fail-closed protection for uncertain findings.
+
+### Fixed
+
+- **Durable Postgres job-store recovery.** Replaced temporary-file worker
+  result handoff with in-process message channels, preserving failure detail
+  and avoiding host `/tmp` inode exhaustion. A failed bridge now retires and
+  recreates its worker safely, and durable admission recovers only after a
+  successful re-registration.
+- **Async availability reporting and lifecycle.** Readiness and process health
+  now reflect durable-admission state, configured-store startup failures exit
+  for supervised recovery, and shutdown reliably closes the job store.
+- **Release and test gates.** The lint command now checks the actual source
+  tree, and Postgres integration tests work with either Docker or Podman.
+
 ## [2.16.0] - 2026-07-10
 
 ### Added

package/dist/acp/client.js

@@ -1,6 +1,7 @@
 import { AcpMethodUnsupportedError, AcpMutatingDisabledError, AcpProtocolError, isAcpError, } from "./errors.js";
 import { deriveAcpMethodAvailability, parseCloseSessionResponse, parseDeleteSessionResponse, parseInitializeResponse, parseListSessionsResponse, parseReadTextFileRequest, parseRequestPermissionRequest, parseSessionLoadResponse, parseSessionNewResponse, parseSessionPromptResponse, parseSessionResumeResponse, parseSessionUpdateNotification, parseSetSessionConfigOptionResponse, parseSetSessionModeResponse, parseWriteTextFileRequest, sessionResponseMethods, } from "./types.js";
 import { noopLogger } from "../logger.js";
+import { gatewayVersion } from "../provider-capability-discovery.js";
 export const DEFAULT_ACP_PROTOCOL_VERSION = 1;
 export class AcpClient {
     transport;
@@ -47,6 +48,10 @@ export class AcpClient {
         }
         const params = {
             protocolVersion: this.protocolVersion,
+            clientInfo: {
+                name: "llm-cli-gateway",
+                version: gatewayVersion(),
+            },
             clientCapabilities: {
                 fs: {
                     readTextFile: options.readTextFile ?? false,

package/dist/acp/flight-redaction.d.ts

@@ -24,5 +24,7 @@ export interface AcpFlightResultParams {
     readonly errorMessage?: string;
     readonly providerSessionId?: string;
     readonly stopReason?: string;
+    readonly costUsd?: number;
+    readonly costBasis?: string;
 }
 export declare function buildAcpFlightResult(params: AcpFlightResultParams): FlightLogResult;

package/dist/acp/flight-redaction.js

@@ -39,5 +39,7 @@ export function buildAcpFlightResult(params) {
         errorMessage: params.errorMessage !== undefined ? redactAcpTextForFlight(params.errorMessage) : undefined,
         providerSessionId: params.providerSessionId,
         stopReason: params.stopReason,
+        costUsd: params.costUsd,
+        costBasis: params.costBasis,
     };
 }

package/dist/acp/runtime.d.ts

@@ -38,6 +38,7 @@ export interface AcpPromptUsage {
     inputTokens?: number;
     outputTokens?: number;
     cacheReadTokens?: number;
+    reasoningTokens?: number;
 }
 export declare function extractAcpPromptUsage(meta: unknown): AcpPromptUsage;
 export declare function runAcpRequest(deps: AcpRuntimeDeps, req: AcpRunRequest): Promise<AcpRunResult>;

package/dist/acp/runtime.js

@@ -6,6 +6,7 @@ import { createAcpPermissionDecider } from "./permission-bridge.js";
 import { AcpProcessManager } from "./process-manager.js";
 import { createAcpSession, recordAcpSessionInfo, resolveAcpResume } from "./session-map.js";
 import { DEVIN_ACP_AGENT_TYPES } from "../provider-definitions.js";
+import { composeCost, getModelCost } from "../pricing.js";
 import { noopLogger } from "../logger.js";
 export function extractAcpPromptUsage(meta) {
     if (!meta || typeof meta !== "object" || Array.isArray(meta))
@@ -22,6 +23,9 @@ export function extractAcpPromptUsage(meta) {
     const cacheReadTokens = num(record.cachedReadTokens);
     if (cacheReadTokens !== undefined)
         usage.cacheReadTokens = cacheReadTokens;
+    const reasoningTokens = num(record.reasoningTokens);
+    if (reasoningTokens !== undefined)
+        usage.reasoningTokens = reasoningTokens;
     return usage;
 }
 export async function runAcpRequest(deps, req) {
@@ -120,6 +124,20 @@ export async function runAcpRequest(deps, req) {
         const text = normalizer.finalText;
         const durationMs = elapsed();
         const usage = extractAcpPromptUsage(promptResult._meta);
+        let costUsd;
+        let costBasis;
+        const modelCost = getModelCost(req.provider, req.model ?? "default");
+        if (modelCost.source !== "unknown" &&
+            (usage.inputTokens !== undefined || usage.outputTokens !== undefined)) {
+            const composed = composeCost({
+                inputTokens: usage.inputTokens ?? 0,
+                outputTokens: usage.outputTokens ?? 0,
+                cacheReadTokens: usage.cacheReadTokens,
+                reasoningTokens: usage.reasoningTokens,
+            }, { estInputTokens: 0, estOutputTokens: 0 }, modelCost);
+            costUsd = composed.costUsd;
+            costBasis = composed.cost_basis;
+        }
         deps.flightRecorder?.logComplete(req.correlationId, buildAcpFlightResult({
             responseText: text,
             durationMs,
@@ -130,6 +148,8 @@ export async function runAcpRequest(deps, req) {
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             cacheReadTokens: usage.cacheReadTokens,
+            costUsd,
+            costBasis,
         }));
         logger.info("acp.request.success", { provider: req.provider, durationMs });
         return {

package/dist/acp/types.d.ts

@@ -54,8 +54,34 @@ export declare const ClientCapabilitiesSchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">>>;
     terminal: z.ZodOptional<z.ZodBoolean>;
 }, z.ZodTypeAny, "passthrough">>;
+export declare const ClientInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
 export declare const InitializeRequestSchema: z.ZodObject<{
     protocolVersion: z.ZodNumber;
+    clientInfo: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
     clientCapabilities: z.ZodOptional<z.ZodObject<{
         fs: z.ZodOptional<z.ZodObject<{
             readTextFile: z.ZodOptional<z.ZodBoolean>;
@@ -96,6 +122,19 @@ export declare const InitializeRequestSchema: z.ZodObject<{
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     protocolVersion: z.ZodNumber;
+    clientInfo: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
     clientCapabilities: z.ZodOptional<z.ZodObject<{
         fs: z.ZodOptional<z.ZodObject<{
             readTextFile: z.ZodOptional<z.ZodBoolean>;
@@ -136,6 +175,19 @@ export declare const InitializeRequestSchema: z.ZodObject<{
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     protocolVersion: z.ZodNumber;
+    clientInfo: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
     clientCapabilities: z.ZodOptional<z.ZodObject<{
         fs: z.ZodOptional<z.ZodObject<{
             readTextFile: z.ZodOptional<z.ZodBoolean>;

package/dist/acp/types.js

@@ -50,9 +50,17 @@ export const ClientCapabilitiesSchema = z
     terminal: z.boolean().optional(),
 })
     .passthrough();
+export const ClientInfoSchema = z
+    .object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    title: z.string().min(1).optional(),
+})
+    .passthrough();
 export const InitializeRequestSchema = z
     .object({
     protocolVersion: ProtocolVersionSchema,
+    clientInfo: ClientInfoSchema.optional(),
     clientCapabilities: ClientCapabilitiesSchema.optional(),
     _meta: MetaSchema,
 })

package/dist/api-provider.d.ts

@@ -25,6 +25,7 @@ export interface ApiUsage {
     inputTokens?: number;
     outputTokens?: number;
     cacheReadTokens?: number;
+    cacheCreationTokens?: number;
     costUsd?: number;
     raw?: unknown;
 }

package/dist/api-provider.js

@@ -126,6 +126,7 @@ export class AnthropicProvider {
                 inputTokens: firstNumber(usage.input_tokens),
                 outputTokens: firstNumber(usage.output_tokens),
                 cacheReadTokens: firstNumber(usage.cache_read_input_tokens),
+                cacheCreationTokens: firstNumber(usage.cache_creation_input_tokens),
                 raw: usage,
             },
             raw: parsed,

package/dist/async-job-manager.d.ts

@@ -37,6 +37,7 @@ export interface JobLimiterSnapshot {
     timedOut: number;
     saturated: boolean;
 }
+export declare function providerAtCapacity(snapshot: JobLimiterSnapshot, provider: string): boolean;
 export interface AsyncJobFlightRecorderEntry {
     model: string;
     prompt: string;
@@ -53,6 +54,7 @@ export type AsyncJobUsageExtractor = (stdout: string) => {
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
     costUsd?: number;
+    costBasis?: string;
 };
 export interface AsyncJobSnapshot {
     id: string;
@@ -120,12 +122,25 @@ export declare class AsyncJobManager {
     private sweepTimer;
     private durableAdmission;
     private consecutiveHeartbeatFailures;
+    private consecutiveHeartbeatSuccesses;
+    private lastHeartbeatFailureAt;
+    private lastHeartbeatRecoveryAt;
+    private lastHeartbeatErrorName;
     private skipSweepThisCycle;
     private nextHeartbeatExpectedAt;
     private disposed;
     private readonly pendingWrites;
     constructor(logger?: Logger, onJobComplete?: ((cli: JobProvider, durationMs: number, success: boolean) => void) | undefined, store?: JobStore | null, flightRecorder?: FlightRecorderLike, limits?: JobLimitsConfig, _deprecatedOwnsOrphanRecovery?: boolean, leaseConfig?: LeaseRuntimeConfig);
     canAdmitDurableJobs(): boolean;
+    getDurableAdmissionHealth(): {
+        storeAttached: boolean;
+        admitting: boolean;
+        consecutiveHeartbeatFailures: number;
+        consecutiveHeartbeatSuccesses: number;
+        lastHeartbeatFailureAt: string | null;
+        lastHeartbeatRecoveryAt: string | null;
+        lastHeartbeatErrorName: string | null;
+    };
     private assertDurableAdmission;
     private trackPendingWrite;
     dispose(opts?: {
@@ -136,6 +151,7 @@ export declare class AsyncJobManager {
     private onHeartbeatTick;
     runOrphanSweepNow(): void;
     private startReaper;
+    private restoreDurableAdmission;
     private runOrphanSweep;
     private confirmLiveProcessCandidates;
     private recordStartOrFailClosed;

package/dist/async-job-manager.js

@@ -20,6 +20,7 @@ const DEFAULT_LEASE_RUNTIME_CONFIG = {
     role: "gateway",
 };
 const MAX_CONSECUTIVE_HEARTBEAT_FAILURES = 3;
+const MIN_CONSECUTIVE_HEARTBEAT_SUCCESSES_TO_RECOVER = 3;
 export function extractApiHttpStatus(error) {
     for (const candidate of [error, error?.cause]) {
         if (candidate instanceof ApiHttpError && typeof candidate.status === "number") {
@@ -72,6 +73,9 @@ export class JobSaturationError extends Error {
         this.name = "JobSaturationError";
     }
 }
+export function providerAtCapacity(snapshot, provider) {
+    return (snapshot.runningByProvider[provider] ?? 0) >= snapshot.maxRunningPerProvider;
+}
 class JobLimiter {
     cfg;
     logger;
@@ -258,6 +262,10 @@ export class AsyncJobManager {
     sweepTimer = null;
     durableAdmission;
     consecutiveHeartbeatFailures = 0;
+    consecutiveHeartbeatSuccesses = 0;
+    lastHeartbeatFailureAt = null;
+    lastHeartbeatRecoveryAt = null;
+    lastHeartbeatErrorName = null;
     skipSweepThisCycle = false;
     nextHeartbeatExpectedAt = 0;
     disposed = false;
@@ -278,25 +286,11 @@ export class AsyncJobManager {
             maxQueuedJobs: limits.maxQueuedJobs,
             queueTimeoutMs: limits.queueTimeoutMs,
         }, logger);
-        this.durableAdmission = store !== null;
+        this.durableAdmission = false;
         if (this.store) {
-            try {
-                this.store.registerInstance({
-                    instanceId: this.instanceId,
-                    role: this.lease.role ?? "gateway",
-                    hostname: this.hostname,
-                    pid: this.instancePid,
-                });
-            }
-            catch (err) {
-                this.durableAdmission = false;
-                this.logger.error("#139 registerInstance failed; durable async admission is disabled for this instance", err);
-            }
-            if (this.durableAdmission) {
-                this.runOrphanSweep();
-                this.startHeartbeat();
-                this.startReaper();
-            }
+            this.restoreDurableAdmission("startup");
+            this.startHeartbeat();
+            this.startReaper();
         }
         this.evictionTimer = setInterval(() => this.evictCompletedJobs(), EVICTION_INTERVAL_MS);
         if (this.evictionTimer.unref) {
@@ -310,6 +304,17 @@ export class AsyncJobManager {
     canAdmitDurableJobs() {
         return this.store !== null && this.durableAdmission;
     }
+    getDurableAdmissionHealth() {
+        return {
+            storeAttached: this.store !== null,
+            admitting: this.canAdmitDurableJobs(),
+            consecutiveHeartbeatFailures: this.consecutiveHeartbeatFailures,
+            consecutiveHeartbeatSuccesses: this.consecutiveHeartbeatSuccesses,
+            lastHeartbeatFailureAt: this.lastHeartbeatFailureAt,
+            lastHeartbeatRecoveryAt: this.lastHeartbeatRecoveryAt,
+            lastHeartbeatErrorName: this.lastHeartbeatErrorName,
+        };
+    }
     assertDurableAdmission(provider) {
         if (this.store && !this.durableAdmission) {
             throw new Error(`Durable async admission is disabled for ${provider}: this gateway instance could not register or lost its heartbeat lease. Retry after the gateway recovers.`);
@@ -394,13 +399,23 @@ export class AsyncJobManager {
         try {
             this.store.heartbeat(this.instanceId);
             this.consecutiveHeartbeatFailures = 0;
+            if (!this.durableAdmission) {
+                this.consecutiveHeartbeatSuccesses++;
+                if (this.consecutiveHeartbeatSuccesses >= MIN_CONSECUTIVE_HEARTBEAT_SUCCESSES_TO_RECOVER) {
+                    this.restoreDurableAdmission("heartbeat recovery");
+                }
+            }
         }
         catch (err) {
             this.consecutiveHeartbeatFailures++;
+            this.consecutiveHeartbeatSuccesses = 0;
+            this.lastHeartbeatFailureAt = new Date().toISOString();
+            this.lastHeartbeatErrorName = err instanceof Error ? err.name : typeof err;
             this.logger.error(`#139 heartbeat failed (${this.consecutiveHeartbeatFailures}/${MAX_CONSECUTIVE_HEARTBEAT_FAILURES})`, err);
             if (this.consecutiveHeartbeatFailures >= MAX_CONSECUTIVE_HEARTBEAT_FAILURES) {
                 if (this.durableAdmission) {
                     this.durableAdmission = false;
+                    this.consecutiveHeartbeatSuccesses = 0;
                     this.logger.error("#139 sustained heartbeat failure; disabling durable admission and orphan sweeping on this instance");
                 }
             }
@@ -412,8 +427,10 @@ export class AsyncJobManager {
     startReaper() {
         this.sweepTimer = setInterval(() => {
             this.runOrphanSweep();
+            if (!this.store || this.disposed || !this.durableAdmission)
+                return;
             try {
-                this.store?.gcInstances(this.lease.instanceGcMs);
+                this.store.gcInstances(this.lease.instanceGcMs);
             }
             catch (err) {
                 this.logger.error("#139 gateway_instances GC failed", err);
@@ -422,6 +439,35 @@ export class AsyncJobManager {
         if (this.sweepTimer.unref)
             this.sweepTimer.unref();
     }
+    restoreDurableAdmission(reason) {
+        if (!this.store || this.disposed)
+            return;
+        try {
+            this.store.registerInstance({
+                instanceId: this.instanceId,
+                role: this.lease.role ?? "gateway",
+                hostname: this.hostname,
+                pid: this.instancePid,
+            });
+            this.store.heartbeat(this.instanceId);
+            const wasDisabled = !this.durableAdmission;
+            this.durableAdmission = true;
+            this.consecutiveHeartbeatFailures = 0;
+            this.consecutiveHeartbeatSuccesses = 0;
+            this.lastHeartbeatRecoveryAt = new Date().toISOString();
+            if (wasDisabled && reason === "heartbeat recovery") {
+                this.logger.info("#139 durable heartbeat recovered; re-enabled async admission and orphan sweeping");
+            }
+            this.runOrphanSweep();
+        }
+        catch (err) {
+            this.durableAdmission = false;
+            this.consecutiveHeartbeatSuccesses = 0;
+            this.lastHeartbeatFailureAt = new Date().toISOString();
+            this.lastHeartbeatErrorName = err instanceof Error ? err.name : typeof err;
+            this.logger.error(`#139 ${reason} register/heartbeat failed; durable async admission remains disabled`, err);
+        }
+    }
     runOrphanSweep() {
         if (!this.store || this.disposed || !this.durableAdmission)
             return;
@@ -493,13 +539,13 @@ export class AsyncJobManager {
                 acq.cancel();
             this.jobs.delete(job.id);
             this.logger.error(`#139 durable recordStart failed for job ${job.id}; failing the request (fail-closed)`, err);
-            throw new Error(`Durable job admission failed for ${job.cli}: the job store rejected recordStart`);
+            throw new Error(`Durable job admission failed for ${job.cli}: the job store rejected recordStart`, { cause: err });
         }
     }
     markRunningDurable(job, pid, failClosed = false) {
         if (!this.store)
             return;
-        let transitioned = false;
+        let transitioned;
         try {
             transitioned = this.store.markRunning(job.id, { pid });
         }
@@ -645,7 +691,7 @@ export class AsyncJobManager {
         if (evicted > 0) {
             this.logger.debug(`Evicted ${evicted} completed jobs from memory (durable store retains them)`);
         }
-        if (this.store) {
+        if (this.store && this.durableAdmission) {
             try {
                 const removed = this.store.evictExpired();
                 if (removed > 0) {
@@ -938,6 +984,7 @@ export class AsyncJobManager {
                 cacheReadTokens: usage.cacheReadTokens,
                 cacheCreationTokens: usage.cacheCreationTokens,
                 costUsd: usage.costUsd,
+                costBasis: usage.costBasis,
                 providerSessionId: providerMeta?.sessionId,
                 stopReason: providerMeta?.stopReason,
             });
@@ -966,6 +1013,7 @@ export class AsyncJobManager {
             inputTokens: u.inputTokens,
             outputTokens: u.outputTokens,
             cacheReadTokens: u.cacheReadTokens,
+            cacheCreationTokens: u.cacheCreationTokens,
             costUsd: u.costUsd,
         };
     }

package/dist/claude-mcp-config.js

@@ -147,7 +147,7 @@ export function buildClaudeMcpConfig(servers) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to write Claude MCP config: ${message}`);
+        throw new Error(`Failed to write Claude MCP config: ${message}`, { cause: error });
     }
     return { path: configPath, enabled, missing };
 }

package/dist/compressor/transforms/ansi.js

@@ -45,7 +45,17 @@ function stripEscapes(text) {
         .replace(ESC_TWO_BYTE, "")
         .replace(STRAY_C0, "");
 }
-const ASCII_ONLY = /^[\x09\x0d\x20-\x7e]*$/;
+function isSingleColumnAsciiFrame(text) {
+    for (const character of text) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint !== 0x09 &&
+            codePoint !== 0x0d &&
+            (codePoint === undefined || codePoint < 0x20 || codePoint > 0x7e)) {
+            return false;
+        }
+    }
+    return true;
+}
 function overlayFrames(frames) {
     const cells = [];
     for (const frame of frames) {
@@ -61,7 +71,7 @@ function collapseLine(line, out, counts) {
         out.push(line);
         return;
     }
-    if (!ASCII_ONLY.test(body)) {
+    if (!isSingleColumnAsciiFrame(body)) {
         out.push(line);
         return;
     }