@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-MO65K5CH.js

@@ -1,1148 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  gateRouteCorrelation,
-  isExecutionRole
-} from "./chunk-H6IUCY6Q.js";
-import {
-  isAgentCapabilityClass
-} from "./chunk-I47EJPYL.js";
-import {
-  canonicalJson
-} from "./chunk-VQD7NH7Z.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/dispatch/routing-intent.ts
-init_esm_shims();
-var KEYS = /* @__PURE__ */ new Set([
-  "posture",
-  "maxCostUsd",
-  "deadlineMs",
-  "minimumQuality",
-  "requiredCapabilities",
-  "locality",
-  "failover"
-]);
-var POSTURES = /* @__PURE__ */ new Set(["manual", "quality", "balanced", "latency", "economy"]);
-var LOCALITIES = /* @__PURE__ */ new Set(["local-only", "prefer-local", "any"]);
-var FAILOVERS = /* @__PURE__ */ new Set(["none", "approved"]);
-function record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isRoutingIntent(value) {
-  if (!record(value) || Object.keys(value).some((key) => !KEYS.has(key))) return false;
-  return typeof value.posture === "string" && POSTURES.has(value.posture) && (value.maxCostUsd === null || typeof value.maxCostUsd === "number" && Number.isFinite(value.maxCostUsd) && value.maxCostUsd > 0) && (value.deadlineMs === null || typeof value.deadlineMs === "number" && Number.isInteger(value.deadlineMs) && value.deadlineMs > 0) && (value.minimumQuality === null || typeof value.minimumQuality === "number" && value.minimumQuality >= 0 && value.minimumQuality <= 1) && Array.isArray(value.requiredCapabilities) && value.requiredCapabilities.every((entry) => typeof entry === "string" && entry.length > 0) && typeof value.locality === "string" && LOCALITIES.has(value.locality) && typeof value.failover === "string" && FAILOVERS.has(value.failover);
-}
-function parseRoutingIntent(value, pins = {}) {
-  const errors = [];
-  if (value !== void 0 && !record(value)) return { ok: false, errors: ["routing must be an object"] };
-  const input = value === void 0 ? {} : value;
-  for (const key of Object.keys(input)) if (!KEYS.has(key)) errors.push(`routing unknown key: ${key}`);
-  const pinned = pins.target !== void 0 || pins.model !== void 0 || pins.node !== void 0;
-  const posture = input.posture ?? (pinned ? "manual" : "balanced");
-  if (typeof posture !== "string" || !POSTURES.has(posture)) {
-    errors.push("routing.posture must be one of: manual|quality|balanced|latency|economy");
-  }
-  if (pinned && posture !== "manual") errors.push("exact target, model, or node pins require routing.posture manual");
-  const positive = (key) => {
-    const candidate = input[key];
-    if (candidate === void 0) return null;
-    if (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate <= 0) {
-      errors.push(`routing.${key} must be a finite number greater than zero`);
-      return null;
-    }
-    if (key === "deadlineMs" && !Number.isInteger(candidate)) errors.push("routing.deadlineMs must be an integer");
-    return candidate;
-  };
-  const maxCostUsd = positive("maxCostUsd");
-  const deadlineMs = positive("deadlineMs");
-  let minimumQuality = null;
-  if (input.minimumQuality !== void 0) {
-    if (typeof input.minimumQuality !== "number" || !Number.isFinite(input.minimumQuality) || input.minimumQuality < 0 || input.minimumQuality > 1)
-      errors.push("routing.minimumQuality must be between zero and one");
-    else minimumQuality = input.minimumQuality;
-  }
-  const requiredCapabilities = input.requiredCapabilities ?? [];
-  if (!Array.isArray(requiredCapabilities) || requiredCapabilities.some((entry) => typeof entry !== "string" || entry.trim().length === 0) || new Set(requiredCapabilities).size !== requiredCapabilities.length)
-    errors.push("routing.requiredCapabilities must be an array of unique non-empty strings");
-  const locality = input.locality ?? "any";
-  if (typeof locality !== "string" || !LOCALITIES.has(locality)) {
-    errors.push("routing.locality must be one of: local-only|prefer-local|any");
-  }
-  const failover = input.failover ?? "none";
-  if (typeof failover !== "string" || !FAILOVERS.has(failover)) {
-    errors.push("routing.failover must be one of: none|approved");
-  }
-  if (pinned && failover !== "none") errors.push("manual pins imply routing.failover none");
-  if (errors.length > 0) return { ok: false, errors };
-  return {
-    ok: true,
-    intent: {
-      posture,
-      maxCostUsd,
-      deadlineMs,
-      minimumQuality,
-      requiredCapabilities: [...requiredCapabilities],
-      locality,
-      failover
-    }
-  };
-}
-function defaultRoutingIntent(pins) {
-  const parsed = parseRoutingIntent(void 0, pins);
-  if (!parsed.ok) throw new Error(parsed.errors.join("; "));
-  return parsed.intent;
-}
-function routingIntentRejection(input) {
-  const { intent } = input;
-  if (intent.minimumQuality !== null && input.qualityLowerBound < intent.minimumQuality) return "minimum-quality";
-  if (intent.maxCostUsd !== null && input.costUpperBoundUsd > intent.maxCostUsd) return "max-cost";
-  if (intent.deadlineMs !== null && input.endToEndUpperBoundMs > intent.deadlineMs) return "deadline";
-  if (intent.locality === "local-only" && input.candidate.nodeId !== "local") return "local-only";
-  if (intent.requiredCapabilities.some((capability) => !input.capabilities.includes(capability))) {
-    return "required-capabilities";
-  }
-  return null;
-}
-var ROUTE_EXPLANATION_MAX_BYTES = 4096;
-function safeIdentity(candidate) {
-  const safe = (value) => {
-    const redacted = /(?:https?:\/\/|api[_-]?key|token|secret|password)/i.test(value) ? "[redacted]" : value;
-    return redacted.length <= 128 ? redacted : `${redacted.slice(0, 127)}\u2026`;
-  };
-  return {
-    ...candidate,
-    agentId: safe(candidate.agentId),
-    specFingerprint: safe(candidate.specFingerprint),
-    targetId: safe(candidate.targetId),
-    modelId: safe(candidate.modelId),
-    runtimeId: safe(candidate.runtimeId),
-    nodeId: safe(candidate.nodeId),
-    ...candidate.thinkingLevel !== void 0 ? { thinkingLevel: safe(candidate.thinkingLevel) } : {},
-    toolSignature: safe(candidate.toolSignature),
-    promptCompositionHash: safe(candidate.promptCompositionHash),
-    endpointIdentityHash: safe(candidate.endpointIdentityHash),
-    settingsFingerprint: safe(candidate.settingsFingerprint)
-  };
-}
-function explainRouteDecision(decision, intent) {
-  const exclusions = [
-    ...new Set(decision.candidateEvaluations.flatMap((entry) => entry.rejection ? [entry.rejection] : []))
-  ];
-  const explanation = {
-    mode: decision.mode,
-    executedRoute: safeIdentity(decision.executedRoute),
-    shadowRecommendation: decision.mode === "shadow" ? safeIdentity(decision.selected) : null,
-    hardExclusions: exclusions.slice(0, 16),
-    approvedFallbacks: decision.approvedFallbacks.slice(0, 3).map(safeIdentity),
-    costUpperBoundUsd: intent.maxCostUsd,
-    deadlineMs: intent.deadlineMs,
-    confidence: decision.confidence,
-    activeEligible: decision.candidateEvaluations.some(
-      (entry) => entry.rejection === null && entry.activeReadiness.ready
-    ),
-    reasonCodes: decision.reasonCodes.slice(0, 16),
-    decisionHash: decision.decisionHash,
-    agentSelection: {
-      request: decision.agentSelection.request,
-      activation: decision.agentSelection.activation,
-      baselineAgentId: safeIdentity({ ...decision.executedRoute, agentId: decision.agentSelection.baselineAgentId }).agentId,
-      recommendedAgentId: safeIdentity({ ...decision.executedRoute, agentId: decision.agentSelection.recommendedAgentId }).agentId,
-      excluded: decision.agentSelection.evaluations.filter((entry) => entry.rejections.length > 0).slice(0, 16).map((entry) => ({
-        agentId: safeIdentity({ ...decision.executedRoute, agentId: entry.agentId }).agentId,
-        reasons: entry.rejections.slice(0, 8)
-      })),
-      authorityTransition: decision.agentSelection.authorityTransition === null ? null : {
-        ...decision.agentSelection.authorityTransition,
-        from: safeIdentity({
-          ...decision.executedRoute,
-          agentId: decision.agentSelection.authorityTransition.from
-        }).agentId,
-        to: safeIdentity({
-          ...decision.executedRoute,
-          agentId: decision.agentSelection.authorityTransition.to
-        }).agentId
-      }
-    }
-  };
-  if (Buffer.byteLength(JSON.stringify(explanation), "utf8") <= ROUTE_EXPLANATION_MAX_BYTES) return explanation;
-  const compact = {
-    ...explanation,
-    approvedFallbacks: explanation.approvedFallbacks.slice(0, 1),
-    hardExclusions: explanation.hardExclusions.slice(0, 4),
-    reasonCodes: explanation.reasonCodes.slice(0, 4),
-    agentSelection: {
-      ...explanation.agentSelection,
-      excluded: explanation.agentSelection.excluded.slice(0, 4).map((entry) => ({ ...entry, reasons: entry.reasons.slice(0, 2) }))
-    }
-  };
-  if (Buffer.byteLength(JSON.stringify(compact), "utf8") <= ROUTE_EXPLANATION_MAX_BYTES) return compact;
-  return {
-    ...compact,
-    shadowRecommendation: null,
-    approvedFallbacks: [],
-    hardExclusions: compact.hardExclusions.slice(0, 2),
-    reasonCodes: compact.reasonCodes.slice(0, 2),
-    agentSelection: {
-      ...compact.agentSelection,
-      excluded: []
-    }
-  };
-}
-
-// src/worker/context-seed.ts
-init_esm_shims();
-import { createHash } from "node:crypto";
-var WORKER_CONTEXT_MAX_BYTES = 512 * 1024;
-function record2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function parseWorkerContextProvenance(value) {
-  const fail = () => {
-    throw new Error("worker context: malformed provenance");
-  };
-  if (!record2(value)) return fail();
-  const p = value;
-  const fields = [
-    "version",
-    "mode",
-    "source",
-    "snapshotHash",
-    "contentHash",
-    "messageCount",
-    "estimatedTokens",
-    "bytes",
-    "omittedMessages",
-    "excludedTailMessages",
-    "excludedInterruptedMessages",
-    "selectedRefs"
-  ];
-  if (Object.keys(p).some((key) => !fields.includes(key))) fail();
-  if (p.version !== 1 || p.mode !== "fork" && p.mode !== "splice" || !record2(p.source)) fail();
-  const source = p.source;
-  if (Object.keys(source).some((key) => !["sessionId", "leafTurnId", "cwd"].includes(key))) fail();
-  if (typeof source.sessionId !== "string" || !source.sessionId || typeof source.cwd !== "string" || !source.cwd || source.leafTurnId !== null && typeof source.leafTurnId !== "string")
-    fail();
-  for (const key of ["snapshotHash", "contentHash"])
-    if (typeof p[key] !== "string" || !/^[a-f0-9]{64}$/u.test(p[key])) fail();
-  for (const key of [
-    "messageCount",
-    "estimatedTokens",
-    "bytes",
-    "omittedMessages",
-    "excludedTailMessages",
-    "excludedInterruptedMessages"
-  ])
-    if (!Number.isSafeInteger(p[key]) || p[key] < 0) fail();
-  if (!Array.isArray(p.selectedRefs) || p.selectedRefs.some((ref) => typeof ref !== "string" || !/^(tool:.+|message:[0-9]+)$/u.test(ref)) || new Set(p.selectedRefs).size !== p.selectedRefs.length)
-    fail();
-  return structuredClone(p);
-}
-function parseWorkerContextSeed(value) {
-  const fail = () => {
-    throw new Error("worker context: malformed or digest-mismatched seed");
-  };
-  if (Buffer.byteLength(JSON.stringify(value) ?? "", "utf8") > WORKER_CONTEXT_MAX_BYTES) fail();
-  if (!record2(value) || !record2(value.provenance) || !Array.isArray(value.messages)) return fail();
-  const p = parseWorkerContextProvenance(value.provenance);
-  for (const message of value.messages) {
-    if (!record2(message) || !["user", "assistant", "toolResult"].includes(String(message.role)) || !Number.isFinite(message.timestamp))
-      fail();
-    if (message.role === "user" && typeof message.content === "string") continue;
-    if (!Array.isArray(message.content)) return fail();
-    for (const block of message.content) {
-      if (!record2(block)) return fail();
-      switch (block.type) {
-        case "text":
-          if (typeof block.text !== "string") fail();
-          break;
-        case "thinking":
-          if (message.role !== "assistant" || typeof block.thinking !== "string") fail();
-          break;
-        case "image":
-          if (message.role === "assistant" || typeof block.data !== "string" || typeof block.mimeType !== "string") fail();
-          break;
-        case "toolCall":
-          if (message.role !== "assistant" || typeof block.id !== "string" || typeof block.name !== "string" || !record2(block.arguments))
-            fail();
-          break;
-        default:
-          fail();
-      }
-    }
-    if (message.role === "toolResult" && (typeof message.toolCallId !== "string" || typeof message.toolName !== "string" || typeof message.isError !== "boolean"))
-      fail();
-    if (message.role === "assistant") {
-      if (!["stop", "length", "toolUse"].includes(String(message.stopReason))) fail();
-      if (message.api !== void 0 && typeof message.api !== "string" || message.provider !== void 0 && typeof message.provider !== "string" || message.model !== void 0 && typeof message.model !== "string" || message.usage !== void 0 && !record2(message.usage))
-        return fail();
-      if (record2(message.usage)) {
-        for (const field of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"])
-          if (message.usage[field] !== void 0 && (typeof message.usage[field] !== "number" || !Number.isFinite(message.usage[field]) || message.usage[field] < 0))
-            fail();
-      }
-    }
-  }
-  const seed = value;
-  completeHistoryLength(seed.messages);
-  if (p.mode === "splice" && (seed.messages.length !== 1 || seed.messages[0]?.role !== "user")) fail();
-  const { contentHash: digest, ...identity } = seed.provenance;
-  if (contextHash({ ...identity, messages: seed.messages }) !== digest || p.messageCount !== seed.messages.length || p.bytes !== Buffer.byteLength(JSON.stringify(seed.messages), "utf8"))
-    fail();
-  return structuredClone(seed);
-}
-function seededWorkerMessages(seed) {
-  if (seed === void 0) return [];
-  const parsed = parseWorkerContextSeed(seed);
-  return parsed.provenance.mode === "fork" ? parsed.messages : [];
-}
-function contextHash(value) {
-  return createHash("sha256").update(`clio-coder.worker-context:1:${canonicalJson(value)}`).digest("hex");
-}
-function messageToolCalls(message) {
-  if (message.role !== "assistant") return [];
-  return message.content.filter((block) => block.type === "toolCall");
-}
-function completeHistoryLength(messages, allowPendingTail = false) {
-  let batchStart = -1;
-  const pending = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, message] of messages.entries()) {
-    if (message.role === "toolResult") {
-      if (!pending.delete(message.toolCallId)) throw new Error("worker context: orphaned or duplicate tool result");
-      continue;
-    }
-    if (pending.size > 0) throw new Error("worker context: incomplete historical tool batch");
-    if (message.role !== "user" && message.role !== "assistant")
-      throw new Error("worker context: unsupported message role");
-    if (message.role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted"))
-      throw new Error("worker context: interrupted assistant message cannot seed a worker");
-    const calls = messageToolCalls(message);
-    if (calls.length > 0) batchStart = index;
-    for (const call of calls) {
-      if (!call.id || seen.has(call.id)) throw new Error("worker context: duplicate or empty tool call id");
-      seen.add(call.id);
-      pending.add(call.id);
-    }
-  }
-  if (pending.size === 0) return messages.length;
-  if (allowPendingTail) return batchStart;
-  throw new Error("worker context: seed contains an unfinished tool batch");
-}
-
-// src/domains/dispatch/route-policy.ts
-init_esm_shims();
-var ROUTE_POLICY_VERSION = "route-policy/4";
-var MINIMUM_QUALITY_LABELED_OUTCOMES = 6;
-var ROUTE_POSTURES = {
-  manual: {
-    floors: { qualityLowerBound: 0, reliability: 0 },
-    weights: { quality: 1, cost: 0, latency: 0 },
-    deadlineFirst: false
-  },
-  quality: {
-    floors: { qualityLowerBound: 0.8, reliability: 0.8 },
-    weights: { quality: 1, cost: 0.1, latency: 0.1 },
-    deadlineFirst: false
-  },
-  balanced: {
-    floors: { qualityLowerBound: 0.6, reliability: 0.6 },
-    weights: { quality: 0.6, cost: 0.2, latency: 0.2 },
-    deadlineFirst: false
-  },
-  latency: {
-    floors: { qualityLowerBound: 0.5, reliability: 0.6 },
-    weights: { quality: 0.3, cost: 0.1, latency: 0.6 },
-    deadlineFirst: true
-  },
-  economy: {
-    floors: { qualityLowerBound: 0.6, reliability: 0.6 },
-    weights: { quality: 0.3, cost: 0.6, latency: 0.1 },
-    deadlineFirst: false
-  }
-};
-var DEFAULT_ROUTE_PRIOR = {
-  qualityMean: 0.5,
-  firstPassSuccessProbability: 0.5,
-  costUpperBoundUsd: 1,
-  expectedEndToEndMs: 12e4,
-  reliability: 0.5,
-  queueWaitMs: 0
-};
-var LATENCY_CLASS_ROUTE_PRIORS = {
-  fast: { ...DEFAULT_ROUTE_PRIOR, expectedEndToEndMs: 3e4 },
-  balanced: { ...DEFAULT_ROUTE_PRIOR, expectedEndToEndMs: 12e4 },
-  deep: { ...DEFAULT_ROUTE_PRIOR, expectedEndToEndMs: 3e5 }
-};
-function routePriorForLatencyClass(latencyClass) {
-  return { ...LATENCY_CLASS_ROUTE_PRIORS[latencyClass] };
-}
-function routeObservationFromHistory(record3) {
-  return {
-    qualityLabel: record3.qualityLabel,
-    reliability: record3.reliability,
-    firstPass: record3.firstPass,
-    completedCostUsd: record3.completedCostUsd,
-    completedEndToEndMs: record3.completedPhaseTiming?.totalEndToEndMs ?? null,
-    cacheRead: record3.cacheRead,
-    queueWaitMs: record3.completedPhaseTiming?.queueWaitMs ?? null
-  };
-}
-var ROUTE_ESTIMATE_SHRINKAGE = 5;
-function mean(values, fallback) {
-  if (values.length === 0) return fallback;
-  return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-function quantile(values, fraction, fallback) {
-  if (values.length === 0) return fallback;
-  const sorted = [...values].sort((left, right) => left - right);
-  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(fraction * sorted.length) - 1));
-  return sorted[index] ?? fallback;
-}
-function shrink(measured, prior, sampleCount) {
-  const weight = sampleCount / (sampleCount + ROUTE_ESTIMATE_SHRINKAGE);
-  return measured * weight + prior * (1 - weight);
-}
-function rate(values, fallback = 0) {
-  if (values.length === 0) return fallback;
-  return values.filter(Boolean).length / values.length;
-}
-function wilsonLowerBound(successes, observations, z = 1.96) {
-  if (observations <= 0) return 0;
-  const proportion = successes / observations;
-  const z2 = z * z;
-  const center = proportion + z2 / (2 * observations);
-  const margin = z * Math.sqrt((proportion * (1 - proportion) + z2 / (4 * observations)) / observations);
-  return Math.max(0, Math.min(1, (center - margin) / (1 + z2 / observations)));
-}
-function estimateRoute(samples, prior = DEFAULT_ROUTE_PRIOR) {
-  const labeled = samples.filter((sample) => sample.qualityLabel !== "unmeasured");
-  const qualityPasses = labeled.filter((sample) => sample.qualityLabel === "pass").length;
-  const attributable = samples.filter((sample) => sample.reliability !== "neutral");
-  const completed = samples.filter((sample) => sample.completedCostUsd !== null && sample.completedEndToEndMs !== null);
-  const costs = completed.flatMap((sample) => sample.completedCostUsd === null ? [] : [sample.completedCostUsd]);
-  const latencies = completed.flatMap(
-    (sample) => sample.completedEndToEndMs === null ? [] : [sample.completedEndToEndMs]
-  );
-  const queueWaits = completed.flatMap((sample) => sample.queueWaitMs === null ? [] : [sample.queueWaitMs]);
-  const completedCount = completed.length;
-  const reliabilityCount = attributable.length;
-  const qualityMean = labeled.length === 0 ? prior.qualityMean : qualityPasses / labeled.length;
-  const completedCosts = mean(costs, prior.costUpperBoundUsd);
-  const completedLatency = mean(latencies, prior.expectedEndToEndMs);
-  return {
-    qualityLabeledCount: labeled.length,
-    unmeasuredCount: samples.length - labeled.length,
-    qualityCoverage: samples.length === 0 ? 0 : labeled.length / samples.length,
-    qualityMean,
-    qualityLowerBound: wilsonLowerBound(qualityPasses, labeled.length),
-    firstPassSuccessProbability: shrink(
-      rate(
-        attributable.map((sample) => sample.firstPass),
-        prior.firstPassSuccessProbability
-      ),
-      prior.firstPassSuccessProbability,
-      reliabilityCount
-    ),
-    expectedCostUsd: shrink(completedCosts, prior.costUpperBoundUsd, completedCount),
-    costUpperBoundUsd: Math.max(prior.costUpperBoundUsd, quantile(costs, 0.95, prior.costUpperBoundUsd)),
-    expectedEndToEndMs: shrink(completedLatency, prior.expectedEndToEndMs, completedCount),
-    p95EndToEndMs: Math.max(completedLatency, quantile(latencies, 0.95, prior.expectedEndToEndMs)),
-    reliability: shrink(
-      rate(
-        attributable.map((sample) => sample.reliability === "success"),
-        prior.reliability
-      ),
-      prior.reliability,
-      reliabilityCount
-    ),
-    cacheHitProbability: completedCount === 0 ? 0 : rate(completed.map((sample) => sample.cacheRead)),
-    queueWaitMs: shrink(mean(queueWaits, prior.queueWaitMs), prior.queueWaitMs, completedCount),
-    sampleCount: samples.length,
-    confidence: labeled.length / (labeled.length + ROUTE_ESTIMATE_SHRINKAGE)
-  };
-}
-function clearsPostureFloors(estimate, posture) {
-  if (posture === "manual") return true;
-  const policy = ROUTE_POSTURES[posture];
-  return estimate.qualityLabeledCount >= MINIMUM_QUALITY_LABELED_OUTCOMES && estimate.qualityLowerBound >= policy.floors.qualityLowerBound && estimate.reliability >= policy.floors.reliability;
-}
-function normalize(value, min, max) {
-  if (!(max > min)) return 0;
-  return (value - min) / (max - min);
-}
-function routeScoreScale(estimates) {
-  const costs = estimates.map((estimate) => estimate.expectedCostUsd);
-  const latencies = estimates.map((estimate) => estimate.p95EndToEndMs);
-  const queueWaits = estimates.map((estimate) => estimate.queueWaitMs);
-  return {
-    minCostUsd: costs.length > 0 ? Math.min(...costs) : 0,
-    maxCostUsd: costs.length > 0 ? Math.max(...costs) : 0,
-    minLatencyMs: latencies.length > 0 ? Math.min(...latencies) : 0,
-    maxLatencyMs: latencies.length > 0 ? Math.max(...latencies) : 0,
-    minQueueWaitMs: queueWaits.length > 0 ? Math.min(...queueWaits) : 0,
-    maxQueueWaitMs: queueWaits.length > 0 ? Math.max(...queueWaits) : 0
-  };
-}
-var SCORE_PRECISION = 1e-9;
-function round(value) {
-  return Math.round(value / SCORE_PRECISION) * SCORE_PRECISION;
-}
-function scoreRoute(estimate, posture, scale) {
-  const policy = ROUTE_POSTURES[posture];
-  const costPenalty = normalize(estimate.expectedCostUsd, scale.minCostUsd, scale.maxCostUsd);
-  const latencyPenalty = normalize(
-    policy.deadlineFirst ? estimate.p95EndToEndMs : estimate.expectedEndToEndMs,
-    scale.minLatencyMs,
-    scale.maxLatencyMs
-  );
-  const queuePenalty = normalize(estimate.queueWaitMs, scale.minQueueWaitMs, scale.maxQueueWaitMs);
-  const qualitySignal = estimate.qualityLabeledCount === 0 ? estimate.qualityMean : estimate.qualityLowerBound;
-  const health = qualitySignal * 0.7 + estimate.reliability * 0.3;
-  const affinityBonus = estimate.cacheHitProbability * 0.01;
-  return round(
-    policy.weights.quality * health - policy.weights.cost * costPenalty - policy.weights.latency * (latencyPenalty * 0.9 + queuePenalty * 0.1) + affinityBonus
-  );
-}
-function dominatesRoute(left, right) {
-  const noWorse = left.qualityLowerBound >= right.qualityLowerBound && left.reliability >= right.reliability && left.expectedCostUsd <= right.expectedCostUsd && left.p95EndToEndMs <= right.p95EndToEndMs && left.queueWaitMs <= right.queueWaitMs && left.cacheHitProbability >= right.cacheHitProbability;
-  return noWorse && (left.qualityLowerBound > right.qualityLowerBound || left.reliability > right.reliability || left.expectedCostUsd < right.expectedCostUsd || left.p95EndToEndMs < right.p95EndToEndMs || left.queueWaitMs < right.queueWaitMs || left.cacheHitProbability > right.cacheHitProbability);
-}
-function compareRankedRoutes(left, right) {
-  if (left.score !== right.score) return right.score - left.score;
-  if (left.estimate.expectedCostUsd !== right.estimate.expectedCostUsd) {
-    return left.estimate.expectedCostUsd - right.estimate.expectedCostUsd;
-  }
-  if (left.estimate.reliability !== right.estimate.reliability) {
-    return right.estimate.reliability - left.estimate.reliability;
-  }
-  if (left.estimate.p95EndToEndMs !== right.estimate.p95EndToEndMs) {
-    return left.estimate.p95EndToEndMs - right.estimate.p95EndToEndMs;
-  }
-  if (left.estimate.queueWaitMs !== right.estimate.queueWaitMs) {
-    return left.estimate.queueWaitMs - right.estimate.queueWaitMs;
-  }
-  if (left.estimate.cacheHitProbability !== right.estimate.cacheHitProbability) {
-    return right.estimate.cacheHitProbability - left.estimate.cacheHitProbability;
-  }
-  if (left.order !== right.order) return left.order - right.order;
-  return left.key < right.key ? -1 : left.key > right.key ? 1 : 0;
-}
-
-// src/domains/dispatch/route-decision.ts
-init_esm_shims();
-import { createHash as createHash2 } from "node:crypto";
-
-// src/domains/dispatch/route-readiness.ts
-init_esm_shims();
-var MINIMUM_ACTIVE_QUALITY_LABELS = 6;
-var DECISION_LATENCY_BUDGET_MS = 10;
-function evaluateRouteReadiness(input) {
-  const gaps = [];
-  const floors = ROUTE_POSTURES[input.posture].floors;
-  const estimate = input.estimate;
-  if (input.hardConstraintValidity < 1) gaps.push("hard-constraint-validity-below-one");
-  if (input.integrityFailures > 0) gaps.push("integrity-failures-in-window");
-  if (estimate.qualityLabeledCount < MINIMUM_ACTIVE_QUALITY_LABELS) gaps.push("insufficient-quality-labels");
-  if (estimate.qualityLowerBound < floors.qualityLowerBound) gaps.push("quality-lower-bound-below-posture-floor");
-  if (input.requestedMinimumQuality !== null && estimate.qualityLowerBound < input.requestedMinimumQuality) {
-    gaps.push("quality-lower-bound-below-requested-minimum");
-  }
-  if (estimate.reliability < floors.reliability) gaps.push("reliability-below-posture-floor");
-  if (input.costUpperBoundUsd === null || !Number.isFinite(input.costUpperBoundUsd)) {
-    gaps.push("cost-upper-bound-unknown");
-  }
-  if (!input.factsFresh) gaps.push("route-facts-stale");
-  if (input.decisionP95Ms > DECISION_LATENCY_BUDGET_MS) gaps.push("decision-latency-above-budget");
-  return {
-    ready: gaps.length === 0,
-    gaps,
-    labelsNeeded: Math.max(0, MINIMUM_ACTIVE_QUALITY_LABELS - estimate.qualityLabeledCount)
-  };
-}
-
-// src/domains/dispatch/route-decision.ts
-function routeCorrelationFacts(candidate) {
-  return {
-    agentId: candidate.agentId,
-    targetId: candidate.targetId,
-    wireModelId: candidate.modelId,
-    runtimeId: candidate.runtimeId,
-    nodeId: candidate.nodeId
-  };
-}
-function exactKeys(value, keys) {
-  return Object.keys(value).sort().join("\0") === [...keys].sort().join("\0");
-}
-function decisionRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var READINESS_GAPS = /* @__PURE__ */ new Set([
-  "hard-constraint-validity-below-one",
-  "integrity-failures-in-window",
-  "insufficient-quality-labels",
-  "quality-lower-bound-below-posture-floor",
-  "quality-lower-bound-below-requested-minimum",
-  "reliability-below-posture-floor",
-  "cost-upper-bound-unknown",
-  "route-facts-stale",
-  "decision-latency-above-budget"
-]);
-function decisionRouteCandidate(value) {
-  if (!decisionRecord(value)) return false;
-  const required = [
-    "agentId",
-    "specFingerprint",
-    "executionRole",
-    "targetId",
-    "modelId",
-    "runtimeId",
-    "nodeId",
-    "toolSignature",
-    "promptCompositionHash",
-    "endpointIdentityHash",
-    "settingsFingerprint"
-  ];
-  const keys = Object.keys(value);
-  if (keys.some((key) => !required.includes(key) && key !== "thinkingLevel")) return false;
-  if (required.some((key) => !Object.hasOwn(value, key))) return false;
-  return isExecutionRole(value.executionRole) && required.filter((key) => key !== "executionRole").every((key) => typeof value[key] === "string" && String(value[key]).length > 0) && (value.thinkingLevel === void 0 || typeof value.thinkingLevel === "string" && value.thinkingLevel.length > 0);
-}
-function decisionReadinessReport(value) {
-  if (!decisionRecord(value) || !exactKeys(value, ["ready", "gaps", "labelsNeeded"])) return false;
-  return typeof value.ready === "boolean" && Array.isArray(value.gaps) && value.gaps.length <= READINESS_GAPS.size && value.gaps.every((gap) => typeof gap === "string" && READINESS_GAPS.has(gap)) && new Set(value.gaps).size === value.gaps.length && value.ready === (value.gaps.length === 0) && Number.isInteger(value.labelsNeeded) && Number(value.labelsNeeded) >= 0;
-}
-function isRouteDecisionAgentSelection(value) {
-  if (!decisionRecord(value)) return false;
-  if (!exactKeys(value, [
-    "request",
-    "activation",
-    "baselineAgentId",
-    "recommendedAgentId",
-    "evaluations",
-    "readiness",
-    "authorityBasis",
-    "authorityTransition"
-  ]) || value.request !== "explicit" && value.request !== "auto" || value.activation !== "shadow" && value.activation !== "active" || typeof value.baselineAgentId !== "string" || value.baselineAgentId.length === 0 || typeof value.recommendedAgentId !== "string" || value.recommendedAgentId.length === 0 || value.authorityBasis !== null && value.authorityBasis !== "operator-plan-approval" && value.authorityBasis !== "full-auto-policy" || !Array.isArray(value.evaluations) || value.evaluations.length === 0 || value.evaluations.length > 64 || !Array.isArray(value.readiness) || value.readiness.length === 0 || value.readiness.length > 64)
-    return false;
-  const priorKeys = [
-    "qualityMean",
-    "firstPassSuccessProbability",
-    "costUpperBoundUsd",
-    "expectedEndToEndMs",
-    "reliability",
-    "queueWaitMs"
-  ];
-  if (!value.evaluations.every((entry) => {
-    if (!decisionRecord(entry) || !exactKeys(entry, [
-      "agentId",
-      "specFingerprint",
-      "executionRole",
-      "authority",
-      "rejections",
-      "coldPrior",
-      "priorReasons"
-    ]))
-      return false;
-    const prior = entry.coldPrior;
-    if (typeof entry.agentId !== "string" || entry.agentId.length === 0 || typeof entry.specFingerprint !== "string" || entry.specFingerprint.length === 0 || !isExecutionRole(entry.executionRole) || !isAgentCapabilityClass(entry.authority) || !Array.isArray(entry.rejections) || entry.rejections.length > 64 || !entry.rejections.every((reason) => typeof reason === "string") || !Array.isArray(entry.priorReasons) || entry.priorReasons.length > 64 || !entry.priorReasons.every((reason) => typeof reason === "string") || !decisionRecord(prior) || !exactKeys(prior, priorKeys) || !priorKeys.every((key) => typeof prior[key] === "number" && Number.isFinite(prior[key])))
-      return false;
-    return true;
-  }))
-    return false;
-  if (!value.readiness.every((entry) => {
-    if (!decisionRecord(entry) || !exactKeys(entry, [
-      "agentId",
-      "specFingerprint",
-      "executionRole",
-      "ready",
-      "candidateCount",
-      "readyCandidateCount",
-      "routes"
-    ]))
-      return false;
-    if (!Array.isArray(entry.routes) || entry.routes.length === 0 || entry.routes.length > 64 || !entry.routes.every(
-      (route) => decisionRecord(route) && exactKeys(route, ["candidate", "report"]) && decisionRouteCandidate(route.candidate) && decisionReadinessReport(route.report) && route.candidate.agentId === entry.agentId && route.candidate.specFingerprint === entry.specFingerprint && route.candidate.executionRole === entry.executionRole
-    ))
-      return false;
-    const readyCandidateCount = entry.routes.filter(
-      (route) => decisionRecord(route) && decisionRecord(route.report) && route.report.ready === true
-    ).length;
-    return typeof entry.agentId === "string" && entry.agentId.length > 0 && typeof entry.specFingerprint === "string" && entry.specFingerprint.length > 0 && isExecutionRole(entry.executionRole) && typeof entry.ready === "boolean" && Number.isInteger(entry.candidateCount) && Number(entry.candidateCount) === entry.routes.length && Number.isInteger(entry.readyCandidateCount) && Number(entry.readyCandidateCount) === readyCandidateCount && entry.ready === readyCandidateCount > 0;
-  }))
-    return false;
-  if (value.authorityTransition !== null) {
-    const transition = value.authorityTransition;
-    if (!decisionRecord(transition) || !exactKeys(transition, ["from", "to", "basis"]) || typeof transition.from !== "string" || transition.from.length === 0 || typeof transition.to !== "string" || transition.to.length === 0 || transition.basis !== "same-authority" && transition.basis !== "operator-plan-approval" && transition.basis !== "full-auto-policy") {
-      return false;
-    }
-    if (value.request !== "auto" || value.activation !== "active" || transition.from !== value.baselineAgentId || transition.to !== value.recommendedAgentId)
-      return false;
-    const from = value.evaluations.find((entry) => entry.agentId === transition.from);
-    const to = value.evaluations.find((entry) => entry.agentId === transition.to);
-    if (from === void 0 || to === void 0) return false;
-    if (transition.basis === "same-authority") {
-      if (from.authority !== to.authority) return false;
-    } else if (transition.basis !== value.authorityBasis) return false;
-  }
-  return (value.request !== "explicit" || value.authorityBasis === null) && new Set(
-    value.evaluations.map((entry) => `${entry.agentId}\0${entry.specFingerprint}\0${entry.executionRole}`)
-  ).size === value.evaluations.length && value.evaluations.some((entry) => entry.agentId === value.baselineAgentId) && value.evaluations.some((entry) => entry.agentId === value.recommendedAgentId);
-}
-function routeCapabilityKey(candidate) {
-  return [
-    candidate.agentId,
-    candidate.specFingerprint,
-    candidate.executionRole,
-    candidate.targetId,
-    candidate.modelId,
-    candidate.runtimeId,
-    candidate.nodeId,
-    candidate.thinkingLevel ?? ""
-  ].join("\0");
-}
-function routeDriftGuard(candidate) {
-  return {
-    promptCompositionHash: candidate.promptCompositionHash,
-    settingsFingerprint: candidate.settingsFingerprint,
-    toolSignature: candidate.toolSignature,
-    endpointIdentityHash: candidate.endpointIdentityHash
-  };
-}
-function routeDriftInvalidates(observed, current) {
-  return observed.toolSignature !== current.toolSignature || observed.endpointIdentityHash !== current.endpointIdentityHash;
-}
-function routeCandidateKey(candidate) {
-  return [
-    candidate.agentId,
-    candidate.specFingerprint,
-    candidate.executionRole,
-    candidate.targetId,
-    candidate.modelId,
-    candidate.runtimeId,
-    candidate.nodeId,
-    candidate.thinkingLevel ?? "",
-    candidate.toolSignature,
-    candidate.promptCompositionHash,
-    candidate.endpointIdentityHash,
-    candidate.settingsFingerprint
-  ].join("\0");
-}
-function sameRouteIdentity(left, right) {
-  return routeCandidateKey(left) === routeCandidateKey(right);
-}
-function promptCompositionIdentity(identity, role) {
-  const persona = role.personaPrompt !== void 0 ? createHash2("sha256").update(role.personaPrompt, "utf8").digest("hex") : null;
-  return createHash2("sha256").update(
-    JSON.stringify({
-      specFingerprint: identity.specFingerprint,
-      toolSignature: identity.toolSignature,
-      persona
-    }),
-    "utf8"
-  ).digest("hex");
-}
-function toRouteCandidate(identity, role) {
-  return {
-    agentId: identity.agentId,
-    specFingerprint: identity.specFingerprint,
-    executionRole: role.executionRole,
-    targetId: identity.targetId,
-    modelId: identity.wireModelId,
-    runtimeId: identity.runtimeId,
-    nodeId: identity.nodeId,
-    ...identity.thinkingLevel !== null ? { thinkingLevel: identity.thinkingLevel } : {},
-    toolSignature: identity.toolSignature,
-    promptCompositionHash: promptCompositionIdentity(identity, role),
-    endpointIdentityHash: identity.endpointIdentityHash,
-    settingsFingerprint: identity.settingsFingerprint
-  };
-}
-function hashNumber(value) {
-  if (!Number.isFinite(value)) throw new Error(`route decision: non-finite number ${String(value)}`);
-  return Number(value.toFixed(9));
-}
-function estimateHashProjection(estimate) {
-  return [
-    hashNumber(estimate.qualityLabeledCount),
-    hashNumber(estimate.unmeasuredCount),
-    hashNumber(estimate.qualityCoverage),
-    hashNumber(estimate.qualityMean),
-    hashNumber(estimate.qualityLowerBound),
-    hashNumber(estimate.firstPassSuccessProbability),
-    hashNumber(estimate.expectedCostUsd),
-    hashNumber(estimate.costUpperBoundUsd),
-    hashNumber(estimate.expectedEndToEndMs),
-    hashNumber(estimate.p95EndToEndMs),
-    hashNumber(estimate.reliability),
-    hashNumber(estimate.cacheHitProbability),
-    hashNumber(estimate.queueWaitMs),
-    hashNumber(estimate.sampleCount),
-    hashNumber(estimate.confidence)
-  ];
-}
-function readinessHashProjection(report) {
-  return [report.ready, report.gaps, hashNumber(report.labelsNeeded)];
-}
-function routeDecisionHash(input) {
-  const candidates = input.candidates.map((entry) => [
-    routeCandidateKey(entry.candidate),
-    estimateHashProjection(entry.estimate),
-    readinessHashProjection(entry.activeReadiness),
-    entry.rejection
-  ]);
-  const agentSelection = [
-    input.agentSelection.request,
-    input.agentSelection.baselineAgentId,
-    input.agentSelection.evaluations.map((entry) => [
-      entry.agentId,
-      entry.specFingerprint,
-      entry.executionRole,
-      entry.authority,
-      entry.rejections,
-      [
-        hashNumber(entry.coldPrior.qualityMean),
-        hashNumber(entry.coldPrior.firstPassSuccessProbability),
-        hashNumber(entry.coldPrior.costUpperBoundUsd),
-        hashNumber(entry.coldPrior.expectedEndToEndMs),
-        hashNumber(entry.coldPrior.reliability),
-        hashNumber(entry.coldPrior.queueWaitMs)
-      ],
-      entry.priorReasons
-    ]),
-    input.agentSelection.readiness.map((entry) => [
-      entry.agentId,
-      entry.specFingerprint,
-      entry.executionRole,
-      entry.ready,
-      hashNumber(entry.candidateCount),
-      hashNumber(entry.readyCandidateCount),
-      entry.routes.map((route) => [routeCandidateKey(route.candidate), readinessHashProjection(route.report)])
-    ]),
-    input.agentSelection.authorityBasis
-  ];
-  const independenceSubject = input.independenceSubject === null ? null : [
-    input.independenceSubject.agentId,
-    input.independenceSubject.targetId,
-    input.independenceSubject.wireModelId,
-    input.independenceSubject.runtimeId,
-    input.independenceSubject.nodeId
-  ];
-  return createHash2("sha256").update(
-    JSON.stringify([
-      ROUTE_POLICY_VERSION,
-      input.mode,
-      input.posture,
-      routeCandidateKey(input.executedRoute),
-      candidates,
-      independenceSubject,
-      agentSelection,
-      input.hardConstraints,
-      hashNumber(input.maxFallbacks)
-    ]),
-    "utf8"
-  ).digest("hex");
-}
-function decideRoute(input) {
-  const reasonCodes = [];
-  const candidateKeys = new Map(input.candidates.map((entry) => [entry, routeCandidateKey(entry.candidate)]));
-  const candidateKey = (entry) => candidateKeys.get(entry);
-  const hardAdmissible = input.candidates.filter((entry) => entry.rejection === null);
-  const rejectedCount = input.candidates.length - hardAdmissible.length;
-  if (rejectedCount > 0) reasonCodes.push(`hard-filter-rejected-${rejectedCount}`);
-  const readinessExcluded = input.mode === "active" ? hardAdmissible.filter((entry) => !entry.activeReadiness.ready).length : 0;
-  if (readinessExcluded > 0) reasonCodes.push(`active-readiness-excluded-${readinessExcluded}`);
-  const admissible = input.mode === "active" ? hardAdmissible.filter((entry) => entry.activeReadiness.ready) : hardAdmissible;
-  const scale = routeScoreScale(admissible.map((entry) => entry.estimate));
-  const clearing = admissible.filter((entry) => clearsPostureFloors(entry.estimate, input.posture));
-  if (clearing.length < admissible.length) {
-    reasonCodes.push(`posture-floor-excluded-${admissible.length - clearing.length}`);
-  }
-  if (clearing.length === 0 && admissible.length > 0) {
-    reasonCodes.push("posture-floors-unsatisfiable");
-    if (input.mode === "active") throw new Error("route decision: posture-floors-unsatisfiable");
-  }
-  const selectable = clearing.length > 0 ? clearing : admissible;
-  const approvalOrder = new Map(input.candidates.map((entry, index) => [candidateKey(entry), index]));
-  const ranked = selectable.map((entry) => {
-    const key = candidateKey(entry);
-    return {
-      entry,
-      ranked: {
-        key,
-        order: approvalOrder.get(key) ?? input.candidates.length,
-        estimate: entry.estimate,
-        score: scoreRoute(entry.estimate, input.posture, scale)
-      }
-    };
-  }).sort((left, right) => {
-    const policyOrder = compareRankedRoutes(
-      { ...left.ranked, key: "", order: 0 },
-      { ...right.ranked, key: "", order: 0 }
-    );
-    if (policyOrder !== 0) return policyOrder;
-    if (input.independenceSubject !== null && (input.executedRoute.executionRole === "reviewer" || input.executedRoute.executionRole === "judge")) {
-      const leftIndependent = gateRouteCorrelation(
-        input.independenceSubject,
-        routeCorrelationFacts(left.entry.candidate)
-      ).independent;
-      const rightIndependent = gateRouteCorrelation(
-        input.independenceSubject,
-        routeCorrelationFacts(right.entry.candidate)
-      ).independent;
-      if (leftIndependent !== rightIndependent) return leftIndependent ? -1 : 1;
-    }
-    return compareRankedRoutes(left.ranked, right.ranked);
-  });
-  const dominatedKeys = /* @__PURE__ */ new Set();
-  for (const outer of admissible) {
-    for (const inner of admissible) {
-      if (inner === outer) continue;
-      if (dominatesRoute(inner.estimate, outer.estimate)) {
-        dominatedKeys.add(candidateKey(outer));
-        break;
-      }
-    }
-  }
-  const scores = new Map(ranked.map((entry) => [entry.ranked.key, entry.ranked.score]));
-  const candidateEvaluations = input.candidates.map((entry) => {
-    const key = candidateKey(entry);
-    return {
-      candidate: { ...entry.candidate },
-      estimate: { ...entry.estimate },
-      activeReadiness: { ...entry.activeReadiness, gaps: [...entry.activeReadiness.gaps] },
-      rejection: entry.rejection,
-      score: entry.rejection === null ? scores.get(key) ?? null : null,
-      dominated: entry.rejection === null && dominatedKeys.has(key)
-    };
-  });
-  const executedKey = routeCandidateKey(input.executedRoute);
-  const executedAdmissible = admissible.some((entry) => candidateKey(entry) === executedKey);
-  const manual = input.posture === "manual";
-  const best = ranked[0]?.entry.candidate;
-  if (input.mode === "active" && best === void 0) {
-    const gaps = hardAdmissible.flatMap((entry) => entry.activeReadiness.gaps);
-    const detail = [...new Set(gaps)].join(", ") || "no-hard-admissible-candidate";
-    throw new Error(`route decision: no-active-eligible-candidate (${detail})`);
-  }
-  const selected = manual || best === void 0 ? { ...input.executedRoute } : { ...best };
-  if (manual) reasonCodes.push("manual-posture-exact-route");
-  if (best === void 0) reasonCodes.push("no-admissible-candidate");
-  if (!executedAdmissible) reasonCodes.push("executed-route-not-admissible");
-  if (input.mode === "shadow") reasonCodes.push("shadow-advisory-only");
-  if (input.mode !== "active" && best !== void 0 && routeCandidateKey(selected) !== executedKey) {
-    reasonCodes.push("shadow-differs-from-executed");
-  }
-  const selectedKey = routeCandidateKey(selected);
-  const approvedFallbacks = [];
-  if (!manual) {
-    for (const entry of ranked) {
-      if (approvedFallbacks.length >= Math.max(0, input.maxFallbacks)) break;
-      if (entry.ranked.key === selectedKey) continue;
-      approvedFallbacks.push({ ...entry.entry.candidate });
-    }
-  }
-  const selectedEstimate = candidateEvaluations.find(
-    (evaluation) => routeCandidateKey(evaluation.candidate) === selectedKey
-  )?.estimate;
-  const coldShare = admissible.length === 0 ? 1 : admissible.filter((entry) => entry.estimate.sampleCount === 0).length / admissible.length;
-  const confidence = Math.max(0, Math.min(1, (selectedEstimate?.confidence ?? 0) * (1 - coldShare) + coldShare * 0));
-  const recommendedAgentId = best?.agentId ?? input.agentSelection.baselineAgentId;
-  let authorityTransition = null;
-  if (input.mode === "active" && selected.agentId !== input.agentSelection.baselineAgentId) {
-    if (input.agentSelection.request !== "auto") {
-      throw new Error("route decision: explicit agent selection cannot change authority");
-    }
-    const from = input.agentSelection.evaluations.find(
-      (evaluation) => evaluation.agentId === input.agentSelection.baselineAgentId
-    )?.authority;
-    const to = input.agentSelection.evaluations.find((evaluation) => evaluation.agentId === selected.agentId)?.authority;
-    const basis = from !== void 0 && to !== void 0 && from === to ? "same-authority" : input.agentSelection.authorityBasis;
-    if (basis === null) throw new Error("route decision: active agent authority transition lacks trusted approval");
-    authorityTransition = { from: input.agentSelection.baselineAgentId, to: selected.agentId, basis };
-  }
-  return {
-    policyVersion: ROUTE_POLICY_VERSION,
-    mode: input.mode,
-    posture: input.posture,
-    selected,
-    approvedFallbacks,
-    hardConstraints: [...input.hardConstraints],
-    candidateEvaluations,
-    reasonCodes,
-    decisionDurationMs: input.decisionDurationMs,
-    confidence,
-    agentSelection: {
-      request: input.agentSelection.request,
-      activation: input.mode === "active" ? "active" : "shadow",
-      baselineAgentId: input.agentSelection.baselineAgentId,
-      recommendedAgentId,
-      evaluations: structuredClone([...input.agentSelection.evaluations]),
-      readiness: structuredClone([...input.agentSelection.readiness]),
-      authorityBasis: input.agentSelection.authorityBasis,
-      authorityTransition
-    },
-    decisionHash: routeDecisionHash({
-      ...input,
-      executedRoute: input.mode === "active" ? selected : input.executedRoute
-    }),
-    executedRoute: { ...input.mode === "active" ? selected : input.executedRoute }
-  };
-}
-function fixedRouteDecision(executedRoute, reasonCode = "observer-failure-fixed-route") {
-  const estimate = estimateRoute([], DEFAULT_ROUTE_PRIOR);
-  const activeReadiness = evaluateRouteReadiness({
-    estimate,
-    posture: "manual",
-    hardConstraintValidity: 1,
-    integrityFailures: 0,
-    costUpperBoundUsd: null,
-    factsFresh: false,
-    decisionP95Ms: Number.POSITIVE_INFINITY,
-    requestedMinimumQuality: null
-  });
-  const input = {
-    mode: "fixed",
-    posture: "manual",
-    executedRoute,
-    candidates: [
-      {
-        candidate: executedRoute,
-        estimate,
-        activeReadiness,
-        rejection: null
-      }
-    ],
-    independenceSubject: null,
-    hardConstraints: ["fixed-executed-route"],
-    maxFallbacks: 0,
-    decisionDurationMs: 0,
-    agentSelection: {
-      request: "explicit",
-      baselineAgentId: executedRoute.agentId,
-      evaluations: [
-        {
-          agentId: executedRoute.agentId,
-          specFingerprint: executedRoute.specFingerprint,
-          executionRole: executedRoute.executionRole,
-          authority: "internal",
-          rejections: [],
-          coldPrior: { ...DEFAULT_ROUTE_PRIOR },
-          priorReasons: ["fixed-route"]
-        }
-      ],
-      readiness: [
-        {
-          agentId: executedRoute.agentId,
-          specFingerprint: executedRoute.specFingerprint,
-          executionRole: executedRoute.executionRole,
-          ready: activeReadiness.ready,
-          candidateCount: 1,
-          readyCandidateCount: activeReadiness.ready ? 1 : 0,
-          routes: [{ candidate: { ...executedRoute }, report: { ...activeReadiness, gaps: [...activeReadiness.gaps] } }]
-        }
-      ],
-      authorityBasis: null
-    }
-  };
-  const decision = decideRoute(input);
-  return { ...decision, reasonCodes: [...decision.reasonCodes, reasonCode] };
-}
-function evaluationFor(decision, candidate) {
-  const key = routeCandidateKey(candidate);
-  return decision.candidateEvaluations.find((evaluation) => routeCandidateKey(evaluation.candidate) === key);
-}
-function routeRegret(decision) {
-  const selected = evaluationFor(decision, decision.selected);
-  const executed = evaluationFor(decision, decision.executedRoute);
-  return {
-    score: (selected?.score ?? 0) - (executed?.score ?? 0),
-    expectedCostUsd: (selected?.estimate.expectedCostUsd ?? 0) - (executed?.estimate.expectedCostUsd ?? 0),
-    expectedLatencyMs: (selected?.estimate.expectedEndToEndMs ?? 0) - (executed?.estimate.expectedEndToEndMs ?? 0),
-    executedOffFrontier: executed?.dominated ?? false,
-    routeDiffered: !sameRouteIdentity(decision.selected, decision.executedRoute)
-  };
-}
-function routeConstraintValidity(decision) {
-  const admissible = (candidate) => evaluationFor(decision, candidate)?.rejection === null;
-  const selectedAdmissible = admissible(decision.selected);
-  const executedAdmissible = admissible(decision.executedRoute);
-  const fallbacksAdmissible = decision.approvedFallbacks.every(admissible);
-  return {
-    selectedAdmissible,
-    executedAdmissible,
-    fallbacksAdmissible,
-    valid: selectedAdmissible && executedAdmissible && fallbacksAdmissible
-  };
-}
-function ratio(actual, expected) {
-  if (expected === 0) return actual === 0 ? 1 : Number.POSITIVE_INFINITY;
-  return actual / expected;
-}
-function routePredictionCalibration(decision, realized) {
-  const executed = evaluationFor(decision, realized.route);
-  const estimate = executed?.estimate;
-  const quality = realized.qualityLabel === "unmeasured" ? null : realized.qualityLabel === "pass" ? 1 : 0;
-  const firstPass = realized.firstPass ? 1 : 0;
-  return {
-    costErrorUsd: realized.costUsd - (estimate?.expectedCostUsd ?? 0),
-    costRatio: ratio(realized.costUsd, estimate?.expectedCostUsd ?? 0),
-    latencyErrorMs: realized.endToEndMs - (estimate?.expectedEndToEndMs ?? 0),
-    latencyRatio: ratio(realized.endToEndMs, estimate?.expectedEndToEndMs ?? 0),
-    qualityBrier: quality === null ? null : (quality - (estimate?.qualityMean ?? 0)) ** 2,
-    firstPassBrier: (firstPass - (estimate?.firstPassSuccessProbability ?? 0)) ** 2,
-    sampleCount: estimate?.sampleCount ?? 0
-  };
-}
-function routeOutcomeMetrics(realized) {
-  return {
-    outcome: realized.outcome,
-    qualityLabel: realized.qualityLabel,
-    firstPass: realized.firstPass,
-    escalated: realized.attempt > 0,
-    attempts: realized.attempt + 1,
-    costUsd: realized.costUsd,
-    endToEndMs: realized.endToEndMs
-  };
-}
-function evaluateRouteDecision(decision, realized) {
-  return {
-    regret: routeRegret(decision),
-    validity: routeConstraintValidity(decision),
-    calibration: routePredictionCalibration(decision, realized),
-    outcome: routeOutcomeMetrics(realized)
-  };
-}
-
-export {
-  WORKER_CONTEXT_MAX_BYTES,
-  parseWorkerContextProvenance,
-  parseWorkerContextSeed,
-  seededWorkerMessages,
-  contextHash,
-  messageToolCalls,
-  completeHistoryLength,
-  ROUTE_POLICY_VERSION,
-  routePriorForLatencyClass,
-  routeObservationFromHistory,
-  estimateRoute,
-  evaluateRouteReadiness,
-  isRouteDecisionAgentSelection,
-  routeCapabilityKey,
-  routeDriftGuard,
-  routeDriftInvalidates,
-  routeCandidateKey,
-  sameRouteIdentity,
-  toRouteCandidate,
-  decideRoute,
-  fixedRouteDecision,
-  routeConstraintValidity,
-  evaluateRouteDecision,
-  isRoutingIntent,
-  parseRoutingIntent,
-  defaultRoutingIntent,
-  routingIntentRejection,
-  explainRouteDecision
-};
-//# sourceMappingURL=chunk-MO65K5CH.js.map