token-harness 0.1.18 → 0.1.19

package/token-harness.mjs

@@ -656,6 +656,65 @@ function parseLocalUsage(value3) {
   }
   return { inputTokens, cacheCreationTokens, cacheReadTokens, outputTokens, totalTokens };
 }
+function parseTaskBenchmarkCcrUsage(value3) {
+  if (value3 === null)
+    return null;
+  const row2 = record(value3);
+  if (row2 === null || row2["schemaVersion"] !== 1)
+    return void 0;
+  const status = row2["status"];
+  const sessionCount = finiteNonNegative(row2["sessionCount"]);
+  const observedSessionCount = finiteNonNegative(row2["observedSessionCount"]);
+  const requestCount = finiteNonNegative(row2["requestCount"]);
+  const inputTokens = finiteNonNegative(row2["inputTokens"]);
+  const outputTokens = finiteNonNegative(row2["outputTokens"]);
+  const cacheReadTokens = finiteNonNegative(row2["cacheReadTokens"]);
+  const cacheWriteTokens = finiteNonNegative(row2["cacheWriteTokens"]);
+  const totalTokens = finiteNonNegative(row2["totalTokens"]);
+  const recordedCostUsd = nullableFiniteNonNegative(row2["recordedCostUsd"]);
+  if (status !== "observed" && status !== "partial" && status !== "unavailable" || sessionCount === null || observedSessionCount === null || requestCount === null || inputTokens === null || outputTokens === null || cacheReadTokens === null || cacheWriteTokens === null || totalTokens === null || recordedCostUsd === void 0 || observedSessionCount > sessionCount || !Array.isArray(row2["byModel"])) {
+    return void 0;
+  }
+  const byModel = [];
+  for (const item of row2["byModel"]) {
+    const modelRow = record(item);
+    if (modelRow === null || typeof modelRow["model"] !== "string" || !/^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(modelRow["model"]))
+      return void 0;
+    const modelRequestCount = finiteNonNegative(modelRow["requestCount"]);
+    const modelInputTokens = finiteNonNegative(modelRow["inputTokens"]);
+    const modelOutputTokens = finiteNonNegative(modelRow["outputTokens"]);
+    const modelCacheReadTokens = finiteNonNegative(modelRow["cacheReadTokens"]);
+    const modelCacheWriteTokens = finiteNonNegative(modelRow["cacheWriteTokens"]);
+    const modelTotalTokens = finiteNonNegative(modelRow["totalTokens"]);
+    const modelCost = nullableFiniteNonNegative(modelRow["recordedCostUsd"]);
+    if (modelRequestCount === null || modelInputTokens === null || modelOutputTokens === null || modelCacheReadTokens === null || modelCacheWriteTokens === null || modelTotalTokens === null || modelCost === void 0)
+      return void 0;
+    byModel.push({
+      model: modelRow["model"],
+      requestCount: modelRequestCount,
+      inputTokens: modelInputTokens,
+      outputTokens: modelOutputTokens,
+      cacheReadTokens: modelCacheReadTokens,
+      cacheWriteTokens: modelCacheWriteTokens,
+      totalTokens: modelTotalTokens,
+      recordedCostUsd: modelCost
+    });
+  }
+  return {
+    schemaVersion: 1,
+    status,
+    sessionCount,
+    observedSessionCount,
+    requestCount,
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    totalTokens,
+    recordedCostUsd,
+    byModel
+  };
+}
 function parseLocalSessionSnapshot(value3) {
   const row2 = record(value3);
   if (row2 === null)
@@ -842,7 +901,9 @@ function parseTaskBenchmarkReceipt(value3) {
   const contextAtStart = hasContextAtStart ? parseTaskBenchmarkContextSnapshot(row2["contextAtStart"]) : void 0;
   const hasContextAtFinish = Object.hasOwn(row2, "contextAtFinish");
   const contextAtFinish = hasContextAtFinish ? parseTaskBenchmarkContextSnapshot(row2["contextAtFinish"]) : void 0;
-  if (typeof benchmarkId !== "string" || benchmarkId === "" || typeof variant !== "string" || !isTaskBenchmarkVariant(variant) || typeof taskClass !== "string" || !isTaskClass(taskClass) || typeof harnessId2 !== "string" || !isHarnessId(harnessId2) || model === void 0 || reasoningEffort === void 0 || verbosity === void 0 || !validInstant(startedAt) || !validInstant(completedAt) || Date.parse(completedAt) < Date.parse(startedAt) || usageBefore === null || usageAfter === null || localUsage === void 0 || outcome2 === null || hasBoundaryPolicy && policyAtFinish === void 0 || hasContextAtStart && contextAtStart === void 0 || hasContextAtFinish && contextAtFinish === void 0) {
+  const hasCcrUsage = Object.hasOwn(row2, "ccrUsage");
+  const ccrUsage = hasCcrUsage ? parseTaskBenchmarkCcrUsage(row2["ccrUsage"]) : void 0;
+  if (typeof benchmarkId !== "string" || benchmarkId === "" || typeof variant !== "string" || !isTaskBenchmarkVariant(variant) || typeof taskClass !== "string" || !isTaskClass(taskClass) || typeof harnessId2 !== "string" || !isHarnessId(harnessId2) || model === void 0 || reasoningEffort === void 0 || verbosity === void 0 || !validInstant(startedAt) || !validInstant(completedAt) || Date.parse(completedAt) < Date.parse(startedAt) || usageBefore === null || usageAfter === null || localUsage === void 0 || outcome2 === null || hasBoundaryPolicy && policyAtFinish === void 0 || hasContextAtStart && contextAtStart === void 0 || hasContextAtFinish && contextAtFinish === void 0 || hasCcrUsage && ccrUsage === void 0) {
     return {
       ok: false,
       reason: "invalid-shape",
@@ -868,7 +929,8 @@ function parseTaskBenchmarkReceipt(value3) {
       outcome: outcome2,
       ...hasContextAtStart ? { contextAtStart: contextAtStart ?? null } : {},
       ...hasContextAtFinish ? { contextAtFinish: contextAtFinish ?? null } : {},
-      ...hasBoundaryPolicy ? { policyAtFinish: policyAtFinish ?? null } : {}
+      ...hasBoundaryPolicy ? { policyAtFinish: policyAtFinish ?? null } : {},
+      ...hasCcrUsage ? { ccrUsage: ccrUsage ?? null } : {}
     }
   };
 }
@@ -890,6 +952,7 @@ function completeTaskBenchmarkCapture(capture, input) {
     ...capture.contextAtStart !== void 0 ? { contextAtStart: capture.contextAtStart } : {},
     ...input.contextAtFinish !== void 0 ? { contextAtFinish: input.contextAtFinish } : {},
     ...input.policyAtFinish !== void 0 ? { policyAtFinish: input.policyAtFinish } : {},
+    ...input.ccrUsage !== void 0 ? { ccrUsage: input.ccrUsage } : {},
     outcome: {
       qualityGate: input.qualityGate,
       attempts: input.attempts,
@@ -973,7 +1036,7 @@ function pairedQuota(baseline, optimized) {
 function result(benchmarkId, verdict, basis, evidenceLevel, quota, reasons) {
   return { benchmarkId, verdict, basis, evidenceLevel, quota, reasons };
 }
-function compareTaskBenchmarkReceipts(baseline, optimized) {
+function compareTaskBenchmarkReceiptsCore(baseline, optimized) {
   const reasons = [];
   if (baseline.benchmarkId !== optimized.benchmarkId || baseline.taskClass !== optimized.taskClass || baseline.harnessId !== optimized.harnessId || baseline.variant !== "baseline" || optimized.variant !== "optimized") {
     return result(baseline.benchmarkId, "incomparable", "none", "none", null, [
@@ -1044,6 +1107,49 @@ function compareTaskBenchmarkReceipts(baseline, optimized) {
     "quality matched but no efficiency evidence separated the receipts"
   ]);
 }
+function compareCcrUsage(baseline, optimized, samePair) {
+  if (!samePair) {
+    return {
+      status: "not-measured",
+      baselineRequests: null,
+      optimizedRequests: null,
+      baselineTokens: null,
+      optimizedTokens: null,
+      totalTokenDelta: null,
+      baselineModels: [],
+      optimizedModels: [],
+      baselineRecordedCostUsd: null,
+      optimizedRecordedCostUsd: null,
+      recordedCostDeltaUsd: null
+    };
+  }
+  const left = baseline.ccrUsage ?? null;
+  const right = optimized.ccrUsage ?? null;
+  const status = left === null || right === null || left.status === "unavailable" || right.status === "unavailable" ? "not-measured" : left.status !== "observed" || right.status !== "observed" ? "partial" : baseline.outcome.qualityGate !== "passed" || optimized.outcome.qualityGate !== "passed" ? "quality-gated" : "comparable";
+  const canCompare = status === "comparable";
+  const baselineRecordedCostUsd = left?.recordedCostUsd ?? null;
+  const optimizedRecordedCostUsd = right?.recordedCostUsd ?? null;
+  return {
+    status,
+    baselineRequests: left?.requestCount ?? null,
+    optimizedRequests: right?.requestCount ?? null,
+    baselineTokens: left?.totalTokens ?? null,
+    optimizedTokens: right?.totalTokens ?? null,
+    totalTokenDelta: canCompare && left && right ? right.totalTokens - left.totalTokens : null,
+    baselineModels: left?.byModel.map((row2) => row2.model) ?? [],
+    optimizedModels: right?.byModel.map((row2) => row2.model) ?? [],
+    baselineRecordedCostUsd,
+    optimizedRecordedCostUsd,
+    recordedCostDeltaUsd: canCompare && baselineRecordedCostUsd !== null && optimizedRecordedCostUsd !== null ? optimizedRecordedCostUsd - baselineRecordedCostUsd : null
+  };
+}
+function compareTaskBenchmarkReceipts(baseline, optimized) {
+  const samePair = baseline.benchmarkId === optimized.benchmarkId && baseline.taskClass === optimized.taskClass && baseline.harnessId === optimized.harnessId && baseline.variant === "baseline" && optimized.variant === "optimized";
+  return {
+    ...compareTaskBenchmarkReceiptsCore(baseline, optimized),
+    ccrUsage: compareCcrUsage(baseline, optimized, samePair)
+  };
+}
 function roundedPercent(numerator, denominator) {
   if (denominator <= 0)
     return null;
@@ -1053,6 +1159,14 @@ function summarizeMatrixEntries(entries, taskClass) {
   const local = entries.filter((entry) => entry.localTokenSavingPercent !== null && entry.baselineLocalTokens !== null && entry.optimizedLocalTokens !== null);
   const baselineLocalTokens = local.length === 0 ? null : local.reduce((total, entry) => total + (entry.baselineLocalTokens ?? 0), 0);
   const optimizedLocalTokens = local.length === 0 ? null : local.reduce((total, entry) => total + (entry.optimizedLocalTokens ?? 0), 0);
+  const ccrRows = entries.flatMap((entry) => entry.ccrUsage === void 0 ? [] : [entry.ccrUsage]);
+  const comparableCcrRows = ccrRows.filter((row2) => row2.status === "comparable");
+  const ccrCostRows = comparableCcrRows.filter((row2) => row2.recordedCostDeltaUsd !== null);
+  const hasCcrEvidence = ccrRows.some((row2) => row2.status !== "not-measured");
+  const baselineCcrTokens = comparableCcrRows.length === 0 ? null : comparableCcrRows.reduce((total, row2) => total + (row2.baselineTokens ?? 0), 0);
+  const optimizedCcrTokens = comparableCcrRows.length === 0 ? null : comparableCcrRows.reduce((total, row2) => total + (row2.optimizedTokens ?? 0), 0);
+  const baselineRecordedCostUsd = ccrCostRows.length === 0 ? null : ccrCostRows.reduce((total, row2) => total + (row2.baselineRecordedCostUsd ?? 0), 0);
+  const optimizedRecordedCostUsd = ccrCostRows.length === 0 ? null : ccrCostRows.reduce((total, row2) => total + (row2.optimizedRecordedCostUsd ?? 0), 0);
   return {
     taskClass,
     pairs: entries.length,
@@ -1067,7 +1181,24 @@ function summarizeMatrixEntries(entries, taskClass) {
     localComparablePairs: local.length,
     baselineLocalTokens,
     optimizedLocalTokens,
-    localTokenSavingPercent: baselineLocalTokens === null || optimizedLocalTokens === null ? null : roundedPercent(baselineLocalTokens - optimizedLocalTokens, baselineLocalTokens)
+    localTokenSavingPercent: baselineLocalTokens === null || optimizedLocalTokens === null ? null : roundedPercent(baselineLocalTokens - optimizedLocalTokens, baselineLocalTokens),
+    ...hasCcrEvidence ? {
+      ccrUsage: {
+        comparablePairs: comparableCcrRows.length,
+        partialPairs: ccrRows.filter((row2) => row2.status === "partial").length,
+        qualityGatedPairs: ccrRows.filter((row2) => row2.status === "quality-gated").length,
+        notMeasuredPairs: ccrRows.filter((row2) => row2.status === "not-measured").length,
+        baselineRequests: comparableCcrRows.length === 0 ? null : comparableCcrRows.reduce((total, row2) => total + (row2.baselineRequests ?? 0), 0),
+        optimizedRequests: comparableCcrRows.length === 0 ? null : comparableCcrRows.reduce((total, row2) => total + (row2.optimizedRequests ?? 0), 0),
+        baselineTokens: baselineCcrTokens,
+        optimizedTokens: optimizedCcrTokens,
+        totalTokenDelta: baselineCcrTokens === null || optimizedCcrTokens === null ? null : optimizedCcrTokens - baselineCcrTokens,
+        recordedCostPairs: ccrCostRows.length,
+        baselineRecordedCostUsd,
+        optimizedRecordedCostUsd,
+        recordedCostDeltaUsd: baselineRecordedCostUsd === null || optimizedRecordedCostUsd === null ? null : optimizedRecordedCostUsd - baselineRecordedCostUsd
+      }
+    } : {}
   };
 }
 function buildTaskBenchmarkMatrix(pairs, selection = {
@@ -1093,7 +1224,8 @@ function buildTaskBenchmarkMatrix(pairs, selection = {
       baselineLocalTokens,
       optimizedLocalTokens,
       localTokenSavingPercent: !bothQualityPassed || baselineLocalTokens === null || optimizedLocalTokens === null ? null : roundedPercent(baselineLocalTokens - optimizedLocalTokens, baselineLocalTokens),
-      quota: comparison.quota
+      quota: comparison.quota,
+      ...comparison.ccrUsage === void 0 ? {} : { ccrUsage: comparison.ccrUsage }
     };
   }).sort((left, right) => TASK_CLASS_ORDER.indexOf(left.taskClass) - TASK_CLASS_ORDER.indexOf(right.taskClass) || left.benchmarkId.localeCompare(right.benchmarkId));
   const byTaskClass = TASK_CLASS_ORDER.map((taskClass) => ({
@@ -3790,6 +3922,280 @@ var init_model_learning = __esm({
   }
 });
 
+// packages/core/dist/src/domain/smart-routing.js
+function classifySmartRoutingPrompt(input) {
+  const original = typeof input.text === "string" ? input.text : "";
+  const text3 = original.trim();
+  const normalized = text3.toLowerCase();
+  const words = normalized.match(/[\p{L}\p{N}_]+/gu) ?? [];
+  const wordCount = words.length;
+  const hasImage = input.hasImage === true;
+  const toolCount = Number.isSafeInteger(input.toolCount) && (input.toolCount ?? 0) > 0 ? input.toolCount : 0;
+  const codePresent = /```|(?:^|\n)\s*(?:function|class|interface|type|import|export|const|let|var)\s+\w/m.test(text3) || /\b(?:stack trace|traceback|SELECT\s+.+\s+FROM|npm ERR!|TS\d{3,5})\b/i.test(text3) || /(?:=>|\b\w+\([^\n)]*\)\s*\{|\b(?:def|fn)\s+\w+\s*\()/m.test(text3);
+  const technicalTerms = [
+    "api",
+    "architecture",
+    "async",
+    "authentication",
+    "database",
+    "distributed",
+    "encryption",
+    "filesystem",
+    "invariant",
+    "migration",
+    "network",
+    "parallel",
+    "protocol",
+    "race condition",
+    "regression",
+    "security",
+    "sql",
+    "thread",
+    "transaction",
+    "typescript"
+  ];
+  let technicalTermCount = 0;
+  for (const term of technicalTerms) {
+    if (normalized.includes(term))
+      technicalTermCount += 1;
+  }
+  const reasoningMarkers = [
+    "analyze",
+    "analyse",
+    "compare",
+    "debug",
+    "design",
+    "evaluate",
+    "investigate",
+    "optimize",
+    "reason through",
+    "root cause",
+    "trade-off",
+    "tradeoff",
+    "why",
+    "step by step"
+  ];
+  let reasoningMarkerCount = 0;
+  for (const marker of reasoningMarkers) {
+    if (normalized.includes(marker))
+      reasoningMarkerCount += 1;
+  }
+  const simpleIndicator = /^(?:hi|hello|hey|thanks|thank you|define\b|what is\b|what does\b|translate\b|rewrite\b|fix typo\b|format\b|summarize\b|summarise\b)/i.test(text3);
+  const multiStep = /\b(?:first|then|finally|step\s+\d+|in\s+three\s+steps)\b/i.test(text3) || /(?:^|\n)\s*\d+[.)]\s+\S/m.test(text3) || /\b(?:and then|after that|before you)\b/i.test(text3);
+  const questionCount = (text3.match(/\?/g) ?? []).length;
+  const longPrompt = wordCount >= 100 || Number.isFinite(input.inputTokens) && (input.inputTokens ?? 0) >= 1200;
+  const veryLongPrompt = wordCount >= 300 || Number.isFinite(input.inputTokens) && (input.inputTokens ?? 0) >= 5e3;
+  const reasonCodes = [];
+  let score = 0;
+  if (wordCount > 0 && wordCount <= 12) {
+    score -= 1.5;
+    reasonCodes.push("short-prompt");
+  } else if (wordCount >= 30 && wordCount < 100) {
+    score += 0.5;
+    reasonCodes.push("medium-prompt");
+  } else if (longPrompt) {
+    score += 1.5;
+    reasonCodes.push("long-prompt");
+  }
+  if (veryLongPrompt) {
+    score += 1;
+    reasonCodes.push("very-long-prompt");
+  }
+  if (codePresent) {
+    score += 2.5;
+    reasonCodes.push("code-present");
+  }
+  if (technicalTermCount > 0) {
+    score += Math.min(technicalTermCount, 3) * 0.75;
+    reasonCodes.push("technical-terms");
+  }
+  if (reasoningMarkerCount > 0) {
+    score += reasoningMarkerCount >= 2 ? 3.5 : 1.5;
+    reasonCodes.push(reasoningMarkerCount >= 2 ? "multiple-reasoning-markers" : "reasoning-marker");
+  }
+  if (multiStep) {
+    score += 1.5;
+    reasonCodes.push("multi-step-request");
+  }
+  if (questionCount > 1) {
+    score += Math.min(questionCount - 1, 3) * 0.5;
+    reasonCodes.push("multiple-questions");
+  }
+  if (simpleIndicator) {
+    score -= 2;
+    reasonCodes.push("simple-language-indicator");
+  }
+  if (hasImage) {
+    score += 3;
+    reasonCodes.push("image-input");
+  }
+  if (wordCount === 0)
+    reasonCodes.push("empty-user-text");
+  if (toolCount > 0)
+    reasonCodes.push("tool-schema-present");
+  const shortFollowUp = wordCount > 0 && wordCount <= 4 && !simpleIndicator;
+  if (shortFollowUp) {
+    score = Math.max(score, 0.25);
+    reasonCodes.push("possible-contextual-follow-up");
+  }
+  let tier;
+  if (hasImage)
+    tier = "complex";
+  else if (reasoningMarkerCount >= 2 || score >= 5)
+    tier = "critical";
+  else if (codePresent || technicalTermCount >= 2 || score >= 1.75)
+    tier = "complex";
+  else if (score <= -1.25 && simpleIndicator && !shortFollowUp)
+    tier = "simple";
+  else
+    tier = "standard";
+  const boundaries = [-1.25, 1.75, 5];
+  let boundaryDistance = Number.POSITIVE_INFINITY;
+  for (const boundary of boundaries)
+    boundaryDistance = Math.min(boundaryDistance, Math.abs(score - boundary));
+  const signalCount = reasonCodes.length;
+  const confidence = wordCount === 0 ? "low" : signalCount >= 2 && boundaryDistance >= 1.25 && tier !== "standard" ? "high" : signalCount >= 1 && boundaryDistance >= 0.5 ? "medium" : "low";
+  const conservativeEligible = tier === "simple" && confidence === "high" && simpleIndicator && !codePresent && technicalTermCount === 0 && reasoningMarkerCount === 0 && !multiStep && questionCount <= 1 && !hasImage && text3.length <= 320;
+  return {
+    classifierVersion: "heuristic-v1",
+    tier,
+    score: Math.round(score * 100) / 100,
+    confidence,
+    reasonCodes,
+    promptChars: text3.length,
+    wordCount,
+    codePresent,
+    technicalTermCount,
+    reasoningMarkerCount,
+    multiStep,
+    hasImage,
+    toolCount,
+    conservativeEligible
+  };
+}
+var SMART_ROUTING_CLASSIFIER_VERSION;
+var init_smart_routing = __esm({
+  "packages/core/dist/src/domain/smart-routing.js"() {
+    "use strict";
+    SMART_ROUTING_CLASSIFIER_VERSION = "heuristic-v1";
+  }
+});
+
+// packages/core/dist/src/domain/smart-routing-telemetry.js
+function isRecord(value3) {
+  return value3 !== null && typeof value3 === "object" && !Array.isArray(value3);
+}
+function isTier(value3) {
+  return value3 === "simple" || value3 === "standard" || value3 === "complex" || value3 === "critical";
+}
+function hasExactKeys(value3, keys) {
+  const actual = Object.keys(value3).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isSafeModelId(value3) {
+  return value3 === null || typeof value3 === "string" && /^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(value3);
+}
+function isSmartRoutingDecisionEvent(value3) {
+  if (!isRecord(value3) || !isRecord(value3["measurement"]))
+    return false;
+  const event = value3;
+  const measurement = event.measurement;
+  const schemaVersion = value3["schemaVersion"];
+  const keys = [
+    "schemaVersion",
+    "eventId",
+    "timestamp",
+    "source",
+    "harnessId",
+    "mode",
+    "classifierVersion",
+    "tier",
+    "score",
+    "confidence",
+    "reasonCodes",
+    "requestModel",
+    "candidateModel",
+    "routeMutationRequested",
+    "routeSkipReason",
+    "promptChars",
+    "requestInputTokenEstimate",
+    "toolCount",
+    "hasImage",
+    "decisionLatencyMs",
+    "measurement"
+  ];
+  const isV2 = schemaVersion === SMART_ROUTING_EVENT_SCHEMA_VERSION;
+  if (isV2)
+    keys.push("sessionId");
+  return hasExactKeys(value3, keys) && hasExactKeys(value3["measurement"], [
+    "status",
+    "resolvedModel",
+    "providerInputTokens",
+    "providerOutputTokens",
+    "qualityGate"
+  ]) && (event.schemaVersion === 1 || event.schemaVersion === SMART_ROUTING_EVENT_SCHEMA_VERSION) && typeof event.eventId === "string" && /^[0-9]{13}-[a-z0-9]+$/.test(event.eventId) && typeof event.timestamp === "string" && event.source === "ccr" && (event.harnessId === "claude" || event.harnessId === "codex") && (event.mode === "shadow" || event.mode === "conservative") && event.classifierVersion === "heuristic-v1" && isTier(event.tier) && Number.isFinite(event.score) && (event.confidence === "low" || event.confidence === "medium" || event.confidence === "high") && Array.isArray(value3["reasonCodes"]) && event.reasonCodes.every((item) => typeof item === "string" && ALLOWED_REASON_CODES.has(item)) && isSafeModelId(event.requestModel) && isSafeModelId(event.candidateModel) && typeof event.routeMutationRequested === "boolean" && (event.routeSkipReason === null || ALLOWED_SKIP_REASONS.has(event.routeSkipReason)) && Number.isSafeInteger(event.promptChars) && event.promptChars >= 0 && (event.requestInputTokenEstimate === null || Number.isSafeInteger(event.requestInputTokenEstimate) && event.requestInputTokenEstimate >= 0) && Number.isSafeInteger(event.toolCount) && event.toolCount >= 0 && typeof event.hasImage === "boolean" && Number.isFinite(event.decisionLatencyMs) && event.decisionLatencyMs >= 0 && (!isV2 || event.sessionId === null || typeof event.sessionId === "string" && /^[A-Za-z0-9_.:-]{1,256}$/.test(event.sessionId)) && measurement.status === "not-measured" && measurement.resolvedModel === null && measurement.providerInputTokens === null && measurement.providerOutputTokens === null && measurement.qualityGate === "unknown";
+}
+function aggregateSmartRoutingEvents(input) {
+  const report = {
+    schemaVersion: 1,
+    retainedDecisionCount: input.events.length,
+    byHarness: { claude: 0, codex: 0 },
+    byMode: { shadow: 0, conservative: 0 },
+    byTier: { simple: 0, standard: 0, complex: 0, critical: 0 },
+    routeMutationRequestCount: 0,
+    malformedRecordCount: input.malformedRecordCount ?? 0,
+    prunedRecordCount: input.prunedRecordCount ?? 0,
+    retentionLimit: SMART_ROUTING_EVENT_RETENTION_LIMIT,
+    savingsStatus: "not-measured",
+    savingsMeasurementCount: 0
+  };
+  for (const event of input.events) {
+    report.byHarness[event.harnessId] += 1;
+    report.byMode[event.mode] += 1;
+    report.byTier[event.tier] += 1;
+    if (event.routeMutationRequested)
+      report.routeMutationRequestCount += 1;
+  }
+  return report;
+}
+var SMART_ROUTING_EVENT_SCHEMA_VERSION, SMART_ROUTING_EVENT_PREFIX, SMART_ROUTING_EVENT_RETENTION_LIMIT, ALLOWED_REASON_CODES, ALLOWED_SKIP_REASONS;
+var init_smart_routing_telemetry = __esm({
+  "packages/core/dist/src/domain/smart-routing-telemetry.js"() {
+    "use strict";
+    SMART_ROUTING_EVENT_SCHEMA_VERSION = 2;
+    SMART_ROUTING_EVENT_PREFIX = "smart-routing-";
+    SMART_ROUTING_EVENT_RETENTION_LIMIT = 200;
+    ALLOWED_REASON_CODES = /* @__PURE__ */ new Set([
+      "short-prompt",
+      "medium-prompt",
+      "long-prompt",
+      "very-long-prompt",
+      "code-present",
+      "technical-terms",
+      "reasoning-marker",
+      "multiple-reasoning-markers",
+      "multi-step-request",
+      "multiple-questions",
+      "simple-language-indicator",
+      "image-input",
+      "empty-user-text",
+      "tool-schema-present",
+      "possible-contextual-follow-up"
+    ]);
+    ALLOWED_SKIP_REASONS = /* @__PURE__ */ new Set([
+      "shadow-mode",
+      "unsupported-mode",
+      "complexity-not-simple",
+      "simple-model-not-configured",
+      "request-model-unavailable",
+      "conservative-safety-gate",
+      "tool-compatibility-unconfirmed",
+      "model-already-selected"
+    ]);
+  }
+});
+
 // packages/core/dist/src/domain/action-conflicts.js
 function markerAction(action) {
   return action.kind === "patch-marker-block";
@@ -7146,8 +7552,8 @@ function parseJsonDocumentText(text3) {
       document: JSON.parse(body),
       formatting: detectJsonFormatting(text3)
     };
-  } catch (error) {
-    return { state: "malformed", reason: error instanceof Error ? error.message : String(error) };
+  } catch (error2) {
+    return { state: "malformed", reason: error2 instanceof Error ? error2.message : String(error2) };
   }
 }
 function clone(value3) {
@@ -8518,12 +8924,12 @@ async function applyCodexConfigBatchWrite(action, context) {
     }
   }
   const response = messages.find((message) => typeof message === "object" && message !== null && !Array.isArray(message) && (message["id"] === CODEX_CONFIG_WRITE_REQUEST_ID || message["id"] === 2));
-  const error = response !== void 0 && typeof response["error"] === "object" && response["error"] !== null && !Array.isArray(response["error"]) ? response["error"] : null;
-  const errorText = error === null ? "" : [error["message"], error["data"]].map((value3) => typeof value3 === "string" ? value3 : JSON.stringify(value3)).filter((value3) => value3 !== void 0 && value3 !== "").join(" ");
+  const error2 = response !== void 0 && typeof response["error"] === "object" && response["error"] !== null && !Array.isArray(response["error"]) ? response["error"] : null;
+  const errorText = error2 === null ? "" : [error2["message"], error2["data"]].map((value3) => typeof value3 === "string" ? value3 : JSON.stringify(value3)).filter((value3) => value3 !== void 0 && value3 !== "").join(" ");
   if (/configVersionConflict/i.test(errorText)) {
     return drift(action, action.path, "Codex reports that config.toml changed after this plan observed its config version");
   }
-  if (result6.exitCode !== 0 || response === void 0 || error !== null || !("result" in response)) {
+  if (result6.exitCode !== 0 || response === void 0 || error2 !== null || !("result" in response)) {
     return outcome(action, "failed", {
       snapshots: [snapshot],
       diagnostics: [
@@ -9027,8 +9433,8 @@ function parseJsoncDocumentText(text3) {
       state: "parsed",
       document: JSON.parse(withoutTrailingCommas(withoutComments(text3)))
     };
-  } catch (error) {
-    return { state: "malformed", reason: error instanceof Error ? error.message : String(error) };
+  } catch (error2) {
+    return { state: "malformed", reason: error2 instanceof Error ? error2.message : String(error2) };
   }
 }
 var init_jsonc = __esm({
@@ -9372,8 +9778,8 @@ async function executeTransaction(request) {
     let restoreError = null;
     try {
       await request.snapshots.restoreAll(snapshots);
-    } catch (error) {
-      restoreError = error instanceof Error ? error.message : String(error);
+    } catch (error2) {
+      restoreError = error2 instanceof Error ? error2.message : String(error2);
     }
     const unrestored = await verifyRestoration(request.fs, snapshots);
     const packageDiagnostics = await restorePackageInventories(applied, request.runner ?? null, request.projectRoot);
@@ -9400,7 +9806,7 @@ async function executeTransaction(request) {
     let result6;
     try {
       result6 = await applyAction(action, context);
-    } catch (error) {
+    } catch (error2) {
       result6 = {
         actionId: action.id,
         kind: action.kind,
@@ -9412,7 +9818,7 @@ async function executeTransaction(request) {
           diagnostic({
             severity: "error",
             code: "action-failed",
-            message: `The action ${action.id} failed: ${error instanceof Error ? error.message : String(error)}`,
+            message: `The action ${action.id} failed: ${error2 instanceof Error ? error2.message : String(error2)}`,
             path: action.affectedPaths[0] ?? null,
             remediation: "Check the path is writable, then run the command again"
           })
@@ -9507,8 +9913,8 @@ async function rollbackTransaction(request) {
   let restoreError = null;
   try {
     await request.snapshots.restoreAll(snapshots);
-  } catch (error) {
-    restoreError = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    restoreError = error2 instanceof Error ? error2.message : String(error2);
   }
   const unrestored = await verifyRestoration(request.fs, snapshots);
   const packageDiagnostics = await restorePackageInventories(journal.entries, request.runner ?? null, request.cwd ?? journal.projectRoot);
@@ -9601,6 +10007,8 @@ var init_src = __esm({
     init_outcome_learning();
     init_verbosity_learning();
     init_model_learning();
+    init_smart_routing();
+    init_smart_routing_telemetry();
     init_action_conflicts();
     init_capabilities();
     init_compatibility_rows();
@@ -9660,7 +10068,7 @@ var TOOL_VERSION;
 var init_version2 = __esm({
   "apps/cli/dist/src/version.js"() {
     "use strict";
-    TOOL_VERSION = "0.1.18";
+    TOOL_VERSION = "0.1.19";
   }
 });
 
@@ -10259,19 +10667,19 @@ var init_node_filesystem = __esm({
             // reporting them would invite a caller to treat them as one.
             mode: this.nativeWindows ? null : octal(info.mode)
           };
-        } catch (error) {
-          if (error.code === "ENOENT")
+        } catch (error2) {
+          if (error2.code === "ENOENT")
             return null;
-          throw error;
+          throw error2;
         }
       }
       async canonicalPath(path) {
         try {
           return await realpath(path);
-        } catch (error) {
-          if (error.code === "ENOENT")
+        } catch (error2) {
+          if (error2.code === "ENOENT")
             return null;
-          throw error;
+          throw error2;
         }
       }
       async readFile(path) {
@@ -10295,21 +10703,63 @@ var init_node_filesystem = __esm({
       async readDirectory(path) {
         try {
           return (await readdir(path)).sort();
-        } catch (error) {
-          if (error.code === "ENOENT")
+        } catch (error2) {
+          if (error2.code === "ENOENT")
             return [];
-          throw error;
+          throw error2;
         }
       }
     };
   }
 });
 
-// packages/platform/dist/src/artifacts/rtk-windows-release.js
+// packages/platform/dist/src/artifacts/rtk-release.js
 import { createHash as createHash2 } from "node:crypto";
 import { rename, rm as rm2 } from "node:fs/promises";
-import { inflateRawSync } from "node:zlib";
-function isRecord(value3) {
+import { gunzipSync, inflateRawSync } from "node:zlib";
+function rtkReleaseAssetForPlatform(platform) {
+  if (platform.os === "windows" && !platform.isWsl && platform.arch === "x64") {
+    return {
+      name: RTK_WINDOWS_RELEASE_ASSET,
+      executableName: "rtk.exe",
+      archiveFormat: "zip"
+    };
+  }
+  if (platform.os === "linux") {
+    if (platform.arch === "x64") {
+      return {
+        name: "rtk-x86_64-unknown-linux-musl.tar.gz",
+        executableName: "rtk",
+        archiveFormat: "tar.gz"
+      };
+    }
+    if (platform.arch === "arm64") {
+      return {
+        name: "rtk-aarch64-unknown-linux-gnu.tar.gz",
+        executableName: "rtk",
+        archiveFormat: "tar.gz"
+      };
+    }
+  }
+  if (platform.os === "macos") {
+    if (platform.arch === "x64") {
+      return {
+        name: "rtk-x86_64-apple-darwin.tar.gz",
+        executableName: "rtk",
+        archiveFormat: "tar.gz"
+      };
+    }
+    if (platform.arch === "arm64") {
+      return {
+        name: "rtk-aarch64-apple-darwin.tar.gz",
+        executableName: "rtk",
+        archiveFormat: "tar.gz"
+      };
+    }
+  }
+  return null;
+}
+function isRecord2(value3) {
   return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
 }
 function integer(value3) {
@@ -10402,8 +10852,8 @@ async function fetchBounded(input) {
     clearTimeout(timer);
   }
 }
-function parseReleaseMetadata(value3, version3) {
-  if (!isRecord(value3))
+function parseReleaseMetadata(value3, version3, selection) {
+  if (!isRecord2(value3))
     return { status: "invalid", message: "release metadata is not an object" };
   const tag = `v${version3}`;
   if (value3["tag_name"] !== tag || value3["draft"] !== false || value3["prerelease"] !== false) {
@@ -10415,30 +10865,30 @@ function parseReleaseMetadata(value3, version3) {
   const assets = value3["assets"];
   if (!Array.isArray(assets))
     return { status: "invalid", message: "release metadata has no asset list" };
-  const matching = assets.filter((asset2) => isRecord(asset2) && asset2["name"] === RTK_WINDOWS_RELEASE_ASSET);
+  const matching = assets.filter((asset2) => isRecord2(asset2) && asset2["name"] === selection.name);
   if (matching.length !== 1) {
     return {
       status: "invalid",
-      message: `release ${tag} must contain exactly one ${RTK_WINDOWS_RELEASE_ASSET} asset`
+      message: `release ${tag} must contain exactly one ${selection.name} asset`
     };
   }
   const asset = matching[0];
-  if (!isRecord(asset))
+  if (!isRecord2(asset))
     return { status: "invalid", message: "release asset is malformed" };
   const digest = normalizeSha256(asset["digest"]);
   const size = integer(asset["size"]);
   const downloadUrl = typeof asset["browser_download_url"] === "string" ? asset["browser_download_url"] : null;
   if (digest === null) {
-    return { status: "invalid", message: `${RTK_WINDOWS_RELEASE_ASSET} has no published SHA-256` };
+    return { status: "invalid", message: `${selection.name} has no published SHA-256` };
   }
   if (size === null || size <= 0 || size > MAX_ARCHIVE_BYTES) {
     return {
       status: "invalid",
-      message: `${RTK_WINDOWS_RELEASE_ASSET} has an invalid or excessive published size`
+      message: `${selection.name} has an invalid or excessive published size`
     };
   }
   if (downloadUrl === null) {
-    return { status: "invalid", message: `${RTK_WINDOWS_RELEASE_ASSET} has no download URL` };
+    return { status: "invalid", message: `${selection.name} has no download URL` };
   }
   let parsedUrl;
   try {
@@ -10446,25 +10896,29 @@ function parseReleaseMetadata(value3, version3) {
   } catch {
     return {
       status: "invalid",
-      message: `${RTK_WINDOWS_RELEASE_ASSET} has an invalid download URL`
+      message: `${selection.name} has an invalid download URL`
     };
   }
   const expectedPrefix = `${RELEASE_DOWNLOAD_PREFIX}${tag}/`;
   if (!allowedAssetUrl(parsedUrl, true) || !downloadUrl.startsWith(expectedPrefix)) {
     return {
       status: "invalid",
-      message: `${RTK_WINDOWS_RELEASE_ASSET} points outside the reviewed rtk-ai/rtk release path`
+      message: `${selection.name} points outside the reviewed rtk-ai/rtk release path`
     };
   }
-  if (asset["content_type"] !== "application/zip") {
-    return { status: "invalid", message: `${RTK_WINDOWS_RELEASE_ASSET} is not published as a ZIP` };
+  const expectedContentType = selection.archiveFormat === "zip" ? "application/zip" : "application/gzip";
+  if (asset["content_type"] !== expectedContentType) {
+    return {
+      status: "invalid",
+      message: `${selection.name} is not published as ${expectedContentType}`
+    };
   }
   return {
     status: "found",
     asset: {
+      ...selection,
       version: version3,
       tag,
-      name: RTK_WINDOWS_RELEASE_ASSET,
       downloadUrl,
       sha256: digest,
       sizeBytes: size
@@ -10573,16 +11027,83 @@ function extractRtkExeFromVerifiedZip(bytes) {
     throw new Error("release ZIP contains no root rtk.exe");
   return extracted;
 }
+function tarText(buffer, offset, length) {
+  const field = buffer.subarray(offset, offset + length);
+  const end = field.indexOf(0);
+  return field.subarray(0, end < 0 ? field.length : end).toString("utf8");
+}
+function tarOctal(buffer, offset, length, fieldName) {
+  const raw = tarText(buffer, offset, length).trim();
+  if (raw === "")
+    return 0;
+  if (!/^[0-7]+$/.test(raw))
+    throw new Error(`tar ${fieldName} is not an octal value`);
+  const value3 = Number.parseInt(raw, 8);
+  if (!Number.isSafeInteger(value3) || value3 < 0)
+    throw new Error(`tar ${fieldName} is outside the supported range`);
+  return value3;
+}
+function extractRtkBinaryFromVerifiedTarGz(bytes) {
+  const compressed = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tar = gunzipSync(compressed, { maxOutputLength: MAX_EXPANDED_ARCHIVE_BYTES });
+  let cursor = 0;
+  let sawEnd = false;
+  let extracted = null;
+  while (cursor + TAR_BLOCK_BYTES <= tar.length) {
+    const header = tar.subarray(cursor, cursor + TAR_BLOCK_BYTES);
+    if (header.every((byte) => byte === 0)) {
+      sawEnd = true;
+      break;
+    }
+    const expectedChecksum = tarOctal(header, 148, 8, "checksum");
+    let checksum = 0;
+    for (let index = 0; index < TAR_BLOCK_BYTES; index += 1) {
+      checksum += index >= 148 && index < 156 ? 32 : header[index] ?? 0;
+    }
+    if (checksum !== expectedChecksum)
+      throw new Error("tar header checksum does not match");
+    const name2 = tarText(header, 0, 100);
+    const prefix = tarText(header, 345, 155);
+    const path = prefix === "" ? name2 : `${prefix}/${name2}`;
+    const type = header[156] === 0 ? "\0" : String.fromCharCode(header[156] ?? 0);
+    const size = tarOctal(header, 124, 12, "file size");
+    if (size > MAX_EXECUTABLE_BYTES)
+      throw new Error("tar entry exceeds the RTK executable size limit");
+    if (type !== "\0" && type !== "0" && type !== "5") {
+      throw new Error(`tar entry type ${JSON.stringify(type)} is not supported`);
+    }
+    const dataStart = cursor + TAR_BLOCK_BYTES;
+    const dataEnd = dataStart + size;
+    const next2 = dataStart + Math.ceil(size / TAR_BLOCK_BYTES) * TAR_BLOCK_BYTES;
+    if (dataEnd > tar.length || next2 > tar.length)
+      throw new Error("tar entry exceeds archive bounds");
+    if (path === "rtk") {
+      if (type === "5")
+        throw new Error("root rtk tar entry is a directory");
+      if (extracted !== null)
+        throw new Error("release tar contains more than one root rtk file");
+      if (size === 0)
+        throw new Error("root rtk tar entry is empty");
+      extracted = new Uint8Array(tar.subarray(dataStart, dataEnd));
+    }
+    cursor = next2;
+  }
+  if (!sawEnd)
+    throw new Error("tar end marker was not found");
+  if (extracted === null)
+    throw new Error("release tar contains no root rtk file");
+  return extracted;
+}
 function versionAppears(output, version3) {
   const escaped = version3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   return new RegExp(`(?:^|\\s)v?${escaped}(?:\\s|$)`, "m").test(output.trim());
 }
-function rtkWindowsReleaseRuntimeFor(fs, runner) {
-  return fs instanceof NodeFileSystem ? new NodeRtkWindowsReleaseRuntime({ fs, runner }) : null;
+function rtkReleaseRuntimeFor(fs, runner, fetchImpl) {
+  return fs instanceof NodeFileSystem ? new NodeRtkReleaseRuntime({ fs, runner, ...fetchImpl === void 0 ? {} : { fetchImpl } }) : null;
 }
-var RTK_WINDOWS_RELEASE_ASSET, RTK_RELEASE_METADATA_DESTINATION, RTK_RELEASE_ASSET_DESTINATION, RELEASE_API_PREFIX, RELEASE_DOWNLOAD_PREFIX, MAX_METADATA_BYTES, MAX_ARCHIVE_BYTES, MAX_EXECUTABLE_BYTES, MAX_REDIRECTS, FETCH_TIMEOUT_MS, ZIP_EOCD_SIGNATURE, ZIP_CENTRAL_SIGNATURE, ZIP_LOCAL_SIGNATURE, nativeFetch, NodeRtkWindowsReleaseRuntime;
-var init_rtk_windows_release = __esm({
-  "packages/platform/dist/src/artifacts/rtk-windows-release.js"() {
+var RTK_WINDOWS_RELEASE_ASSET, RTK_RELEASE_METADATA_DESTINATION, RTK_RELEASE_ASSET_DESTINATION, RELEASE_API_PREFIX, RELEASE_DOWNLOAD_PREFIX, MAX_METADATA_BYTES, MAX_ARCHIVE_BYTES, MAX_EXPANDED_ARCHIVE_BYTES, MAX_EXECUTABLE_BYTES, MAX_REDIRECTS, FETCH_TIMEOUT_MS, ZIP_EOCD_SIGNATURE, ZIP_CENTRAL_SIGNATURE, ZIP_LOCAL_SIGNATURE, TAR_BLOCK_BYTES, nativeFetch, NodeRtkReleaseRuntime;
+var init_rtk_release = __esm({
+  "packages/platform/dist/src/artifacts/rtk-release.js"() {
     "use strict";
     init_src();
     init_node_filesystem();
@@ -10593,14 +11114,16 @@ var init_rtk_windows_release = __esm({
     RELEASE_DOWNLOAD_PREFIX = "https://github.com/rtk-ai/rtk/releases/download/";
     MAX_METADATA_BYTES = 1024 * 1024;
     MAX_ARCHIVE_BYTES = 32 * 1024 * 1024;
+    MAX_EXPANDED_ARCHIVE_BYTES = 128 * 1024 * 1024;
     MAX_EXECUTABLE_BYTES = 64 * 1024 * 1024;
     MAX_REDIRECTS = 5;
     FETCH_TIMEOUT_MS = 2e4;
     ZIP_EOCD_SIGNATURE = 101010256;
     ZIP_CENTRAL_SIGNATURE = 33639248;
     ZIP_LOCAL_SIGNATURE = 67324752;
+    TAR_BLOCK_BYTES = 512;
     nativeFetch = async (url, init) => fetch(url, init);
-    NodeRtkWindowsReleaseRuntime = class {
+    NodeRtkReleaseRuntime = class {
       fs;
       runner;
       fetchImpl;
@@ -10609,10 +11132,17 @@ var init_rtk_windows_release = __esm({
         this.runner = input.runner;
         this.fetchImpl = input.fetchImpl ?? nativeFetch;
       }
-      async query(version3) {
+      async query(version3, platform) {
         if (parseSemanticVersion(version3) === null) {
           return { status: "invalid", message: `${version3} is not a semantic RTK release` };
         }
+        const selection = rtkReleaseAssetForPlatform(platform);
+        if (selection === null) {
+          return {
+            status: "invalid",
+            message: `RTK ${version3} does not publish a managed binary for ${platform.os}/${platform.arch}`
+          };
+        }
         const url = `${RELEASE_API_PREFIX}v${version3}`;
         let bytes;
         try {
@@ -10622,19 +11152,19 @@ var init_rtk_windows_release = __esm({
             maximumBytes: MAX_METADATA_BYTES,
             kind: "metadata"
           });
-        } catch (error) {
+        } catch (error2) {
           return {
             status: "unavailable",
-            message: `RTK release metadata could not be read: ${error instanceof Error ? error.message : String(error)}`
+            message: `RTK release metadata could not be read: ${error2 instanceof Error ? error2.message : String(error2)}`
           };
         }
         try {
           const value3 = JSON.parse(new TextDecoder().decode(bytes));
-          return parseReleaseMetadata(value3, version3);
-        } catch (error) {
+          return parseReleaseMetadata(value3, version3, selection);
+        } catch (error2) {
           return {
             status: "invalid",
-            message: `RTK release metadata is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+            message: `RTK release metadata is not valid JSON: ${error2 instanceof Error ? error2.message : String(error2)}`
           };
         }
       }
@@ -10650,7 +11180,7 @@ var init_rtk_windows_release = __esm({
         }
         const digest = createHash2("sha256").update(archive).digest("hex");
         if (digest !== asset.sha256)
-          throw new Error("downloaded RTK ZIP does not match GitHub published SHA-256");
+          throw new Error("downloaded RTK release archive does not match GitHub published SHA-256");
         return archive;
       }
       async verifyExecutable(path, version3, cwd) {
@@ -10689,23 +11219,23 @@ ${result6.stderr}`, version3);
           }
           const directory = this.fs.dirname(handle.targetPath);
           const stage = this.fs.join(directory, `.rtk.token-harness.rollback-${handle.previousDigest.slice(-12)}.tmp`);
-          const displaced = this.fs.join(directory, ".rtk.token-harness.rollback-displaced.exe");
+          const displaced = this.fs.join(directory, ".rtk.token-harness.rollback-displaced");
           if (await this.fs.stat(displaced) !== null) {
             return {
               status: "dirty",
               message: `RTK rollback staging path already exists: ${displaced}`
             };
           }
-          await this.fs.writeFile(stage, backup);
+          await this.fs.writeFile(stage, backup, handle.previousMode);
           await rename(handle.targetPath, displaced);
           try {
             await rename(stage, handle.targetPath);
-          } catch (error) {
+          } catch (error2) {
             await rename(displaced, handle.targetPath).catch(() => void 0);
             await rm2(stage, { force: true }).catch(() => void 0);
             return {
               status: "dirty",
-              message: `RTK rollback could not replace the executable: ${error instanceof Error ? error.message : String(error)}`
+              message: `RTK rollback could not replace the executable: ${error2 instanceof Error ? error2.message : String(error2)}`
             };
           }
           await rm2(displaced, { force: true });
@@ -10726,10 +11256,10 @@ ${result6.stderr}`, version3);
             status: "rolled-back",
             message: "RTK previous executable bytes and version were restored and verified"
           };
-        } catch (error) {
+        } catch (error2) {
           return {
             status: "dirty",
-            message: `RTK rollback failed: ${error instanceof Error ? error.message : String(error)}`
+            message: `RTK rollback failed: ${error2 instanceof Error ? error2.message : String(error2)}`
           };
         }
       }
@@ -10738,11 +11268,11 @@ ${result6.stderr}`, version3);
       }
       async install(input) {
         const targetName = this.fs.basename(input.targetPath).toLowerCase();
-        if (targetName !== "rtk.exe") {
+        if (targetName !== input.asset.executableName.toLowerCase()) {
           return {
             status: "failed",
             code: "rtk-release-target-refused",
-            message: `Resolved RTK target is not rtk.exe: ${input.targetPath}`,
+            message: `Resolved RTK target does not match the release executable name ${input.asset.executableName}: ${input.targetPath}`,
             backupPath: null
           };
         }
@@ -10755,16 +11285,24 @@ ${result6.stderr}`, version3);
             backupPath: null
           };
         }
+        if (input.asset.executableName === "rtk" && (targetStat.mode === null || (Number.parseInt(targetStat.mode, 8) & 73) === 0)) {
+          return {
+            status: "failed",
+            code: "rtk-release-target-not-executable",
+            message: `Resolved RTK target does not have readable POSIX executable permissions: ${input.targetPath}`,
+            backupPath: null
+          };
+        }
         let archive;
         let replacement;
         try {
           archive = await this.download(input.asset);
-          replacement = extractRtkExeFromVerifiedZip(archive);
-        } catch (error) {
+          replacement = input.asset.archiveFormat === "zip" ? extractRtkExeFromVerifiedZip(archive) : extractRtkBinaryFromVerifiedTarGz(archive);
+        } catch (error2) {
           return {
             status: "failed",
             code: "rtk-release-artifact-invalid",
-            message: error instanceof Error ? error.message : String(error),
+            message: error2 instanceof Error ? error2.message : String(error2),
             backupPath: null
           };
         }
@@ -10772,7 +11310,7 @@ ${result6.stderr}`, version3);
         const previousDigest = digestBytes(previous);
         const replacementDigest = digestBytes(replacement);
         const backupDirectory = this.fs.join(input.stateRoot, "backups", "rtk-release");
-        const backupPath = this.fs.join(backupDirectory, `rtk-${input.previousVersion ?? "unknown"}-${previousDigest.slice(-16)}.exe`);
+        const backupPath = this.fs.join(backupDirectory, `rtk-${input.previousVersion ?? "unknown"}-${previousDigest.slice(-16)}.bin`);
         await this.fs.createDirectory(backupDirectory);
         const existingBackup = await this.fs.stat(backupPath);
         if (existingBackup === null)
@@ -10787,7 +11325,7 @@ ${result6.stderr}`, version3);
         }
         const directory = this.fs.dirname(input.targetPath);
         const stage = this.fs.join(directory, `.rtk.token-harness-${input.asset.version}.tmp`);
-        const displaced = this.fs.join(directory, ".rtk.token-harness-previous.exe");
+        const displaced = this.fs.join(directory, ".rtk.token-harness-previous");
         if (await this.fs.stat(stage) !== null || await this.fs.stat(displaced) !== null) {
           return {
             status: "failed",
@@ -10797,18 +11335,18 @@ ${result6.stderr}`, version3);
           };
         }
         try {
-          await this.fs.writeFile(stage, replacement);
+          await this.fs.writeFile(stage, replacement, targetStat.mode);
           if (digestBytes(await this.fs.readFile(stage)) !== replacementDigest) {
-            throw new Error("staged rtk.exe does not match the extracted bytes");
+            throw new Error("staged RTK executable does not match the extracted bytes");
           }
           await rename(input.targetPath, displaced);
           try {
             await rename(stage, input.targetPath);
-          } catch (error) {
+          } catch (error2) {
             await rename(displaced, input.targetPath).catch(() => void 0);
-            throw error;
+            throw error2;
           }
-        } catch (error) {
+        } catch (error2) {
           await rm2(stage, { force: true }).catch(() => void 0);
           const live = await this.fs.stat(input.targetPath);
           if (live !== null && live.kind === "file" && digestBytes(await this.fs.readFile(input.targetPath)) === previousDigest) {
@@ -10816,14 +11354,14 @@ ${result6.stderr}`, version3);
             return {
               status: "rolled-back",
               code: "rtk-release-replacement-failed",
-              message: `RTK replacement failed before commit and the previous executable is intact: ${error instanceof Error ? error.message : String(error)}`,
+              message: `RTK replacement failed before commit and the previous executable is intact: ${error2 instanceof Error ? error2.message : String(error2)}`,
               backupPath
             };
           }
           return {
             status: "dirty",
             code: "rtk-release-replacement-dirty",
-            message: `RTK replacement failed and exact restoration could not be verified: ${error instanceof Error ? error.message : String(error)}`,
+            message: `RTK replacement failed and exact restoration could not be verified: ${error2 instanceof Error ? error2.message : String(error2)}`,
             backupPath
           };
         }
@@ -10832,6 +11370,7 @@ ${result6.stderr}`, version3);
           backupPath,
           previousDigest,
           replacementDigest,
+          previousMode: targetStat.mode,
           previousVersion: input.previousVersion,
           replacementVersion: input.asset.version
         };
@@ -10842,7 +11381,7 @@ ${result6.stderr}`, version3);
             return {
               status: "rolled-back",
               code: "rtk-release-postcondition-failed",
-              message: "The verified RTK release bytes were installed but Windows could not verify the new version; the previous executable was restored. Smart App Control or another application-control policy may have blocked the freshly released unsigned binary.",
+              message: "The verified RTK release bytes were installed but the new version could not be verified; the previous executable was restored. Check OS application-control policy and binary compatibility.",
               backupPath
             };
           }
@@ -10889,7 +11428,7 @@ async function resolveAttributionSalt(fs, stateRoot) {
   try {
     await fs.writeFile(path, new TextEncoder().encode(`${salt}
 `), "0600");
-  } catch (error) {
+  } catch (error2) {
     return {
       salt: null,
       diagnostics: [
@@ -10897,7 +11436,7 @@ async function resolveAttributionSalt(fs, stateRoot) {
         diagnostic({
           severity: "warning",
           code: "attribution-salt-unwritable",
-          message: `The project attribution salt could not be stored, so metrics cannot be attributed to a project: ${error instanceof Error ? error.message : String(error)}`,
+          message: `The project attribution salt could not be stored, so metrics cannot be attributed to a project: ${error2 instanceof Error ? error2.message : String(error2)}`,
           path,
           remediation: "Check that the Token Harness state directory is writable"
         })
@@ -10933,9 +11472,9 @@ function toValue(value3) {
     return value3 ? 1 : 0;
   return null;
 }
-function classify2(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const code = error?.code;
+function classify2(error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  const code = error2?.code;
   if (code === "ERR_UNKNOWN_BUILTIN_MODULE" || /Cannot find module 'node:sqlite'/.test(message)) {
     return { failure: "driver-unavailable", detail: "this runtime has no node:sqlite" };
   }
@@ -10951,8 +11490,8 @@ async function readLocalDatabase(request) {
   let construct;
   try {
     ({ DatabaseSync: construct } = await import("node:sqlite"));
-  } catch (error) {
-    return { rows: [], ...classify2(error) };
+  } catch (error2) {
+    return { rows: [], ...classify2(error2) };
   }
   let database = null;
   try {
@@ -10966,8 +11505,8 @@ async function readLocalDatabase(request) {
       return mapped;
     });
     return { rows, failure: null, detail: null };
-  } catch (error) {
-    return { rows: [], ...classify2(error) };
+  } catch (error2) {
+    return { rows: [], ...classify2(error2) };
   } finally {
     try {
       database?.close();
@@ -11820,8 +12359,8 @@ var init_node_runner = __esm({
               killTimer = setTimeout(() => this.terminateTree(child.pid, onPosix, true), this.options.killGraceMs ?? DEFAULT_KILL_GRACE_MS);
             }, timeoutMs);
           }
-          child.on("error", (error) => {
-            finish5(failureOutcome({ displayCommand, interpreter: plan6.interpreter, executablePath: resolved.path }, spawnFailureReason(error.code), redactText(`Starting ${resolved.path} failed: ${error.code ?? "unknown"} ${error.message}`, policy), now() - started));
+          child.on("error", (error2) => {
+            finish5(failureOutcome({ displayCommand, interpreter: plan6.interpreter, executablePath: resolved.path }, spawnFailureReason(error2.code), redactText(`Starting ${resolved.path} failed: ${error2.code ?? "unknown"} ${error2.message}`, policy), now() - started));
           });
           child.on("close", (code, signal) => {
             const durationMs = now() - started;
@@ -11973,7 +12512,7 @@ var init_host = __esm({
 var init_src2 = __esm({
   "packages/platform/dist/src/index.js"() {
     "use strict";
-    init_rtk_windows_release();
+    init_rtk_release();
     init_node_filesystem();
     init_attribution_salt();
     init_sqlite_child();
@@ -12112,12 +12651,12 @@ async function recordProjectTransferEvidence(input) {
       reason: "observed transfer experiment is missing its measured payload"
     };
   }
-  const receiptPath3 = input.fs.join(input.stateRoot, "benchmarks", input.benchmarkId, "transfer.json");
-  if (await input.fs.stat(receiptPath3) !== null) {
+  const receiptPath4 = input.fs.join(input.stateRoot, "benchmarks", input.benchmarkId, "transfer.json");
+  if (await input.fs.stat(receiptPath4) !== null) {
     return {
       status: "exists",
       receipt: null,
-      receiptPath: receiptPath3,
+      receiptPath: receiptPath4,
       reason: "transfer evidence receipt already exists and is immutable"
     };
   }
@@ -12136,17 +12675,17 @@ async function recordProjectTransferEvidence(input) {
     taskClass: experiment.stay.taskClass
   });
   try {
-    await input.fs.writeFile(receiptPath3, new TextEncoder().encode(`${JSON.stringify(receipt, null, 2)}
+    await input.fs.writeFile(receiptPath4, new TextEncoder().encode(`${JSON.stringify(receipt, null, 2)}
 `));
   } catch {
     return {
       status: "write-failed",
       receipt: null,
-      receiptPath: receiptPath3,
+      receiptPath: receiptPath4,
       reason: "transfer evidence receipt could not be written"
     };
   }
-  return { status: "recorded", receipt, receiptPath: receiptPath3, reason: null };
+  return { status: "recorded", receipt, receiptPath: receiptPath4, reason: null };
 }
 async function resolveLocalTransferContext(cwd) {
   const resolution = resolveHostEnvironment();
@@ -13855,15 +14394,15 @@ var init_claude_benchmark_policy = __esm({
 });
 
 // packages/adapters/dist/src/harnesses/claude.js
-function isRecord2(value3) {
+function isRecord3(value3) {
   return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
 }
 function readHooks(document2) {
   const found = /* @__PURE__ */ new Map();
-  if (!isRecord2(document2))
+  if (!isRecord3(document2))
     return found;
   const hooks = document2["hooks"];
-  if (!isRecord2(hooks))
+  if (!isRecord3(hooks))
     return found;
   for (const point of MANIFEST.interceptionPoints) {
     const list = hooks[point.eventName];
@@ -13871,12 +14410,12 @@ function readHooks(document2) {
       continue;
     const entries = [];
     for (const [entryIndex, item] of list.entries()) {
-      if (!isRecord2(item))
+      if (!isRecord3(item))
         continue;
       const matcher = item["matcher"];
       const inner = item["hooks"];
       const hookCommands = Array.isArray(inner) ? inner.flatMap((hook, hookIndex) => {
-        if (!isRecord2(hook) || typeof hook["command"] !== "string")
+        if (!isRecord3(hook) || typeof hook["command"] !== "string")
           return [];
         const eventSegment = point.eventName.replace(/\./g, "\\.");
         const entryPointer = `hooks.${eventSegment}.${String(entryIndex)}`;
@@ -14184,7 +14723,7 @@ function cclimitsReset(value3) {
   return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
 }
 function cclimitsUsageWindow(value3, input) {
-  if (!isRecord2(value3))
+  if (!isRecord3(value3))
     return null;
   const usedPercent = cclimitsPercent(value3["used"]);
   const remainingPercent = cclimitsPercent(value3["remaining"]);
@@ -14251,7 +14790,7 @@ async function observeUsage(context, observedAt) {
   } catch {
     return unavailable3("cclimits-claude-schema-unrecognized", "cclimits returned output that is not valid JSON");
   }
-  if (!isRecord2(parsed) || !isRecord2(parsed["claude"])) {
+  if (!isRecord3(parsed) || !isRecord3(parsed["claude"])) {
     return unavailable3("cclimits-claude-schema-unrecognized", "cclimits JSON did not contain a Claude usage object");
   }
   const claude = parsed["claude"];
@@ -14614,11 +15153,11 @@ var init_codex_hooks = __esm({
 });
 
 // packages/adapters/dist/src/harnesses/codex.js
-function isRecord3(value3) {
+function isRecord4(value3) {
   return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
 }
 function readHooks2(document2) {
-  if (!isRecord3(document2) || !isRecord3(document2["hooks"]))
+  if (!isRecord4(document2) || !isRecord4(document2["hooks"]))
     return { points: [], matchers: [], commands: [], hookCommands: [] };
   const hooks = document2["hooks"];
   const points = [];
@@ -14631,14 +15170,14 @@ function readHooks2(document2) {
       continue;
     let carries = false;
     for (const [entryIndex, entry] of entries.entries()) {
-      if (!isRecord3(entry))
+      if (!isRecord4(entry))
         continue;
       const matcher = typeof entry["matcher"] === "string" ? entry["matcher"] : null;
       if (matcher !== null)
         matchers.push(matcher);
       if (Array.isArray(entry["hooks"])) {
         for (const [hookIndex, hook] of entry["hooks"].entries()) {
-          if (isRecord3(hook) && typeof hook["command"] === "string") {
+          if (isRecord4(hook) && typeof hook["command"] === "string") {
             commands.push(hook["command"]);
             const entryPointer = `hooks.${point.eventName}.${String(entryIndex)}`;
             hookCommands.push({
@@ -14929,7 +15468,7 @@ function resetInstant(epochSeconds) {
   return Number.isNaN(date.getTime()) ? null : date.toISOString();
 }
 function rateWindow(value3, input) {
-  if (!isRecord3(value3))
+  if (!isRecord4(value3))
     return null;
   const usedPercent = readNumber(value3, "usedPercent");
   const duration2 = readNumber(value3, "windowDurationMins");
@@ -14950,7 +15489,7 @@ function rateWindow(value3, input) {
   };
 }
 function snapshotWindows(value3, observedAt, fallbackBucketId) {
-  if (!isRecord3(value3))
+  if (!isRecord4(value3))
     return { windows: [], planType: null, rateLimitReachedType: null };
   const bucketId = readString(value3, "limitId") ?? fallbackBucketId;
   const bucketName = readString(value3, "limitName");
@@ -14982,13 +15521,13 @@ function parseRateLimitResponse(stdout, observedAt) {
     } catch {
     }
   }
-  const response = messages.find((message) => isRecord3(message) && message["id"] === RATE_LIMIT_REQUEST_ID && isRecord3(message["result"]));
-  if (!isRecord3(response) || !isRecord3(response["result"]))
+  const response = messages.find((message) => isRecord4(message) && message["id"] === RATE_LIMIT_REQUEST_ID && isRecord4(message["result"]));
+  if (!isRecord4(response) || !isRecord4(response["result"]))
     return null;
   const result6 = response["result"];
   const snapshots = [];
   const byId = result6["rateLimitsByLimitId"];
-  if (isRecord3(byId)) {
+  if (isRecord4(byId)) {
     for (const [id, value3] of Object.entries(byId)) {
       if (value3 !== void 0)
         snapshots.push({ id, value: value3 });
@@ -15008,7 +15547,7 @@ function parseRateLimitResponse(stdout, observedAt) {
   }
   let resetCreditsAvailable = null;
   const resetCredits = result6["rateLimitResetCredits"];
-  if (isRecord3(resetCredits)) {
+  if (isRecord4(resetCredits)) {
     const available = readNumber(resetCredits, "availableCount");
     resetCreditsAvailable = available === null ? null : Math.max(0, Math.trunc(available));
   }
@@ -15027,7 +15566,7 @@ function cclimitsPercent2(value3) {
   return Number.isFinite(parsed) && parsed >= 0 && parsed <= 100 ? parsed : null;
 }
 function cclimitsWindow(value3, input) {
-  if (!isRecord3(value3))
+  if (!isRecord4(value3))
     return null;
   const usedPercent = cclimitsPercent2(value3["used_percent"]) ?? cclimitsPercent2(value3["used"]);
   const remainingPercent = cclimitsPercent2(value3["remaining_percent"]) ?? cclimitsPercent2(value3["remaining"]);
@@ -15058,7 +15597,7 @@ function parseCclimitsCodexResponse(stdout, observedAt) {
   } catch {
     return null;
   }
-  if (!isRecord3(parsed) || !isRecord3(parsed["codex"]))
+  if (!isRecord4(parsed) || !isRecord4(parsed["codex"]))
     return null;
   const codex = parsed["codex"];
   if (codex["status"] !== "ok")
@@ -15235,8 +15774,8 @@ function utf8Bytes(value3) {
   return value3 === null ? 0 : new TextEncoder().encode(value3).byteLength;
 }
 function rpcResult(messages, id) {
-  const response = messages.find((message) => isRecord3(message) && message["id"] === id && isRecord3(message["result"]));
-  return isRecord3(response) && isRecord3(response["result"]) ? response["result"] : null;
+  const response = messages.find((message) => isRecord4(message) && message["id"] === id && isRecord4(message["result"]));
+  return isRecord4(response) && isRecord4(response["result"]) ? response["result"] : null;
 }
 function parseJsonLines(stdout) {
   const messages = [];
@@ -15366,15 +15905,15 @@ async function observeContext2(context, _observedAt) {
     const mcpMessages = parseJsonLines(mcpOutcome.stdout);
     mcpResponse = rpcResult(mcpMessages, CONTEXT_MCP_REQUEST_ID) ?? rpcResult(mcpMessages, 3);
   }
-  const config = configResponse !== null && isRecord3(configResponse["config"]) ? configResponse["config"] : null;
+  const config = configResponse !== null && isRecord4(configResponse["config"]) ? configResponse["config"] : null;
   const managedConfigTarget = (() => {
     const layers = configResponse?.["layers"];
     if (!Array.isArray(layers))
       return null;
     for (const layer of layers) {
-      if (!isRecord3(layer))
+      if (!isRecord4(layer))
         continue;
-      const source = isRecord3(layer["name"]) ? layer["name"] : null;
+      const source = isRecord4(layer["name"]) ? layer["name"] : null;
       if (source === null || readString(source, "type") !== "user")
         continue;
       if (readString(source, "profile") !== null)
@@ -15394,11 +15933,11 @@ async function observeContext2(context, _observedAt) {
     return null;
   })();
   const managedConfigFieldOrigins = [];
-  const origins = configResponse !== null && isRecord3(configResponse["origins"]) ? configResponse["origins"] : null;
+  const origins = configResponse !== null && isRecord4(configResponse["origins"]) ? configResponse["origins"] : null;
   const managedConfigOriginsObserved = origins !== null;
   for (const keyPath of ["model", "model_reasoning_effort", "model_verbosity"]) {
-    const metadata = origins !== null && isRecord3(origins[keyPath]) ? origins[keyPath] : null;
-    const source = metadata !== null && isRecord3(metadata["name"]) ? metadata["name"] : null;
+    const metadata = origins !== null && isRecord4(origins[keyPath]) ? origins[keyPath] : null;
+    const source = metadata !== null && isRecord4(metadata["name"]) ? metadata["name"] : null;
     if (metadata === null || source === null)
       continue;
     const sourceType = readString(source, "type");
@@ -15418,14 +15957,14 @@ async function observeContext2(context, _observedAt) {
       source: "native-rpc"
     });
   }
-  const features = config !== null && isRecord3(config["features"]) ? config["features"] : null;
+  const features = config !== null && isRecord4(config["features"]) ? config["features"] : null;
   const instructions = config === null ? null : readString(config, "instructions");
   const developerInstructions = config === null ? null : readString(config, "developer_instructions");
   const availableModels = [];
   const modelData = modelResponse?.["data"];
   if (Array.isArray(modelData)) {
     for (const item of modelData) {
-      if (!isRecord3(item))
+      if (!isRecord4(item))
         continue;
       const id = readString(item, "id");
       const model = readString(item, "model");
@@ -15436,7 +15975,7 @@ async function observeContext2(context, _observedAt) {
       const effortOptions = item["supportedReasoningEfforts"];
       if (Array.isArray(effortOptions)) {
         for (const option of effortOptions) {
-          if (!isRecord3(option))
+          if (!isRecord4(option))
             continue;
           const effort = readString(option, "reasoningEffort");
           if (effort !== null)
@@ -15461,12 +16000,12 @@ async function observeContext2(context, _observedAt) {
   const data = mcpResponse?.["data"];
   if (Array.isArray(data)) {
     for (const item of data) {
-      if (!isRecord3(item))
+      if (!isRecord4(item))
         continue;
       const name2 = readString(item, "name");
       if (name2 === null)
         continue;
-      const tools = isRecord3(item["tools"]) ? item["tools"] : null;
+      const tools = isRecord4(item["tools"]) ? item["tools"] : null;
       mcpServers.push({
         harnessId: CODEX,
         name: name2,
@@ -15856,11 +16395,11 @@ var init_hermes = __esm({
 });
 
 // packages/adapters/dist/src/harnesses/opencode.js
-function isRecord4(value3) {
+function isRecord5(value3) {
   return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
 }
 function pluginEntries(document2) {
-  if (!isRecord4(document2) || !Array.isArray(document2["plugin"]))
+  if (!isRecord5(document2) || !Array.isArray(document2["plugin"]))
     return [];
   return document2["plugin"].filter((item) => typeof item === "string");
 }
@@ -21556,6 +22095,379 @@ var init_providers = __esm({
   }
 });
 
+// packages/adapters/dist/src/routing/ccr-smart-routing.js
+function createCcrSmartRoutingScript(options) {
+  const mode = options.mode ?? "shadow";
+  const eventPathPrefix = `${options.telemetryDirectory}${options.pathSeparator}`;
+  const classifierSource = classifySmartRoutingPrompt.toString();
+  const eventSchemaVersion = 2;
+  const classifierVersion = SMART_ROUTING_CLASSIFIER_VERSION;
+  const configuredSimpleModel = typeof options.simpleModel === "string" && /^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(options.simpleModel) ? options.simpleModel : null;
+  return `const classifySmartRoutingPrompt = (${classifierSource});
+const telemetryPathPrefix = ${JSON.stringify(eventPathPrefix)};
+const harnessId = ${JSON.stringify(options.harnessId)};
+const mode = ${JSON.stringify(mode)};
+const startedAt = Date.now();
+const safeInput = input && typeof input === "object" ? input : {};
+const summary = safeInput.summary && typeof safeInput.summary === "object" ? safeInput.summary : {};
+const headers = safeInput.headers && typeof safeInput.headers === "object" ? safeInput.headers : {};
+const headerSignals = [];
+for (const [name, rawValue] of Object.entries(headers)) {
+  const key = name.toLowerCase();
+  if (key !== "user-agent" && key !== "x-user-agent" && key !== "x-client-user-agent" && key !== "x-ccr-client" && key !== "x-client-name") continue;
+  if (Array.isArray(rawValue)) headerSignals.push(rawValue.join(" "));
+  else if (typeof rawValue === "string") headerSignals.push(rawValue);
+}
+const agentSignal = headerSignals.join(" ").toLowerCase();
+const detectedHarness = /openai-codex|codex[_ -]?cli/.test(agentSignal)
+  ? "codex"
+  : /@anthropic-ai\\/claude-code|claude[-_ ]code|claude[_ -]?cli/.test(agentSignal)
+    ? "claude"
+    : null;
+if (detectedHarness !== harnessId) return null;
+const prompt = typeof summary.lastUserText === "string" ? summary.lastUserText : "";
+const toolCount = Array.isArray(summary.toolNames) ? summary.toolNames.length : 0;
+const tokenCount = Number.isSafeInteger(safeInput.tokenCount) && safeInput.tokenCount > 0 ? safeInput.tokenCount : null;
+const decision = classifySmartRoutingPrompt({
+  text: prompt,
+  hasImage: summary.hasImage === true,
+  toolCount,
+  inputTokens: tokenCount
+});
+const rawSimpleModel = api.env("TOKEN_HARNESS_ROUTING_SIMPLE_MODEL");
+const simpleModel = typeof rawSimpleModel === "string" && /^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(rawSimpleModel)
+  ? rawSimpleModel
+  : ${JSON.stringify(configuredSimpleModel)};
+const requestModel = typeof safeInput.model === "string" && /^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(safeInput.model)
+  ? safeInput.model
+  : null;
+const rawSessionId = typeof safeInput.sessionId === "string" ? safeInput.sessionId : null;
+const sessionId = rawSessionId !== null && /^[A-Za-z0-9_.:-]{1,256}$/.test(rawSessionId) ? rawSessionId : null;
+const candidateModel = decision.tier === "simple" ? simpleModel : null;
+let routeMutationRequested = false;
+let routeSkipReason = null;
+if (mode === "shadow") {
+  routeSkipReason = "shadow-mode";
+} else if (mode !== "conservative") {
+  routeSkipReason = "unsupported-mode";
+} else if (decision.tier !== "simple") {
+  routeSkipReason = "complexity-not-simple";
+} else if (candidateModel === null) {
+  routeSkipReason = "simple-model-not-configured";
+} else if (requestModel === null) {
+  routeSkipReason = "request-model-unavailable";
+} else if (!decision.conservativeEligible) {
+  routeSkipReason = "conservative-safety-gate";
+} else if (toolCount > 0 && api.env("TOKEN_HARNESS_ROUTING_ALLOW_TOOLS") !== "true") {
+  routeSkipReason = "tool-compatibility-unconfirmed";
+} else if (candidateModel === requestModel) {
+  routeSkipReason = "model-already-selected";
+} else {
+  routeMutationRequested = true;
+}
+const now = new Date();
+const epoch = now.getTime();
+const suffix = Math.random().toString(36).slice(2, 10);
+const eventId = String(epoch) + "-" + suffix;
+const event = {
+  schemaVersion: ${eventSchemaVersion},
+  eventId,
+  timestamp: now.toISOString(),
+  source: "ccr",
+  harnessId,
+  mode,
+  classifierVersion: ${JSON.stringify(classifierVersion)},
+  tier: decision.tier,
+  score: decision.score,
+  confidence: decision.confidence,
+  reasonCodes: decision.reasonCodes,
+  requestModel,
+  candidateModel,
+  routeMutationRequested,
+  routeSkipReason,
+  promptChars: decision.promptChars,
+  requestInputTokenEstimate: tokenCount,
+  toolCount,
+  hasImage: decision.hasImage,
+  decisionLatencyMs: Math.max(0, Date.now() - startedAt),
+  sessionId,
+  measurement: {
+    status: "not-measured",
+    resolvedModel: null,
+    providerInputTokens: null,
+    providerOutputTokens: null,
+    qualityGate: "unknown"
+  }
+};
+try {
+  await api.fs.writeJson(telemetryPathPrefix + "smart-routing-" + String(epoch).padStart(13, "0") + "-" + suffix + ".json", event);
+} catch {
+  // A telemetry write failure must never break the user's CCR request path.
+}
+if (routeMutationRequested) return { model: candidateModel };
+return null;`;
+}
+var init_ccr_smart_routing = __esm({
+  "packages/adapters/dist/src/routing/ccr-smart-routing.js"() {
+    "use strict";
+    init_src();
+  }
+});
+
+// packages/adapters/dist/src/routing/ccr-management.js
+function isRecord6(value3) {
+  return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
+}
+function numberField(value3) {
+  return typeof value3 === "number" && Number.isSafeInteger(value3) && value3 >= 0 ? value3 : null;
+}
+function costField(value3) {
+  return typeof value3 === "number" && Number.isFinite(value3) && value3 >= 0 ? value3 : null;
+}
+function resolveCcrManagementUrl(value3) {
+  try {
+    const url = new URL(value3?.trim() || DEFAULT_CCR_WEB_URL);
+    if (url.protocol !== "http:" && url.protocol !== "https:" || !LOCAL_HOSTS.has(url.hostname.toLowerCase()) || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "") {
+      return null;
+    }
+    url.pathname = "/";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function ccrSmartRoutingRuleId(harness) {
+  return `${CCR_ROUTING_RULE_ID_PREFIX}-${harness}-v1`;
+}
+function createCcrSmartRoutingRule(harness, scriptPath2) {
+  return {
+    enabled: true,
+    id: ccrSmartRoutingRuleId(harness),
+    name: `Token Harness Smart Routing (${harness}, shadow-first)`,
+    script: {
+      apiVersion: CCR_ROUTING_RULE_API_VERSION,
+      file: scriptPath2,
+      language: "javascript",
+      timeoutMs: CCR_ROUTING_RULE_TIMEOUT_MS
+    },
+    type: "script"
+  };
+}
+function stableJson(value3) {
+  if (Array.isArray(value3))
+    return `[${value3.map(stableJson).join(",")}]`;
+  if (!isRecord6(value3))
+    return JSON.stringify(value3);
+  return `{${Object.keys(value3).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value3[key])}`).join(",")}}`;
+}
+function isExactCcrSmartRoutingRule(value3, expected) {
+  return isRecord6(value3) && stableJson(value3) === stableJson(expected);
+}
+function isSameCcrConfig(left, right) {
+  return isRecord6(left) && isRecord6(right) && stableJson(left) === stableJson(right);
+}
+function configRouter(config) {
+  if (!isRecord6(config) || !isRecord6(config["Router"]) || !Array.isArray(config["Router"]["rules"])) {
+    return null;
+  }
+  return {
+    config,
+    router: config["Router"],
+    rules: config["Router"]["rules"]
+  };
+}
+function addCcrSmartRoutingRule(config, rule) {
+  const current = configRouter(config);
+  if (current === null)
+    return null;
+  const existing = current.rules.find((item) => isRecord6(item) && item["id"] === rule["id"]);
+  if (existing !== void 0)
+    return isExactCcrSmartRoutingRule(existing, rule) ? current.config : null;
+  return {
+    ...current.config,
+    Router: { ...current.router, rules: [rule, ...current.rules] }
+  };
+}
+function removeOwnedCcrSmartRoutingRule(config, ruleId, expected) {
+  const current = configRouter(config);
+  if (current === null)
+    return null;
+  const matches = current.rules.filter((item) => isRecord6(item) && item["id"] === ruleId);
+  if (matches.length !== 1 || !isExactCcrSmartRoutingRule(matches[0], expected))
+    return null;
+  return {
+    ...current.config,
+    Router: {
+      ...current.router,
+      rules: current.rules.filter((item) => !(isRecord6(item) && item["id"] === ruleId))
+    }
+  };
+}
+function readCcrVersion(value3) {
+  if (!isRecord6(value3) || typeof value3["version"] !== "string")
+    return null;
+  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value3["version"]) ? value3["version"] : null;
+}
+function reduceCcrSessionUsage(value3, expectedSessionId, expectedAgent, since, until) {
+  if (!isRecord6(value3) || value3["requestScanTruncated"] === true || !isRecord6(value3["selectedSession"])) {
+    return null;
+  }
+  const selected = value3["selectedSession"];
+  if (!isRecord6(selected["session"]) || selected["session"]["agent"] !== expectedAgent || selected["session"]["id"] !== `${expectedAgent}:${expectedSessionId}` || !Array.isArray(selected["requests"])) {
+    return null;
+  }
+  const start = Date.parse(since);
+  const end = Date.parse(until);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+    return null;
+  const byModel = /* @__PURE__ */ new Map();
+  for (const item of selected["requests"]) {
+    if (!isRecord6(item) || item["sessionId"] !== expectedSessionId)
+      continue;
+    const createdAt = typeof item["createdAt"] === "string" ? Date.parse(item["createdAt"]) : Number.NaN;
+    if (!Number.isFinite(createdAt) || createdAt < start || createdAt > end)
+      continue;
+    const model = item["model"];
+    const inputTokens = numberField(item["inputTokens"]);
+    const outputTokens = numberField(item["outputTokens"]);
+    const cacheReadTokens = numberField(item["cacheReadTokens"]);
+    const cacheWriteTokens = numberField(item["cacheWriteTokens"]);
+    const totalTokens = numberField(item["totalTokens"]);
+    if (typeof model !== "string" || !MODEL_ID.test(model) || inputTokens === null || outputTokens === null || cacheReadTokens === null || cacheWriteTokens === null || totalTokens === null) {
+      continue;
+    }
+    const current = byModel.get(model) ?? {
+      model,
+      requestCount: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0,
+      recordedCostUsd: 0
+    };
+    const recordedCostUsd = costField(item["costUsd"]);
+    current.requestCount += 1;
+    current.inputTokens += inputTokens;
+    current.outputTokens += outputTokens;
+    current.cacheReadTokens += cacheReadTokens;
+    current.cacheWriteTokens += cacheWriteTokens;
+    current.totalTokens += totalTokens;
+    if (recordedCostUsd === null)
+      current.recordedCostUsd = null;
+    else if (current.recordedCostUsd !== null)
+      current.recordedCostUsd += recordedCostUsd;
+    byModel.set(model, current);
+  }
+  const rows = [...byModel.values()].sort((left, right) => left.model.localeCompare(right.model));
+  if (rows.length === 0)
+    return null;
+  return {
+    sessionId: expectedSessionId,
+    requestCount: rows.reduce((total, row2) => total + row2.requestCount, 0),
+    inputTokens: rows.reduce((total, row2) => total + row2.inputTokens, 0),
+    outputTokens: rows.reduce((total, row2) => total + row2.outputTokens, 0),
+    cacheReadTokens: rows.reduce((total, row2) => total + row2.cacheReadTokens, 0),
+    cacheWriteTokens: rows.reduce((total, row2) => total + row2.cacheWriteTokens, 0),
+    totalTokens: rows.reduce((total, row2) => total + row2.totalTokens, 0),
+    recordedCostUsd: rows.length === 0 || rows.some((row2) => row2.recordedCostUsd === null) ? null : rows.reduce((total, row2) => total + (row2.recordedCostUsd ?? 0), 0),
+    byModel: rows
+  };
+}
+function ccrAgentForHarness(harness) {
+  return HARNESS_AGENTS[harness];
+}
+var CCR_REVIEWED_VERSION, CCR_ROUTING_RULE_ID_PREFIX, CCR_ROUTING_RULE_API_VERSION, CCR_ROUTING_RULE_TIMEOUT_MS, CcrManagementError, DEFAULT_CCR_WEB_URL, CCR_RPC_PATH, CCR_RESPONSE_MAX_BYTES, LOCAL_HOSTS, MODEL_ID, HARNESS_AGENTS, CcrManagementClient;
+var init_ccr_management = __esm({
+  "packages/adapters/dist/src/routing/ccr-management.js"() {
+    "use strict";
+    CCR_REVIEWED_VERSION = "3.1.1";
+    CCR_ROUTING_RULE_ID_PREFIX = "token-harness-smart-routing";
+    CCR_ROUTING_RULE_API_VERSION = 1;
+    CCR_ROUTING_RULE_TIMEOUT_MS = 2e3;
+    CcrManagementError = class extends Error {
+      failure;
+      constructor(failure) {
+        super(`CCR management request failed (${failure})`);
+        this.name = "CcrManagementError";
+        this.failure = failure;
+      }
+    };
+    DEFAULT_CCR_WEB_URL = "http://127.0.0.1:3458";
+    CCR_RPC_PATH = "/api/ccr/rpc";
+    CCR_RESPONSE_MAX_BYTES = 8 * 1024 * 1024;
+    LOCAL_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
+    MODEL_ID = /^[A-Za-z0-9_.:/@+ -]{1,160}$/;
+    HARNESS_AGENTS = { claude: "claude-code", codex: "codex" };
+    CcrManagementClient = class {
+      baseUrl;
+      token;
+      fetcher;
+      constructor(options = {}) {
+        const baseUrl = resolveCcrManagementUrl(options.baseUrl);
+        if (baseUrl === null)
+          throw new CcrManagementError("endpoint-invalid");
+        const token = options.authToken?.trim();
+        if (!token || token.length > 512)
+          throw new CcrManagementError("token-missing");
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.fetcher = options.fetcher ?? globalThis.fetch;
+      }
+      async call(method, args = []) {
+        let response;
+        try {
+          response = await this.fetcher(`${this.baseUrl}${CCR_RPC_PATH}`, {
+            method: "POST",
+            redirect: "error",
+            signal: AbortSignal.timeout(8e3),
+            headers: {
+              "content-type": "application/json",
+              "x-ccr-web-auth": this.token
+            },
+            body: JSON.stringify({ method, args })
+          });
+        } catch {
+          throw new CcrManagementError("unreachable");
+        }
+        if (response.status === 401 || response.status === 403) {
+          throw new CcrManagementError("unauthorized");
+        }
+        if (response.status === 404)
+          throw new CcrManagementError("method-unavailable");
+        if (!response.ok)
+          throw new CcrManagementError("request-failed");
+        const contentLength = Number(response.headers.get("content-length"));
+        if (Number.isFinite(contentLength) && contentLength > CCR_RESPONSE_MAX_BYTES) {
+          throw new CcrManagementError("invalid-response");
+        }
+        let payload;
+        try {
+          const text3 = await response.text();
+          if (new TextEncoder().encode(text3).byteLength > CCR_RESPONSE_MAX_BYTES) {
+            throw new CcrManagementError("invalid-response");
+          }
+          payload = JSON.parse(text3);
+        } catch (error2) {
+          if (error2 instanceof CcrManagementError)
+            throw error2;
+          throw new CcrManagementError("invalid-response");
+        }
+        if (!isRecord6(payload))
+          throw new CcrManagementError("invalid-response");
+        if (payload["ok"] !== true) {
+          const message = isRecord6(payload["error"]) ? payload["error"]["message"] : void 0;
+          if (typeof message === "string" && /unknown ccr web rpc method/i.test(message)) {
+            throw new CcrManagementError("method-unavailable");
+          }
+          throw new CcrManagementError("request-failed");
+        }
+        return payload["value"];
+      }
+    };
+  }
+});
+
 // packages/adapters/dist/src/index.js
 var init_src3 = __esm({
   "packages/adapters/dist/src/index.js"() {
@@ -21563,6 +22475,8 @@ var init_src3 = __esm({
     init_harnesses();
     init_providers();
     init_rtk_plan();
+    init_ccr_smart_routing();
+    init_ccr_management();
   }
 });
 
@@ -21915,6 +22829,14 @@ function parseArgv(argv2, plannedCommands = PLANNED_COMMANDS) {
     tasksLeft: null,
     contextSnapshot: null,
     nativePolicy: false,
+    routingScript: false,
+    routingMetrics: false,
+    routingMode: "shadow",
+    routingPrune: false,
+    routingCcrConfigure: false,
+    routingCcrRollback: false,
+    routingCcrUpdate: false,
+    routingCcrUsage: false,
     agentSkill: false,
     verbose: false,
     yes: false
@@ -21954,6 +22876,20 @@ function parseArgv(argv2, plannedCommands = PLANNED_COMMANDS) {
         options.nativePolicy = true;
       if (name2 === "--agent-skill")
         options.agentSkill = true;
+      if (name2 === "--script")
+        options.routingScript = true;
+      if (name2 === "--route-metrics")
+        options.routingMetrics = true;
+      if (name2 === "--prune")
+        options.routingPrune = true;
+      if (name2 === "--configure-ccr")
+        options.routingCcrConfigure = true;
+      if (name2 === "--rollback-ccr")
+        options.routingCcrRollback = true;
+      if (name2 === "--update-ccr")
+        options.routingCcrUpdate = true;
+      if (name2 === "--ccr-usage")
+        options.routingCcrUsage = true;
       if (name2 === "--verbose")
         options.verbose = true;
       continue;
@@ -22159,6 +23095,18 @@ function parseArgv(argv2, plannedCommands = PLANNED_COMMANDS) {
         }
         break;
       }
+      case "--route-mode":
+        if (value3 !== "shadow" && value3 !== "conservative") {
+          diagnostics.push(diagnostic({
+            severity: "error",
+            code: "invalid-routing-mode",
+            message: `Routing mode ${JSON.stringify(value3)} is not supported`,
+            remediation: "Use --route-mode shadow or --route-mode conservative"
+          }));
+        } else {
+          options.routingMode = value3;
+        }
+        break;
       case "--context-snapshot":
         options.contextSnapshot = value3;
         break;
@@ -22229,6 +23177,7 @@ var init_argv = __esm({
       "optimize",
       "plan",
       "rollback",
+      "routing",
       "setup",
       "status",
       "stack-review",
@@ -22257,9 +23206,23 @@ var init_argv = __esm({
       "--profile",
       "--reserve",
       "--tasks-left",
+      "--route-mode",
       "--context-snapshot"
     ]);
-    BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json", "--native-policy", "--agent-skill", "--verbose", "--yes"]);
+    BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+      "--json",
+      "--native-policy",
+      "--agent-skill",
+      "--verbose",
+      "--yes",
+      "--script",
+      "--route-metrics",
+      "--prune",
+      "--configure-ccr",
+      "--rollback-ccr",
+      "--update-ccr",
+      "--ccr-usage"
+    ]);
   }
 });
 
@@ -22309,12 +23272,12 @@ function parseGitNexusIndexReadiness(output) {
     if (receipt["schemaVersion"] !== 1)
       return { state: "invalid", detail: null };
     const status = safeGitNexusStatusLabel(receipt["status"]);
-    const error = safeGitNexusStatusLabel(receipt["error"]);
+    const error2 = safeGitNexusStatusLabel(receipt["error"]);
     if (status === "up-to-date" && receipt["error"] === void 0) {
       return { state: "up-to-date", detail: null };
     }
     if (receipt["error"] !== void 0)
-      return { state: "not-ready", detail: error };
+      return { state: "not-ready", detail: error2 };
     if (receipt["status"] !== void 0)
       return { state: "not-ready", detail: status };
     return { state: "invalid", detail: null };
@@ -24451,15 +25414,15 @@ async function readOptimizationHistory(context) {
         continue;
       result6.scannedBenchmarks += 1;
       for (const variant of ["baseline", "optimized"]) {
-        const receiptPath3 = fs.join(directory, `${variant}.json`);
-        if (await fs.stat(receiptPath3) === null)
+        const receiptPath4 = fs.join(directory, `${variant}.json`);
+        if (await fs.stat(receiptPath4) === null)
           continue;
         const capture = parseTaskBenchmarkCapture(await read(fs.join(directory, `${variant}.capture.json`)));
         if (!capture.ok)
           return result6;
         if (capture.capture.projectId !== project)
           continue;
-        const receipt = parseTaskBenchmarkReceipt(await read(receiptPath3));
+        const receipt = parseTaskBenchmarkReceipt(await read(receiptPath4));
         if (!receipt.ok)
           return result6;
         const start = capture.capture;
@@ -25752,12 +26715,12 @@ async function verifyManagedIntegrationPostconditions(context, integrations) {
           remediation: runtimeProblem?.remediation ?? "Check that the newly installed provider executable is on PATH, then review a fresh setup preview"
         }));
       }
-    } catch (error) {
+    } catch (error2) {
       diagnostics.push(diagnostic({
         severity: "error",
         code: "managed-setup-postcondition-unavailable",
         subject: integration.providerId,
-        message: `The provider could not be re-observed after setup: ${error instanceof Error ? error.message : String(error)}`,
+        message: `The provider could not be re-observed after setup: ${error2 instanceof Error ? error2.message : String(error2)}`,
         remediation: "Refresh and inspect the provider runtime before retrying"
       }));
     }
@@ -25811,13 +26774,13 @@ async function loadStoredPlan(context, planId) {
       throw new TypeError("A stored plan must be a JSON object");
     }
     return { stored: parsed, diagnostic: null };
-  } catch (error) {
+  } catch (error2) {
     return {
       stored: null,
       diagnostic: diagnostic({
         severity: "error",
         code: "plan-unreadable",
-        message: `The stored plan could not be read: ${error instanceof Error ? error.message : String(error)}`,
+        message: `The stored plan could not be read: ${error2 instanceof Error ? error2.message : String(error2)}`,
         path,
         remediation: "Run `token-harness plan` to compute a new one"
       })
@@ -26206,6 +27169,596 @@ var init_benchmark2 = __esm({
   }
 });
 
+// apps/cli/dist/src/commands/ccr-runtime.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+function ccrRuntimeRoot(context) {
+  return context.adapters.fs.join(context.stateRoot, "smart-routing", "ccr");
+}
+function runtimeReceiptPath(context) {
+  return context.adapters.fs.join(ccrRuntimeRoot(context), "runtime.json");
+}
+function runtimeTokenPath(context) {
+  return context.adapters.fs.join(ccrRuntimeRoot(context), "web-auth-token");
+}
+function packagePrefix(context, version3) {
+  return context.adapters.fs.join(ccrRuntimeRoot(context), "versions", version3);
+}
+function ccrExecutable(context, prefix) {
+  const suffix = context.platform.os === "windows" && !context.platform.isWsl ? ".cmd" : "";
+  return context.adapters.fs.join(prefix, "node_modules", ".bin", `ccr${suffix}`);
+}
+function parseJsonRecord(value3) {
+  return typeof value3 === "object" && value3 !== null && !Array.isArray(value3) ? value3 : null;
+}
+async function readManagedCcrRuntime(context) {
+  if (context.adapters === null || context.stateRoot === null)
+    return null;
+  try {
+    const bytes = await context.adapters.fs.readFile(runtimeReceiptPath(context));
+    const receipt = parseJsonRecord(JSON.parse(new TextDecoder().decode(bytes)));
+    if (receipt?.["schemaVersion"] !== 1 || typeof receipt["version"] !== "string" || !/^\d+\.\d+\.\d+$/.test(receipt["version"]) || typeof receipt["installPrefix"] !== "string" || typeof receipt["executablePath"] !== "string" || typeof receipt["managementEndpoint"] !== "string" || typeof receipt["installedAt"] !== "string") {
+      return null;
+    }
+    const expectedPrefix = packagePrefix(context, receipt["version"]);
+    if (receipt["installPrefix"] !== expectedPrefix || receipt["executablePath"] !== ccrExecutable(context, expectedPrefix) || resolveCcrManagementUrl(receipt["managementEndpoint"]) !== receipt["managementEndpoint"]) {
+      return null;
+    }
+    return receipt;
+  } catch {
+    return null;
+  }
+}
+async function readPrivateToken(context) {
+  if (context.adapters === null || context.stateRoot === null)
+    return null;
+  try {
+    const value3 = new TextDecoder().decode(await context.adapters.fs.readFile(runtimeTokenPath(context))).trim();
+    return /^[A-Za-z0-9_-]{32,128}$/.test(value3) ? value3 : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveManagedCcr(context) {
+  const envToken = context.env?.["CCR_WEB_AUTH_TOKEN"]?.trim();
+  const envUrl = context.env?.["CCR_WEB_URL"];
+  if (envToken) {
+    const endpoint = resolveCcrManagementUrl(envUrl);
+    if (endpoint === null)
+      throw new CcrManagementError("endpoint-invalid");
+    return { kind: "external", endpoint, token: envToken };
+  }
+  if (envUrl !== void 0 && envUrl.trim() !== "")
+    throw new CcrManagementError("token-missing");
+  const receipt = await readManagedCcrRuntime(context);
+  const token = await readPrivateToken(context);
+  if (receipt !== null && token !== null) {
+    return {
+      kind: "managed",
+      endpoint: receipt.managementEndpoint,
+      token,
+      receipt
+    };
+  }
+  const service = await readCcrServiceState(context);
+  if (service !== null)
+    return service;
+  return { kind: "unavailable" };
+}
+async function readCcrServiceState(context) {
+  if (context.adapters === null || context.home === null)
+    return null;
+  const windows = context.platform.os === "windows" && !context.platform.isWsl;
+  const appData = context.env?.["APPDATA"];
+  const configDirectory = windows ? context.adapters.fs.join(appData || context.adapters.fs.join(context.home, "AppData", "Roaming"), "claude-code-router") : context.adapters.fs.join(context.home, ".claude-code-router");
+  try {
+    const bytes = await context.adapters.fs.readFile(context.adapters.fs.join(configDirectory, "service.json"));
+    const state = parseJsonRecord(JSON.parse(new TextDecoder().decode(bytes)));
+    if (typeof state?.["url"] !== "string")
+      return null;
+    const serviceUrl = new URL(state["url"]);
+    const endpoint = resolveCcrManagementUrl(serviceUrl.origin);
+    const token = serviceUrl.searchParams.get("ccr_web_token")?.trim();
+    if (endpoint === null || token === void 0 || !/^[A-Za-z0-9_-]{32,128}$/.test(token))
+      return null;
+    const client = new CcrManagementClient({
+      baseUrl: endpoint,
+      authToken: token,
+      ...context.ccrFetch === void 0 ? {} : { fetcher: context.ccrFetch }
+    });
+    const version3 = readCcrVersion(await client.call("getAppInfo"));
+    if (version3 === null)
+      return null;
+    return { kind: "external", endpoint, token };
+  } catch {
+    return null;
+  }
+}
+async function localManagementPortIsOccupied(context) {
+  const fetcher = context.ccrFetch ?? globalThis.fetch;
+  try {
+    const response = await fetcher(`http://127.0.0.1:${String(DEFAULT_WEB_PORT)}/api/ccr/rpc`, {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(1e3),
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ method: "getAppInfo", args: [] })
+    });
+    return response.status >= 100 && response.status <= 599;
+  } catch {
+    return false;
+  }
+}
+function lifecycleError(code, message, remediation) {
+  return commandResult({
+    command: "routing",
+    exitCode: EXIT_CODES["problems-found"],
+    diagnostics: [diagnostic({ severity: "error", code, message, remediation })]
+  });
+}
+function lifecyclePreview(action, state, context, receipt) {
+  const fs = context.adapters.fs;
+  const prefix = packagePrefix(context, CCR_REVIEWED_VERSION);
+  const executable = ccrExecutable(context, prefix);
+  const endpoint = receipt?.managementEndpoint ?? `http://127.0.0.1:${String(DEFAULT_WEB_PORT)}`;
+  return commandResult({
+    command: "routing",
+    exitCode: EXIT_CODES.ok,
+    data: {
+      kind: "ccr-lifecycle",
+      action,
+      state,
+      version: CCR_REVIEWED_VERSION,
+      packagePath: prefix,
+      executablePath: executable,
+      managementEndpoint: endpoint
+    },
+    diagnostics: [
+      diagnostic({
+        severity: "info",
+        code: `ccr-${action}-preview`,
+        message: state === "already-current" ? `Token Harness manages CCR CLI ${CCR_REVIEWED_VERSION}; no package update is needed` : action === "install" ? `Token Harness would install CCR CLI ${CCR_REVIEWED_VERSION} in its protected local state directory` : action === "update" ? `Token Harness would stop its managed CCR service, install reviewed CCR ${CCR_REVIEWED_VERSION}, then restart and verify it` : `Token Harness would start its managed CCR ${CCR_REVIEWED_VERSION} service on loopback`,
+        path: fs.join(ccrRuntimeRoot(context), "runtime.json"),
+        remediation: state === "already-current" ? "Use `token-harness routing --configure-ccr --harness <claude|codex> --yes` to verify or configure the owned shadow rule" : "Review the local package installation and gateway restart, then rerun with `--yes`; no global CCR package or harness configuration is replaced"
+      })
+    ]
+  });
+}
+function successfulProcess(outcome2) {
+  return outcome2.failure === null && outcome2.exitCode === 0;
+}
+function managementPortFromOutput(output) {
+  const match = /https?:\/\/(?:127\.0\.0\.1|localhost|\[::1\]):(\d+)/i.exec(output);
+  const port = Number(match?.[1]);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : DEFAULT_WEB_PORT;
+}
+async function packageVersionAt(context, prefix) {
+  try {
+    const path = context.adapters.fs.join(prefix, "node_modules", "@musistudio", "claude-code-router", "package.json");
+    const parsed = parseJsonRecord(JSON.parse(new TextDecoder().decode(await context.adapters.fs.readFile(path))));
+    return typeof parsed?.["version"] === "string" ? parsed["version"] : null;
+  } catch {
+    return null;
+  }
+}
+async function runCcrExecutable(context, executable, args, token) {
+  const env = { CCR_WEB_AUTH_TOKEN: token };
+  const simpleModel = context.env?.["TOKEN_HARNESS_ROUTING_SIMPLE_MODEL"]?.trim();
+  if (simpleModel && /^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(simpleModel)) {
+    env["TOKEN_HARNESS_ROUTING_SIMPLE_MODEL"] = simpleModel;
+  }
+  return context.adapters.runner.run({
+    executable,
+    args,
+    cwd: context.projectRoot,
+    env,
+    timeoutMs: 45e3,
+    maxOutputBytes: 128 * 1024,
+    secretValues: [token]
+  });
+}
+async function startAndVerify(context, receipt, token, expectedVersion = CCR_REVIEWED_VERSION) {
+  const start = await runCcrExecutable(context, receipt.executablePath, [
+    "start",
+    "--daemon",
+    "--host",
+    "127.0.0.1",
+    "--port",
+    String(DEFAULT_WEB_PORT),
+    "--no-open",
+    "--gateway"
+  ], token);
+  if (!successfulProcess(start))
+    return null;
+  const port = managementPortFromOutput(`${start.stdout}
+${start.stderr}`);
+  const endpoint = resolveCcrManagementUrl(`http://127.0.0.1:${String(port)}`);
+  if (endpoint === null)
+    return null;
+  const client = new CcrManagementClient({
+    baseUrl: endpoint,
+    authToken: token,
+    ...context.ccrFetch === void 0 ? {} : { fetcher: context.ccrFetch }
+  });
+  try {
+    const version3 = readCcrVersion(await client.call("getAppInfo"));
+    const gateway = parseJsonRecord(await client.call("getGatewayStatus"));
+    if (version3 !== expectedVersion || gateway?.["state"] !== "running")
+      return null;
+    return { endpoint, version: version3 };
+  } catch {
+    return null;
+  }
+}
+async function verifyManagedService(context, receipt, token) {
+  const client = new CcrManagementClient({
+    baseUrl: receipt.managementEndpoint,
+    authToken: token,
+    ...context.ccrFetch === void 0 ? {} : { fetcher: context.ccrFetch }
+  });
+  try {
+    const version3 = readCcrVersion(await client.call("getAppInfo"));
+    const gateway = parseJsonRecord(await client.call("getGatewayStatus"));
+    if (version3 === null)
+      return null;
+    return { version: version3, running: gateway?.["state"] === "running" };
+  } catch {
+    return null;
+  }
+}
+async function ensureManagedCcrRuntime(input) {
+  const { context } = input;
+  if (context.adapters === null || context.stateRoot === null) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-local-state-required", "Managed CCR needs Token Harness local state and process adapters", "Run this command from the local Token Harness installation")
+    };
+  }
+  const nodeMajor = Number(/^v?(\d+)/.exec(context.platform.nodeVersion ?? "")?.[1]);
+  if (!Number.isInteger(nodeMajor) || nodeMajor < 22) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-node-version-unsupported", "CCR CLI requires Node.js 22 or newer", "Run Token Harness with Node.js 22+ and retry")
+    };
+  }
+  const fs = context.adapters.fs;
+  const root = ccrRuntimeRoot(context);
+  const prior = await readManagedCcrRuntime(context);
+  const token = await readPrivateToken(context);
+  if (prior === null && await fs.stat(runtimeReceiptPath(context)) !== null) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-runtime-receipt-unrecognized", "The local CCR runtime receipt exists but is not a valid Token Harness ownership record", "Inspect or move the receipt before setup; Token Harness will not overwrite unrecognized runtime state")
+    };
+  }
+  if (prior === null && await fs.stat(runtimeTokenPath(context)) !== null) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-runtime-token-unrecognized", "A local CCR credential exists without a valid Token Harness ownership receipt", "Inspect or move the credential before setup; Token Harness will not replace unrecognized authentication state")
+    };
+  }
+  if (prior !== null && token === null) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-managed-token-missing", "Token Harness could not read the private credential for its managed CCR service", "Restore the private credential from a backup or remove the managed runtime manually before reinstalling")
+    };
+  }
+  if (prior === null && await localManagementPortIsOccupied(context)) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-existing-service-auth-required", "A local service is already listening on CCR\u2019s default management port, but Token Harness cannot authenticate to it", "Set CCR_WEB_AUTH_TOKEN and optionally CCR_WEB_URL to connect to that CCR instance; Token Harness will not start a second gateway beside it")
+    };
+  }
+  if (input.action === "update" && prior === null) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-managed-runtime-required", "Token Harness has no CCR CLI installation to update", "Run `token-harness routing --configure-ccr --harness <claude|codex>` first")
+    };
+  }
+  if (prior?.version === CCR_REVIEWED_VERSION) {
+    if (token === null)
+      return {
+        kind: "result",
+        result: lifecycleError("ccr-managed-token-missing", "Token Harness could not read its private CCR management credential", "Inspect the protected Token Harness smart-routing state and rerun setup if the credential was removed")
+      };
+    const current = await verifyManagedService(context, prior, token);
+    if (current?.version === CCR_REVIEWED_VERSION && current.running) {
+      return input.action === "update" ? { kind: "result", result: lifecyclePreview("update", "already-current", context, prior) } : {
+        kind: "ready",
+        endpoint: prior.managementEndpoint,
+        token,
+        changed: false,
+        lifecycleAction: "start",
+        packagePath: prior.installPrefix,
+        executablePath: prior.executablePath
+      };
+    }
+  }
+  if (!context.confirmed) {
+    const action = prior === null ? "install" : prior.version === CCR_REVIEWED_VERSION ? "start" : "update";
+    return {
+      kind: "result",
+      result: lifecyclePreview(action, "preview", context, prior ?? void 0)
+    };
+  }
+  const runtimeToken = token ?? randomBytes2(32).toString("base64url");
+  const prefix = packagePrefix(context, CCR_REVIEWED_VERSION);
+  const executable = ccrExecutable(context, prefix);
+  const existingPrefixStat = await fs.stat(prefix);
+  if (prior === null && existingPrefixStat !== null) {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-install-path-unowned", "The Token Harness CCR package path already contains files with no ownership receipt", "Inspect the path reported in the preview and move it before setup; Token Harness will not adopt unknown files")
+    };
+  }
+  let changed = false;
+  if (await packageVersionAt(context, prefix) !== CCR_REVIEWED_VERSION) {
+    const npm = context.adapters.resolveExecutables?.("npm") ?? [];
+    if (npm.length === 0 && context.adapters.resolveExecutables !== void 0) {
+      return {
+        kind: "result",
+        result: lifecycleError("ccr-npm-not-found", "npm could not be resolved, so CCR was not installed", "Install npm with Node.js 22+ and retry")
+      };
+    }
+    if (prior !== null) {
+      const stop = await runCcrExecutable(context, prior.executablePath, ["stop"], runtimeToken);
+      if (!successfulProcess(stop)) {
+        return {
+          kind: "result",
+          result: lifecycleError("ccr-stop-before-update-failed", "Token Harness could not stop its managed CCR service before updating", "Review the local CCR service and retry; the current installation was left in place")
+        };
+      }
+    }
+    const install = await context.adapters.runner.run({
+      executable: "npm",
+      args: [
+        "install",
+        "--prefix",
+        prefix,
+        "--no-save",
+        "--package-lock=true",
+        `${CCR_PACKAGE}@${CCR_REVIEWED_VERSION}`
+      ],
+      cwd: context.projectRoot,
+      timeoutMs: 10 * 6e4,
+      maxOutputBytes: 256 * 1024
+    });
+    if (!successfulProcess(install) || await packageVersionAt(context, prefix) !== CCR_REVIEWED_VERSION) {
+      const restored = prior !== null && await startAndVerify(context, prior, runtimeToken, prior.version) !== null;
+      return {
+        kind: "result",
+        result: lifecycleError("ccr-npm-install-failed", `npm did not install the reviewed CCR CLI ${CCR_REVIEWED_VERSION}`, restored ? "The previously managed CCR package and gateway were restored; check npm connectivity and retry from a fresh preview" : prior !== null ? "The package update failed and Token Harness could not verify restart of the previous gateway; inspect local CCR status before retrying" : "Check npm connectivity and retry from a fresh preview; no global npm package was modified")
+      };
+    }
+    changed = true;
+  }
+  const provisional = {
+    schemaVersion: 1,
+    version: CCR_REVIEWED_VERSION,
+    installPrefix: prefix,
+    executablePath: executable,
+    managementEndpoint: prior?.managementEndpoint ?? `http://127.0.0.1:${String(DEFAULT_WEB_PORT)}`,
+    installedAt: prior?.installedAt ?? context.now()
+  };
+  try {
+    await fs.createDirectory(root);
+    await fs.writeFile(runtimeTokenPath(context), new TextEncoder().encode(`${runtimeToken}
+`), "0600");
+  } catch {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-token-store-failed", "Token Harness could not store the local CCR management credential securely", "Check Token Harness state-directory permissions; no CCR profile or route change was applied")
+    };
+  }
+  try {
+    await fs.writeFile(runtimeReceiptPath(context), new TextEncoder().encode(`${JSON.stringify(provisional, null, 2)}
+`), "0600");
+  } catch {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-receipt-write-failed", "Token Harness could not save the local CCR ownership receipt before starting the service", "Repair the protected Token Harness state directory; CCR was not started")
+    };
+  }
+  const started = await startAndVerify(context, provisional, runtimeToken);
+  if (started === null) {
+    if (prior !== null) {
+      const restored = await startAndVerify(context, prior, runtimeToken, prior.version) !== null;
+      if (!restored)
+        return {
+          kind: "result",
+          result: lifecycleError("ccr-start-verification-failed", "The new CCR service failed verification and Token Harness could not verify restart of the previous gateway", "Inspect local CCR status before retrying; the ownership receipt was retained for recovery")
+        };
+      await fs.writeFile(runtimeReceiptPath(context), new TextEncoder().encode(`${JSON.stringify(prior, null, 2)}
+`), "0600");
+    }
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-start-verification-failed", "The managed CCR service did not pass its local version and gateway checks", "Inspect CCR service status and retry; Token Harness did not report live routing or savings")
+    };
+  }
+  const active = { ...provisional, managementEndpoint: started.endpoint };
+  try {
+    await fs.writeFile(runtimeReceiptPath(context), new TextEncoder().encode(`${JSON.stringify(active, null, 2)}
+`), "0600");
+  } catch {
+    return {
+      kind: "result",
+      result: lifecycleError("ccr-receipt-write-failed", "CCR started, but Token Harness could not save its ownership receipt", "Keep CCR running; repair the protected Token Harness state directory, then rerun setup")
+    };
+  }
+  changed = true;
+  return {
+    kind: "ready",
+    endpoint: started.endpoint,
+    token: runtimeToken,
+    changed,
+    lifecycleAction: prior === null ? "install" : prior.version === CCR_REVIEWED_VERSION ? "start" : "update",
+    packagePath: prefix,
+    executablePath: executable
+  };
+}
+var CCR_PACKAGE, DEFAULT_WEB_PORT;
+var init_ccr_runtime = __esm({
+  "apps/cli/dist/src/commands/ccr-runtime.js"() {
+    "use strict";
+    init_src3();
+    init_src();
+    CCR_PACKAGE = "@musistudio/claude-code-router";
+    DEFAULT_WEB_PORT = 3458;
+  }
+});
+
+// apps/cli/dist/src/commands/routing-usage.js
+function combineSessionUsage(rows) {
+  const byModel = /* @__PURE__ */ new Map();
+  for (const row2 of rows) {
+    for (const model of row2.byModel) {
+      const current = byModel.get(model.model) ?? {
+        ...model,
+        requestCount: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        recordedCostUsd: 0
+      };
+      current.requestCount += model.requestCount;
+      current.inputTokens += model.inputTokens;
+      current.outputTokens += model.outputTokens;
+      current.cacheReadTokens += model.cacheReadTokens;
+      current.cacheWriteTokens += model.cacheWriteTokens;
+      current.totalTokens += model.totalTokens;
+      if (current.recordedCostUsd === null || model.recordedCostUsd === null) {
+        current.recordedCostUsd = null;
+      } else {
+        current.recordedCostUsd += model.recordedCostUsd;
+      }
+      byModel.set(model.model, current);
+    }
+  }
+  const models = [...byModel.values()].sort((left, right) => left.model.localeCompare(right.model));
+  const allCostsKnown = rows.length > 0 && rows.every((row2) => row2.recordedCostUsd !== null);
+  return {
+    status: rows.length === 0 ? "unavailable" : "observed",
+    sessionCount: rows.length,
+    observedSessionCount: rows.length,
+    requestCount: rows.reduce((total, row2) => total + row2.requestCount, 0),
+    inputTokens: rows.reduce((total, row2) => total + row2.inputTokens, 0),
+    outputTokens: rows.reduce((total, row2) => total + row2.outputTokens, 0),
+    cacheReadTokens: rows.reduce((total, row2) => total + row2.cacheReadTokens, 0),
+    cacheWriteTokens: rows.reduce((total, row2) => total + row2.cacheWriteTokens, 0),
+    totalTokens: rows.reduce((total, row2) => total + row2.totalTokens, 0),
+    recordedCostUsd: allCostsKnown ? rows.reduce((total, row2) => total + (row2.recordedCostUsd ?? 0), 0) : null,
+    byModel: models
+  };
+}
+async function observeCcrUsage(input) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const event of input.events) {
+    if (event.sessionId) {
+      unique.set(`${event.harnessId}:${event.sessionId}`, {
+        harness: event.harnessId,
+        sessionId: event.sessionId
+      });
+    }
+  }
+  const entries = [...unique.values()];
+  const bounded = entries.slice(0, 20);
+  if (bounded.length === 0) {
+    return {
+      usage: {
+        status: "unavailable",
+        sessionCount: 0,
+        observedSessionCount: 0,
+        requestCount: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        recordedCostUsd: null,
+        byModel: []
+      },
+      failedSessions: 0
+    };
+  }
+  const managed = await resolveManagedCcr(input.context);
+  if (managed.kind === "unavailable")
+    throw new Error("CCR management credentials are unavailable");
+  const client = new CcrManagementClient({
+    baseUrl: managed.endpoint,
+    authToken: managed.token,
+    ...input.context.ccrFetch === void 0 ? {} : { fetcher: input.context.ccrFetch }
+  });
+  const appInfo = await client.call("getAppInfo");
+  if (readCcrVersion(appInfo) !== CCR_REVIEWED_VERSION) {
+    throw new Error("CCR version is outside the reviewed metadata interface");
+  }
+  const rows = [];
+  let failedSessions = entries.length - bounded.length;
+  for (const item of bounded) {
+    try {
+      const response = await client.call("getAgentAnalysis", [
+        {
+          agent: ccrAgentForHarness(item.harness),
+          sessionAgent: ccrAgentForHarness(item.harness),
+          sessionId: item.sessionId,
+          range: "7d"
+        }
+      ]);
+      const usage2 = reduceCcrSessionUsage(response, item.sessionId, ccrAgentForHarness(item.harness), input.since, input.until);
+      if (usage2 === null)
+        failedSessions += 1;
+      else
+        rows.push(usage2);
+    } catch {
+      failedSessions += 1;
+    }
+  }
+  const usage = combineSessionUsage(rows);
+  if (failedSessions > 0 && usage.status !== "unavailable")
+    usage.status = "partial";
+  return { usage: { ...usage, sessionCount: entries.length }, failedSessions };
+}
+async function loadSmartRoutingEventsForWindow(input) {
+  const fs = input.context.adapters?.fs;
+  const stateRoot = input.context.stateRoot;
+  if (fs === void 0 || stateRoot === null)
+    return [];
+  const directory = fs.join(stateRoot, "smart-routing");
+  let names;
+  try {
+    names = (await fs.readDirectory(directory)).filter((name2) => new RegExp(`^${SMART_ROUTING_EVENT_PREFIX}\\d{13}-[a-z0-9]+\\.json$`).test(name2)).sort();
+  } catch {
+    return [];
+  }
+  const start = Date.parse(input.since);
+  const end = Date.parse(input.until);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+    return [];
+  const events = [];
+  for (const name2 of names) {
+    try {
+      const value3 = JSON.parse(new TextDecoder().decode(await fs.readFile(fs.join(directory, name2))));
+      if (!isSmartRoutingDecisionEvent(value3) || value3.harnessId !== input.harness)
+        continue;
+      const timestamp = Date.parse(value3.timestamp);
+      if (Number.isFinite(timestamp) && timestamp >= start && timestamp <= end)
+        events.push(value3);
+    } catch {
+    }
+  }
+  return events;
+}
+var init_routing_usage = __esm({
+  "apps/cli/dist/src/commands/routing-usage.js"() {
+    "use strict";
+    init_src3();
+    init_ccr_runtime();
+    init_src();
+  }
+});
+
 // apps/cli/dist/src/commands/benchmark-capture.js
 function statePaths(context, benchmarkId, variant) {
   if (context.adapters === null || context.stateRoot === null)
@@ -26555,6 +28108,59 @@ async function runBenchmarkFinish(context) {
   const budget = budgetResult.data?.harnesses.find((item) => item.harnessId === parsed.capture.harnessId);
   const localUsage = parsed.capture.localSessionsBefore !== null && historyResult.data?.source.state === "available" ? deriveTaskLocalUsage(parsed.capture.localSessionsBefore, snapshotTaskLocalSessions(historyResult.data.sessions), parsed.capture.startedAt, completedAt) : null;
   const finishContextObservation = contextResult.data?.harnesses.find((item) => item.harnessId === parsed.capture.harnessId);
+  const routingHarness = parsed.capture.harnessId === CLAUDE12 ? "claude" : "codex";
+  const routingEvents = await loadSmartRoutingEventsForWindow({
+    context,
+    harness: routingHarness,
+    since: parsed.capture.startedAt,
+    until: completedAt
+  });
+  let ccrUsage;
+  let ccrUsageDiagnostics = [];
+  if (routingEvents.length > 0) {
+    try {
+      const observed = await observeCcrUsage({
+        context,
+        events: routingEvents,
+        since: parsed.capture.startedAt,
+        until: completedAt
+      });
+      ccrUsage = { schemaVersion: 1, ...observed.usage };
+      if (observed.usage.status !== "observed") {
+        ccrUsageDiagnostics = [
+          diagnostic({
+            severity: "warning",
+            code: "benchmark-ccr-usage-partial",
+            message: `CCR request usage was ${observed.usage.status} for this capture`,
+            remediation: "Check CCR Web RPC logging and keep one harness session active during the benchmark task"
+          })
+        ];
+      }
+    } catch {
+      ccrUsage = {
+        schemaVersion: 1,
+        status: "unavailable",
+        sessionCount: 0,
+        observedSessionCount: 0,
+        requestCount: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        recordedCostUsd: null,
+        byModel: []
+      };
+      ccrUsageDiagnostics = [
+        diagnostic({
+          severity: "warning",
+          code: "benchmark-ccr-usage-unavailable",
+          message: "CCR request usage could not be read; the task receipt is still valid without it",
+          remediation: "Set the local CCR Web RPC token and verify CCR 3.1.1 request logging before the next paired capture"
+        })
+      ];
+    }
+  }
   const completed = completeTaskBenchmarkCapture(parsed.capture, {
     completedAt,
     usageAfter: budget?.windows ?? [],
@@ -26563,7 +28169,8 @@ async function runBenchmarkFinish(context) {
     failedAttempts,
     localUsage,
     contextAtFinish: taskBenchmarkContextSnapshot(finishContextObservation),
-    policyAtFinish: benchmarkPolicySnapshot(finishContextObservation)
+    policyAtFinish: benchmarkPolicySnapshot(finishContextObservation),
+    ...ccrUsage === void 0 ? {} : { ccrUsage }
   });
   if (!completed.ok) {
     return commandResult({
@@ -26608,7 +28215,8 @@ async function runBenchmarkFinish(context) {
     diagnostics: [
       ...budgetResult.diagnostics,
       ...historyResult.diagnostics,
-      ...contextResult.diagnostics
+      ...contextResult.diagnostics,
+      ...ccrUsageDiagnostics
     ]
   });
 }
@@ -26620,6 +28228,7 @@ var init_benchmark_capture = __esm({
     init_budget2();
     init_context_cost2();
     init_history2();
+    init_routing_usage();
     CLAUDE12 = harnessId("claude");
     CODEX12 = harnessId("codex");
     CAPTURE_HARNESSES = /* @__PURE__ */ new Set([CLAUDE12, CODEX12]);
@@ -26833,11 +28442,11 @@ async function readJsonArtifact(context, path) {
   }
 }
 async function gitNexusBaselinePurity(context, benchmarkId) {
-  const receiptPath3 = benchmarkArtifactPath(context, benchmarkId, "baseline.json");
+  const receiptPath4 = benchmarkArtifactPath(context, benchmarkId, "baseline.json");
   const capturePath = benchmarkArtifactPath(context, benchmarkId, "baseline.capture.json");
-  if (receiptPath3 === null || capturePath === null)
+  if (receiptPath4 === null || capturePath === null)
     return "absent";
-  const rawReceipt = await readJsonArtifact(context, receiptPath3);
+  const rawReceipt = await readJsonArtifact(context, receiptPath4);
   if (rawReceipt.state !== "absent") {
     if (rawReceipt.state === "invalid")
       return "invalid";
@@ -29052,6 +30661,1031 @@ var init_rollback = __esm({
   }
 });
 
+// apps/cli/dist/src/commands/smart-routing.js
+import { createHash as createHash3 } from "node:crypto";
+function safeGatewayState(value3) {
+  if (!isJsonRecord(value3) || typeof value3["state"] !== "string")
+    return "unknown";
+  const state = value3["state"];
+  return ["running", "stopped", "starting", "stopping", "error"].includes(state) ? state : "unknown";
+}
+function isSmartRoutingHarness(value3) {
+  return value3 === "claude" || value3 === "codex";
+}
+function error(code, message, remediation) {
+  return commandResult({
+    command: "routing",
+    exitCode: EXIT_CODES["usage-error"],
+    diagnostics: [diagnostic({ severity: "error", code, message, remediation })]
+  });
+}
+function ccrFailure(errorValue) {
+  if (!(errorValue instanceof CcrManagementError)) {
+    return {
+      code: "ccr-management-failed",
+      message: "CCR management operation failed",
+      remediation: "Check the local CCR management service and repeat the command"
+    };
+  }
+  const rows = {
+    "endpoint-invalid": {
+      code: "ccr-endpoint-not-local",
+      message: "CCR management URL must use a loopback address on this machine",
+      remediation: "Use CCR_WEB_URL=http://127.0.0.1:3458 or another local loopback port"
+    },
+    "token-missing": {
+      code: "ccr-auth-token-required",
+      message: "CCR Web RPC authentication is not configured for Token Harness",
+      remediation: "Start the local CCR service or set CCR_WEB_AUTH_TOKEN and optionally CCR_WEB_URL; Token Harness never prints credentials, and managed credentials are stored only in protected local state"
+    },
+    unreachable: {
+      code: "ccr-management-unreachable",
+      message: "The local CCR management service could not be reached",
+      remediation: "Start CCR Web Management on this machine and set CCR_WEB_URL to its loopback address"
+    },
+    unauthorized: {
+      code: "ccr-management-unauthorized",
+      message: "CCR rejected the local management token",
+      remediation: "Use the same CCR_WEB_AUTH_TOKEN in the CCR service and Token Harness process"
+    },
+    "method-unavailable": {
+      code: "ccr-management-api-unsupported",
+      message: "This CCR build does not expose the reviewed management operation",
+      remediation: `Use CCR ${CCR_REVIEWED_VERSION} for managed setup, or add the exported rule through CCR Routing manually`
+    },
+    "config-drift": {
+      code: "ccr-config-changed-during-operation",
+      message: "CCR configuration changed while Token Harness was preparing the rule update",
+      remediation: "Review the latest CCR configuration and retry from a fresh preview"
+    },
+    "invalid-response": {
+      code: "ccr-management-response-invalid",
+      message: "CCR returned an unsupported or oversized management response",
+      remediation: "Check the CCR version and retry with a local CCR service"
+    },
+    "request-failed": {
+      code: "ccr-management-operation-failed",
+      message: "CCR could not complete the management operation",
+      remediation: "Review CCR status and retry; Token Harness did not print CCR response contents"
+    }
+  };
+  return rows[errorValue.failure];
+}
+function isJsonRecord(value3) {
+  return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
+}
+function receiptPath3(context, harness) {
+  const fs = context.adapters.fs;
+  return fs.join(stateDirectory(context), `ccr-ownership-${harness}.json`);
+}
+function scriptDirectory(context) {
+  return context.adapters.fs.join(stateDirectory(context), "ccr-scripts");
+}
+function scriptPath(context, harness) {
+  return context.adapters.fs.join(scriptDirectory(context), `smart-routing-${harness}.js`);
+}
+function stateDirectory(context) {
+  return context.adapters.fs.join(context.stateRoot, "smart-routing");
+}
+function scriptHash(script) {
+  return createHash3("sha256").update(script, "utf8").digest("hex");
+}
+async function readOwnership(context, harness) {
+  const path = receiptPath3(context, harness);
+  try {
+    const bytes = await context.adapters.fs.readFile(path);
+    const value3 = JSON.parse(new TextDecoder().decode(bytes));
+    if (isJsonRecord(value3) && value3["schemaVersion"] === 1 && (value3["status"] === "pending" || value3["status"] === "active") && value3["harnessId"] === harness && (value3["mode"] === "shadow" || value3["mode"] === "conservative") && value3["ruleId"] === ccrSmartRoutingRuleId(harness) && typeof value3["scriptPath"] === "string" && /^[a-f0-9]{64}$/.test(String(value3["scriptSha256"])) && (value3["profileId"] === void 0 || typeof value3["profileId"] === "string") && (value3["profileSha256"] === void 0 || /^[a-f0-9]{64}$/.test(String(value3["profileSha256"]))) && value3["profileId"] === void 0 === (value3["profileSha256"] === void 0) && typeof value3["installedAt"] === "string") {
+      return value3;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function writeJson4(context, path, value3) {
+  await context.adapters.fs.writeFile(path, new TextEncoder().encode(`${JSON.stringify(value3, null, 2)}
+`));
+}
+async function cleanupUnappliedCcrFiles(context, harness, ownership) {
+  const fs = context.adapters.fs;
+  const receipt = await readOwnership(context, harness);
+  if (receipt !== null && receipt.status === "pending" && receipt.scriptPath === ownership.scriptPath && receipt.scriptSha256 === ownership.scriptSha256) {
+    await fs.remove(receiptPath3(context, harness)).catch(() => void 0);
+  }
+  const scriptBytes = await fs.readFile(ownership.scriptPath).catch(() => null);
+  if (scriptBytes !== null && scriptHash(new TextDecoder().decode(scriptBytes)) === ownership.scriptSha256) {
+    await fs.remove(ownership.scriptPath).catch(() => void 0);
+  }
+}
+async function readCcrState(context) {
+  const managed = await resolveManagedCcr(context);
+  if (managed.kind === "unavailable")
+    throw new CcrManagementError("token-missing");
+  const client = new CcrManagementClient({
+    baseUrl: managed.endpoint,
+    authToken: managed.token,
+    ...context.ccrFetch === void 0 ? {} : { fetcher: context.ccrFetch }
+  });
+  const [appInfo, configValue, gatewayValue] = await Promise.all([
+    client.call("getAppInfo"),
+    client.call("getConfig"),
+    client.call("getGatewayStatus")
+  ]);
+  const version3 = readCcrVersion(appInfo);
+  if (version3 !== CCR_REVIEWED_VERSION) {
+    throw new CcrManagementError("method-unavailable");
+  }
+  if (!isJsonRecord(configValue) || !isJsonRecord(configValue["Router"])) {
+    throw new CcrManagementError("invalid-response");
+  }
+  const gatewayState = safeGatewayState(gatewayValue);
+  return { client, endpoint: managed.endpoint, version: version3, config: configValue, gatewayState };
+}
+function validateRouteRuleResult(value3) {
+  return isJsonRecord(value3) && value3["ok"] === true;
+}
+function profileSlug(value3) {
+  return value3.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "provider";
+}
+function planCcrProfile(config, harness, selectedModel) {
+  const profileContainer = isJsonRecord(config["profile"]) ? config["profile"] : null;
+  const profiles = profileContainer && Array.isArray(profileContainer["profiles"]) ? profileContainer["profiles"] : null;
+  if (profileContainer === null || profiles === null || profileContainer["enabled"] === false) {
+    return {
+      profile: null,
+      profileContainer,
+      conflict: false,
+      reason: "CCR Agent Profiles are unavailable or disabled"
+    };
+  }
+  const providerName3 = harness === "claude" ? "Claude Code API" : "Codex API";
+  const protocol = harness === "claude" ? "anthropic_messages" : "openai_responses";
+  const providers = Array.isArray(config["Providers"]) ? config["Providers"] : [];
+  const matches = providers.filter((item) => isJsonRecord(item) && item["name"] === providerName3 && item["type"] === protocol && Array.isArray(item["models"]) && item["models"].some((model2) => typeof model2 === "string" && /^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(model2)));
+  if (matches.length !== 1 || !isJsonRecord(matches[0])) {
+    return {
+      profile: null,
+      profileContainer,
+      conflict: false,
+      reason: matches.length === 0 ? `Import the existing ${providerName3} login/provider in CCR before Token Harness can create a safe launcher profile` : `CCR has multiple ${providerName3} providers; select the intended subscription account explicitly in CCR`
+    };
+  }
+  const provider = matches[0];
+  const models = provider["models"].filter((model2) => typeof model2 === "string" && /^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(model2));
+  let model;
+  const selectedModelValue = selectedModel?.trim();
+  if (selectedModelValue) {
+    if (!selectedModelValue.startsWith(`${providerName3}/`)) {
+      return {
+        profile: null,
+        profileContainer,
+        conflict: false,
+        reason: "TOKEN_HARNESS_ROUTING_PROFILE_MODEL must name a model from the matching CCR provider"
+      };
+    }
+    const selectedId = selectedModelValue.slice(providerName3.length + 1);
+    if (models.includes(selectedId))
+      model = selectedId;
+    else
+      return {
+        profile: null,
+        profileContainer,
+        conflict: false,
+        reason: "TOKEN_HARNESS_ROUTING_PROFILE_MODEL is not present in the matching CCR provider model list"
+      };
+  }
+  const providerDefault = typeof provider["defaultModel"] === "string" ? provider["defaultModel"] : typeof provider["model"] === "string" ? provider["model"] : null;
+  if (model === void 0 && providerDefault !== null) {
+    const providerDefaultId = providerDefault.startsWith(`${providerName3}/`) ? providerDefault.slice(providerName3.length + 1) : providerDefault;
+    if (models.includes(providerDefaultId))
+      model = providerDefaultId;
+  }
+  if (model === void 0 && models.length === 1)
+    model = models[0];
+  if (model === void 0) {
+    return {
+      profile: null,
+      profileContainer,
+      conflict: false,
+      reason: `${providerName3} has multiple models; set TOKEN_HARNESS_ROUTING_PROFILE_MODEL to the exact Provider/model you want as the CCR CLI default`
+    };
+  }
+  const id = OWNED_PROFILE_IDS[harness];
+  const profile = {
+    agent: harness === "claude" ? "claude-code" : "codex",
+    enabled: true,
+    id,
+    model: `${providerName3}/${model}`,
+    name: `Token Harness ${harness === "claude" ? "Claude Code" : "Codex"}`,
+    providerId: typeof provider["id"] === "string" ? provider["id"] : profileSlug(providerName3),
+    providerName: providerName3,
+    scope: "ccr",
+    surface: "cli"
+  };
+  const existing = profiles.filter((item) => isJsonRecord(item) && item["id"] === id);
+  if (existing.length > 0) {
+    return {
+      profile,
+      profileContainer,
+      conflict: true,
+      reason: "A CCR Agent Profile already uses the Token Harness profile id"
+    };
+  }
+  return { profile, profileContainer, conflict: false, reason: null };
+}
+function configuredCcrModel(config, requested) {
+  const candidate = requested?.trim();
+  if (candidate === void 0 || !/^[A-Za-z0-9_.:/@+ -]{1,160}$/.test(candidate))
+    return null;
+  const providers = Array.isArray(config["Providers"]) ? config["Providers"] : [];
+  return providers.some((provider) => isJsonRecord(provider) && typeof provider["name"] === "string" && Array.isArray(provider["models"]) && provider["models"].some((model) => typeof model === "string" && candidate === `${provider["name"]}/${model}`)) ? candidate : null;
+}
+function stableJson2(value3) {
+  if (Array.isArray(value3))
+    return `[${value3.map(stableJson2).join(",")}]`;
+  if (!isJsonRecord(value3))
+    return JSON.stringify(value3);
+  return `{${Object.keys(value3).sort().map((key) => `${JSON.stringify(key)}:${stableJson2(value3[key])}`).join(",")}}`;
+}
+function profileRows(config) {
+  const container = config["profile"];
+  return isJsonRecord(container) && Array.isArray(container["profiles"]) ? container["profiles"] : [];
+}
+function withCcrProfile(config, profile) {
+  const container = config["profile"];
+  if (!isJsonRecord(container) || container["enabled"] === false || !Array.isArray(container["profiles"])) {
+    return null;
+  }
+  if (container["profiles"].some((item) => isJsonRecord(item) && item["id"] === profile["id"])) {
+    return null;
+  }
+  return {
+    ...config,
+    profile: { ...container, profiles: [profile, ...container["profiles"]] }
+  };
+}
+function withoutOwnedCcrProfile(config, profileId, expectedSha256) {
+  const container = config["profile"];
+  if (!isJsonRecord(container) || !Array.isArray(container["profiles"]))
+    return config;
+  const matches = container["profiles"].filter((item) => isJsonRecord(item) && item["id"] === profileId);
+  if (matches.length === 0)
+    return config;
+  if (matches.length !== 1 || scriptHash(stableJson2(matches[0])) !== expectedSha256)
+    return null;
+  return {
+    ...config,
+    profile: {
+      ...container,
+      profiles: container["profiles"].filter((item) => !(isJsonRecord(item) && item["id"] === profileId))
+    }
+  };
+}
+function isExpectedCcrProfile(value3, expected) {
+  if (!isJsonRecord(value3))
+    return false;
+  const requiredKeys = [
+    "agent",
+    "enabled",
+    "id",
+    "model",
+    "name",
+    "providerId",
+    "providerName",
+    "scope",
+    "surface"
+  ];
+  return requiredKeys.every((key) => stableJson2(value3[key]) === stableJson2(expected[key]));
+}
+function ccrLaunchCommand(harness) {
+  return `ccr "Token Harness ${harness === "claude" ? "Claude Code" : "Codex"}"`;
+}
+function profilePlanDiagnostic(plan6) {
+  if (plan6.reason === null)
+    return null;
+  return diagnostic({
+    severity: "warning",
+    code: "ccr-profile-not-created",
+    message: plan6.reason,
+    remediation: `Resolve the CCR profile setup requirement and rerun routing setup; provider login/import and credential changes remain explicit CCR actions`
+  });
+}
+async function ccrConfiguration(context) {
+  const fs = context.adapters?.fs;
+  if (fs === void 0 || context.stateRoot === null || !isSmartRoutingHarness(context.harness)) {
+    return error("ccr-configuration-context-required", "Managed CCR setup needs a local state directory and a Claude Code or Codex harness", "Pass `--harness claude` or `--harness codex` from a local Token Harness installation");
+  }
+  const mode = context.routingMode ?? "shadow";
+  const harnessId2 = context.harness;
+  const ruleId = ccrSmartRoutingRuleId(harnessId2);
+  const path = scriptPath(context, harnessId2);
+  const telemetryDirectory = stateDirectory(context);
+  let ccr;
+  try {
+    ccr = await readCcrState(context);
+  } catch (errorValue) {
+    const issue = ccrFailure(errorValue);
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES["problems-found"],
+      diagnostics: [diagnostic({ severity: "error", ...issue })]
+    });
+  }
+  const requestedProfileModel = context.env?.["TOKEN_HARNESS_ROUTING_PROFILE_MODEL"];
+  const profilePlan = planCcrProfile(ccr.config, harnessId2, requestedProfileModel);
+  const profileModelWarning = requestedProfileModel?.trim() && (profilePlan.profile === null || profilePlan.profile["model"] !== requestedProfileModel.trim()) ? diagnostic({
+    severity: "warning",
+    code: "ccr-profile-model-not-configured",
+    message: "TOKEN_HARNESS_ROUTING_PROFILE_MODEL did not match a model in the selected CCR provider and was not applied",
+    remediation: "Set it to the exact Provider/model alias from CCR, then roll back and preview setup again"
+  }) : null;
+  const requestedSimpleModel = context.env?.["TOKEN_HARNESS_ROUTING_SIMPLE_MODEL"];
+  const configuredSimpleModel = configuredCcrModel(ccr.config, requestedSimpleModel);
+  const simpleModelWarning = requestedSimpleModel?.trim() && configuredSimpleModel === null ? diagnostic({
+    severity: "warning",
+    code: "ccr-simple-model-not-configured",
+    message: "TOKEN_HARNESS_ROUTING_SIMPLE_MODEL did not match a model in the selected CCR configuration and was not embedded",
+    remediation: "Set it to the exact Provider/model alias from CCR, then roll back and preview setup again"
+  }) : null;
+  const script = createCcrSmartRoutingScript({
+    harnessId: harnessId2,
+    mode,
+    telemetryDirectory,
+    pathSeparator: context.platform.os === "windows" ? "\\" : "/",
+    simpleModel: configuredSimpleModel
+  });
+  const expectedRule = createCcrSmartRoutingRule(harnessId2, path);
+  const router = ccr.config["Router"];
+  const rules = isJsonRecord(router) && Array.isArray(router["rules"]) ? router["rules"] : null;
+  if (rules === null) {
+    return error("ccr-routing-config-unavailable", "CCR configuration does not contain the reviewed routing-rule list", "Review CCR Routing manually and use `token-harness routing --script` to export the rule");
+  }
+  const matching = rules.filter((item) => isJsonRecord(item) && item["id"] === ruleId);
+  const owned = await readOwnership(context, harnessId2);
+  const profileList = profilePlan.profileContainer && Array.isArray(profilePlan.profileContainer["profiles"]) ? profilePlan.profileContainer["profiles"] : [];
+  const currentOwnedProfile = owned?.profileId ? profileList.find((item) => isJsonRecord(item) && item["id"] === owned.profileId) : void 0;
+  const ownedProfileMatches = owned?.profileId === void 0 || isJsonRecord(currentOwnedProfile) && owned.profileSha256 === scriptHash(stableJson2(currentOwnedProfile));
+  if (owned !== null && !ownedProfileMatches) {
+    return error("ccr-owned-profile-drift", "The Token Harness CCR profile changed or disappeared after setup, so configuration was left untouched", "Review the profile in CCR Agent Config; restore it or remove it manually before retrying");
+  }
+  if (profilePlan.conflict && !owned?.profileId) {
+    return error("ccr-profile-id-conflict", "A CCR Agent Profile already uses the Token Harness profile id, so it was left unchanged", "Rename or remove that profile in CCR Agent Config before retrying");
+  }
+  const ownershipStat = await fs.stat(receiptPath3(context, harnessId2));
+  if (owned === null && ownershipStat !== null) {
+    return error("ccr-ownership-state-invalid", "The local CCR ownership path already contains unrecognized data and was left unchanged", "Inspect or move the local ownership file before retrying CCR setup");
+  }
+  const targetFile = await fs.stat(path);
+  if (matching.length > 0) {
+    if (matching.length === 1 && isExactCcrSmartRoutingRule(matching[0], expectedRule) && owned) {
+      const currentScript = await fs.readFile(path).catch(() => null);
+      if (currentScript !== null && scriptHash(new TextDecoder().decode(currentScript)) === owned.scriptSha256) {
+        if (owned.mode !== mode || owned.scriptSha256 !== scriptHash(script)) {
+          return error("ccr-route-mode-requires-rollback", `CCR is already configured in ${owned.mode} mode; changing the mode requires an explicit rollback first`, `Review the active routing rule, run \`token-harness routing --rollback-ccr --harness ${harnessId2} --yes\`, then configure again in ${mode} mode`);
+        }
+        if (owned.profileId === void 0 && profilePlan.profile !== null && !profilePlan.conflict) {
+          const profileConfig = withCcrProfile(ccr.config, profilePlan.profile);
+          if (profileConfig === null) {
+            return error("ccr-profile-config-conflict", "CCR Agent Profile settings changed or cannot accept the Token Harness profile", "Review CCR Agent Config and retry from a new preview");
+          }
+          if (!context.confirmed) {
+            return configurationResult("configure", "preview", ccr, harnessId2, mode, ruleId, path, [
+              diagnostic({
+                severity: "info",
+                code: "ccr-profile-preview",
+                message: "The CCR routing rule is already owned; Token Harness would add its scoped CLI profile using the existing provider",
+                remediation: `Review the CCR-only profile and rerun with --yes. Launch it with ${ccrLaunchCommand(harnessId2)}`
+              })
+            ], String(profilePlan.profile["id"]), ccrLaunchCommand(harnessId2));
+          }
+          try {
+            const currentConfig = await ccr.client.call("getConfig");
+            if (!isSameCcrConfig(currentConfig, ccr.config))
+              throw new CcrManagementError("config-drift");
+            await ccr.client.call("saveConfig", [profileConfig, { applyProfile: false }]);
+            const afterConfig = await ccr.client.call("getConfig");
+            const afterRouter = isJsonRecord(afterConfig) ? afterConfig["Router"] : null;
+            const afterRules = isJsonRecord(afterRouter) && Array.isArray(afterRouter["rules"]) ? afterRouter["rules"] : [];
+            if (!afterRules.some((item) => isExactCcrSmartRoutingRule(item, expectedRule)))
+              throw new CcrManagementError("request-failed");
+            const savedProfile = profileRows(isJsonRecord(afterConfig) ? afterConfig : {}).find((item) => isJsonRecord(item) && item["id"] === profilePlan.profile?.["id"]);
+            if (!isExpectedCcrProfile(savedProfile, profilePlan.profile))
+              throw new CcrManagementError("request-failed");
+            const updatedOwnership = {
+              ...owned,
+              profileId: String(profilePlan.profile["id"]),
+              profileSha256: scriptHash(stableJson2(savedProfile))
+            };
+            await writeJson4(context, receiptPath3(context, harnessId2), updatedOwnership);
+            return configurationResult("configure", "configured", ccr, harnessId2, mode, ruleId, path, [
+              diagnostic({
+                severity: "info",
+                code: "ccr-profile-verified",
+                message: "CCR saved and verified the Token Harness scoped CLI profile using an existing provider",
+                remediation: `Launch Claude Code or Codex through ${ccrLaunchCommand(harnessId2)} and verify requests in CCR logs`
+              })
+            ], updatedOwnership.profileId, ccrLaunchCommand(harnessId2));
+          } catch (errorValue) {
+            const issue = ccrFailure(errorValue);
+            return commandResult({
+              command: "routing",
+              exitCode: EXIT_CODES["problems-found"],
+              diagnostics: [diagnostic({ severity: "error", ...issue })]
+            });
+          }
+        }
+        const profileWarning = owned.profileId === void 0 ? profilePlanDiagnostic(profilePlan) : null;
+        return configurationResult("configure", "already-configured", ccr, harnessId2, mode, ruleId, path, profileWarning === null ? [] : [profileWarning], owned.profileId ?? null, owned.profileId ? ccrLaunchCommand(harnessId2) : null);
+      }
+    }
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES["precondition-drift"],
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "ccr-routing-rule-conflict",
+          message: "A CCR rule already uses the Token Harness rule id, so it was left unchanged",
+          remediation: "Inspect that rule in CCR Routing and remove or rename it before retrying"
+        })
+      ]
+    });
+  }
+  if (owned !== null) {
+    return error("ccr-ownership-state-drift", "Token Harness has an ownership receipt but the CCR rule is missing or changed", "Run `token-harness routing --rollback-ccr --harness <id> --yes` after reviewing the CCR state");
+  }
+  if (targetFile !== null) {
+    return error("ccr-script-file-conflict", "The managed CCR script path already contains a file that Token Harness does not own", "Move that file or use the exported script with CCR Routing manually");
+  }
+  if (!context.confirmed) {
+    const profileDiagnostic = profilePlanDiagnostic(profilePlan);
+    return configurationResult("configure", "preview", ccr, harnessId2, mode, ruleId, path, [
+      diagnostic({
+        severity: "info",
+        code: "ccr-configure-preview",
+        message: profilePlan.profile === null ? `CCR ${ccr.version} would receive one ${mode} Node.js routing rule for ${harnessId2}` : `CCR ${ccr.version} would receive one ${mode} Node.js routing rule and a CCR-only CLI profile for ${harnessId2} using ${String(profilePlan.profile["model"])}`,
+        path,
+        remediation: `Review the exact CCR changes and rerun with --yes to apply them; CCR may restart. The profile uses an existing provider and affects only CLI launches through CCR. Rollback: \`token-harness routing --rollback-ccr --harness ${harnessId2} --yes\``
+      }),
+      ...profileDiagnostic === null ? [] : [profileDiagnostic],
+      ...profileModelWarning === null ? [] : [profileModelWarning],
+      ...simpleModelWarning === null ? [] : [simpleModelWarning]
+    ], profilePlan.profile === null ? null : String(profilePlan.profile["id"]), profilePlan.profile === null ? null : ccrLaunchCommand(harnessId2));
+  }
+  let validation;
+  try {
+    validation = await ccr.client.call("validateRouteScript", [
+      {
+        script: {
+          apiVersion: 1,
+          language: "javascript",
+          source: script,
+          timeoutMs: 2e3
+        }
+      }
+    ]);
+  } catch (errorValue) {
+    const issue = ccrFailure(errorValue);
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES["problems-found"],
+      diagnostics: [diagnostic({ severity: "error", ...issue })]
+    });
+  }
+  if (!validateRouteRuleResult(validation)) {
+    return error("ccr-script-validation-failed", "CCR did not validate the generated routing script", "No CCR or harness configuration was changed; inspect CCR compatibility and retry");
+  }
+  const withRule = addCcrSmartRoutingRule(ccr.config, expectedRule);
+  if (withRule === null) {
+    return error("ccr-routing-rule-conflict", "CCR routing rules changed or cannot accept a script rule", "Refresh CCR state and review existing rules before retrying");
+  }
+  const nextConfig = profilePlan.profile === null ? withRule : withCcrProfile(withRule, profilePlan.profile);
+  if (nextConfig === null) {
+    return error("ccr-profile-config-conflict", "CCR Agent Profile settings changed or cannot accept the Token Harness profile", "Review CCR Agent Config and retry from a new preview");
+  }
+  const now = context.now();
+  const ownership = {
+    schemaVersion: 1,
+    status: "pending",
+    harnessId: harnessId2,
+    mode,
+    ruleId,
+    scriptPath: path,
+    scriptSha256: scriptHash(script),
+    installedAt: now
+  };
+  let saveAttempted = false;
+  try {
+    await fs.createDirectory(telemetryDirectory);
+    await fs.createDirectory(scriptDirectory(context));
+    await writeJson4(context, receiptPath3(context, harnessId2), ownership);
+    await fs.writeFile(path, new TextEncoder().encode(script));
+    const currentConfig = await ccr.client.call("getConfig");
+    if (!isSameCcrConfig(currentConfig, ccr.config)) {
+      throw new CcrManagementError("config-drift");
+    }
+    saveAttempted = true;
+    await ccr.client.call("saveConfig", [nextConfig, { applyProfile: false }]);
+    const afterConfig = await ccr.client.call("getConfig");
+    const afterRouter = isJsonRecord(afterConfig) ? afterConfig["Router"] : null;
+    const afterRules = isJsonRecord(afterRouter) && Array.isArray(afterRouter["rules"]) ? afterRouter["rules"] : [];
+    if (!afterRules.some((item) => isExactCcrSmartRoutingRule(item, expectedRule))) {
+      throw new CcrManagementError("request-failed");
+    }
+    let savedProfile = null;
+    if (profilePlan.profile !== null) {
+      const saved = profileRows(isJsonRecord(afterConfig) ? afterConfig : {}).find((item) => isJsonRecord(item) && item["id"] === profilePlan.profile?.["id"]);
+      if (!isExpectedCcrProfile(saved, profilePlan.profile))
+        throw new CcrManagementError("request-failed");
+      savedProfile = saved;
+    }
+    const activeOwnership2 = {
+      ...ownership,
+      status: "active",
+      ...savedProfile === null || profilePlan.profile === null ? {} : {
+        profileId: String(profilePlan.profile["id"]),
+        profileSha256: scriptHash(stableJson2(savedProfile))
+      }
+    };
+    await writeJson4(context, receiptPath3(context, harnessId2), activeOwnership2);
+    const gatewayValue = await ccr.client.call("getGatewayStatus");
+    const gatewayState = safeGatewayState(gatewayValue);
+    const finalCcr = { ...ccr, gatewayState };
+    const profileDiagnostic = profilePlanDiagnostic(profilePlan);
+    return configurationResult("configure", "configured", finalCcr, harnessId2, mode, ruleId, path, [
+      diagnostic({
+        severity: gatewayState === "running" ? "info" : "warning",
+        code: gatewayState === "running" ? "ccr-config-verified" : "ccr-gateway-not-running",
+        message: gatewayState === "running" ? "CCR accepted the rule and its gateway reports running; live request routing has not been exercised" : `CCR saved and verified the rule, but its gateway reports ${gatewayState}`,
+        path,
+        remediation: gatewayState === "running" ? "Use shadow mode first, then inspect local decisions with `token-harness routing --route-metrics`" : "Start or repair the CCR gateway, then verify it before sending a model request"
+      }),
+      ...profileDiagnostic === null ? [] : [profileDiagnostic],
+      ...profileModelWarning === null ? [] : [profileModelWarning],
+      ...simpleModelWarning === null ? [] : [simpleModelWarning]
+    ], activeOwnership2.profileId ?? null, activeOwnership2.profileId ? ccrLaunchCommand(harnessId2) : null);
+  } catch (errorValue) {
+    if (!saveAttempted)
+      await cleanupUnappliedCcrFiles(context, harnessId2, ownership);
+    const issue = ccrFailure(errorValue);
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES["problems-found"],
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: issue.code,
+          message: saveAttempted ? `${issue.message}; the ownership receipt was retained for safe recovery` : `${issue.message}; CCR configuration was not changed`,
+          ...saveAttempted ? { path: receiptPath3(context, harnessId2) } : {},
+          remediation: saveAttempted ? `Run \`token-harness routing --rollback-ccr --harness ${harnessId2} --yes\` to remove only the owned rule, or inspect the ownership receipt first` : "Resolve the local or CCR issue and start again from a new preview"
+        })
+      ]
+    });
+  }
+}
+function configurationResult(action, state, ccr, harnessId2, mode, ruleId, path, diagnostics = [], profileId = null, launchCommand = null) {
+  return commandResult({
+    command: "routing",
+    exitCode: EXIT_CODES.ok,
+    data: {
+      kind: "ccr-configuration",
+      action,
+      state,
+      harnessId: harnessId2,
+      mode,
+      ccrVersion: ccr.version,
+      gatewayState: ccr.gatewayState,
+      ruleId,
+      scriptPath: path,
+      managementEndpoint: ccr.endpoint,
+      profileId,
+      launchCommand
+    },
+    diagnostics
+  });
+}
+async function rollbackCcrConfiguration(context) {
+  const fs = context.adapters?.fs;
+  if (fs === void 0 || context.stateRoot === null || !isSmartRoutingHarness(context.harness)) {
+    return error("ccr-rollback-context-required", "CCR rollback needs the local ownership receipt and a Claude Code or Codex harness", "Pass the same `--harness` used for CCR configuration");
+  }
+  const harnessId2 = context.harness;
+  const ownership = await readOwnership(context, harnessId2);
+  if (ownership === null) {
+    return error("ccr-ownership-receipt-missing", "Token Harness has no valid CCR ownership receipt for this harness", "Review the rule in CCR manually; Token Harness removes only rules it recorded as owned");
+  }
+  let ccr;
+  try {
+    ccr = await readCcrState(context);
+  } catch (errorValue) {
+    const issue = ccrFailure(errorValue);
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES["problems-found"],
+      diagnostics: [diagnostic({ severity: "error", ...issue })]
+    });
+  }
+  const expectedRule = createCcrSmartRoutingRule(harnessId2, ownership.scriptPath);
+  const profileValue = ownership.profileId === void 0 ? null : profileRows(ccr.config).find((item) => isJsonRecord(item) && item["id"] === ownership.profileId) ?? null;
+  if (ownership.profileId !== void 0 && profileValue !== null && (ownership.profileSha256 === void 0 || scriptHash(stableJson2(profileValue)) !== ownership.profileSha256)) {
+    return error("ccr-owned-profile-drift", "The CCR profile changed after Token Harness created it, so rollback left it untouched", "Review the profile in CCR Agent Config; restore it or remove it manually before retrying rollback");
+  }
+  const rules = isJsonRecord(ccr.config["Router"]) && Array.isArray(ccr.config["Router"]["rules"]) ? ccr.config["Router"]["rules"] : [];
+  const ownedRule = rules.find((item) => isJsonRecord(item) && item["id"] === ownership.ruleId);
+  if (ownedRule === void 0) {
+    if (!context.confirmed) {
+      return configurationResult("rollback", ownership.profileId === void 0 ? "already-absent" : "preview", ccr, harnessId2, ownership.mode, ownership.ruleId, ownership.scriptPath, ownership.profileId === void 0 ? [] : [
+        diagnostic({
+          severity: "info",
+          code: "ccr-rollback-profile-preview",
+          message: "Rollback would remove the remaining exact Token Harness CLI profile and local script",
+          remediation: "Review the change and rerun with --yes to apply it"
+        })
+      ], ownership.profileId ?? null, ownership.profileId === void 0 ? null : ccrLaunchCommand(harnessId2));
+    }
+    if (ownership.profileId !== void 0) {
+      const nextConfig2 = withoutOwnedCcrProfile(ccr.config, ownership.profileId, ownership.profileSha256);
+      if (nextConfig2 === null) {
+        return error("ccr-owned-profile-drift", "The CCR profile is duplicated or changed, so rollback left it untouched", "Review CCR Agent Config and retry after restoring the exact owned profile");
+      }
+      try {
+        const currentConfig = await ccr.client.call("getConfig");
+        if (!isSameCcrConfig(currentConfig, ccr.config))
+          throw new CcrManagementError("config-drift");
+        await ccr.client.call("saveConfig", [nextConfig2, { applyProfile: false }]);
+        const afterConfig = await ccr.client.call("getConfig");
+        if (profileRows(isJsonRecord(afterConfig) ? afterConfig : {}).some((item) => isJsonRecord(item) && item["id"] === ownership.profileId)) {
+          throw new CcrManagementError("request-failed");
+        }
+      } catch (errorValue) {
+        const issue = ccrFailure(errorValue);
+        return commandResult({
+          command: "routing",
+          exitCode: EXIT_CODES["problems-found"],
+          diagnostics: [diagnostic({ severity: "error", ...issue })]
+        });
+      }
+    }
+    const bytes = await fs.readFile(ownership.scriptPath).catch(() => null);
+    if (bytes !== null && scriptHash(new TextDecoder().decode(bytes)) === ownership.scriptSha256) {
+      await fs.remove(ownership.scriptPath);
+    }
+    await fs.remove(receiptPath3(context, harnessId2));
+    return configurationResult("rollback", "already-absent", ccr, harnessId2, ownership.mode, ownership.ruleId, ownership.scriptPath);
+  }
+  if (!isExactCcrSmartRoutingRule(ownedRule, expectedRule)) {
+    return error("ccr-owned-rule-drift", "The CCR rule changed after Token Harness installed it, so rollback left it untouched", "Review the rule in CCR Routing and restore or remove it manually before retrying");
+  }
+  if (!context.confirmed) {
+    return configurationResult("rollback", "preview", ccr, harnessId2, ownership.mode, ownership.ruleId, ownership.scriptPath, [
+      diagnostic({
+        severity: "info",
+        code: "ccr-rollback-preview",
+        message: "Rollback would remove the exact Token Harness rule and script while preserving other CCR settings",
+        path: ownership.scriptPath,
+        remediation: "Review the change and rerun with --yes to apply it"
+      }),
+      ...ownership.profileId === void 0 ? [] : [
+        diagnostic({
+          severity: "info",
+          code: "ccr-rollback-profile-preview",
+          message: "Rollback also removes the exact Token Harness scoped CLI profile; providers and credentials remain unchanged",
+          remediation: "Review the change and rerun with --yes to apply it"
+        })
+      ]
+    ], ownership.profileId ?? null, ownership.profileId === void 0 ? null : ccrLaunchCommand(harnessId2));
+  }
+  const withoutRule = removeOwnedCcrSmartRoutingRule(ccr.config, ownership.ruleId, expectedRule);
+  if (withoutRule === null) {
+    return error("ccr-owned-rule-drift", "CCR rules changed while rollback was being prepared", "Refresh the CCR state and retry after reviewing the rule list");
+  }
+  const nextConfig = ownership.profileId === void 0 ? withoutRule : withoutOwnedCcrProfile(withoutRule, ownership.profileId, ownership.profileSha256);
+  if (nextConfig === null) {
+    return error("ccr-owned-profile-drift", "The Token Harness CCR profile changed while rollback was being prepared", "Refresh CCR state and retry after reviewing the profile");
+  }
+  try {
+    const currentConfig = await ccr.client.call("getConfig");
+    if (!isSameCcrConfig(currentConfig, ccr.config)) {
+      throw new CcrManagementError("config-drift");
+    }
+    await ccr.client.call("saveConfig", [nextConfig, { applyProfile: false }]);
+    const after = await ccr.client.call("getConfig");
+    const afterRules = isJsonRecord(after) && isJsonRecord(after["Router"]) && Array.isArray(after["Router"]["rules"]) ? after["Router"]["rules"] : [];
+    if (afterRules.some((item) => isJsonRecord(item) && item["id"] === ownership.ruleId)) {
+      throw new CcrManagementError("request-failed");
+    }
+    if (ownership.profileId !== void 0 && profileRows(isJsonRecord(after) ? after : {}).some((item) => isJsonRecord(item) && item["id"] === ownership.profileId)) {
+      throw new CcrManagementError("request-failed");
+    }
+    const gatewayValue = await ccr.client.call("getGatewayStatus");
+    const gatewayState = safeGatewayState(gatewayValue);
+    const bytes = await fs.readFile(ownership.scriptPath).catch(() => null);
+    if (bytes !== null && scriptHash(new TextDecoder().decode(bytes)) === ownership.scriptSha256) {
+      await fs.remove(ownership.scriptPath);
+    }
+    await fs.remove(receiptPath3(context, harnessId2));
+    return configurationResult("rollback", "rolled-back", { ...ccr, gatewayState }, harnessId2, ownership.mode, ownership.ruleId, ownership.scriptPath, [
+      diagnostic({
+        severity: "info",
+        code: "ccr-rollback-verified",
+        message: "CCR no longer contains the owned rule; other routing rules were preserved",
+        path: ownership.scriptPath,
+        remediation: "No further action is required"
+      })
+    ]);
+  } catch (errorValue) {
+    const issue = ccrFailure(errorValue);
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES["problems-found"],
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: issue.code,
+          message: `${issue.message}; the ownership receipt was retained for another rollback attempt`,
+          path: receiptPath3(context, harnessId2),
+          remediation: "Check CCR status and retry the rollback after it is reachable"
+        })
+      ]
+    });
+  }
+}
+async function runSmartRouting(context) {
+  const wantsScript = context.routingScript === true;
+  const wantsMetrics = context.routingMetrics === true;
+  const wantsCcrConfigure = context.routingCcrConfigure === true;
+  const wantsCcrRollback = context.routingCcrRollback === true;
+  const wantsCcrUpdate = context.routingCcrUpdate === true;
+  const requestedActions = [
+    wantsScript,
+    wantsMetrics,
+    wantsCcrConfigure,
+    wantsCcrRollback,
+    wantsCcrUpdate
+  ].filter(Boolean).length;
+  if (requestedActions !== 1) {
+    return error("routing-action-required", "Choose one Smart Model Routing action", "Use `token-harness routing --script --harness claude`, `--configure-ccr`, `--update-ccr`, `--rollback-ccr`, or `--route-metrics`");
+  }
+  if (context.routingPrune === true && !wantsMetrics) {
+    return error("routing-prune-requires-metrics", "`--prune` is available only with the routing metrics action", "Use `token-harness routing --route-metrics --prune`");
+  }
+  if (context.routingCcrUsage === true && !wantsMetrics) {
+    return error("ccr-usage-requires-metrics", "`--ccr-usage` is available only with routing metrics", "Use `token-harness routing --route-metrics --ccr-usage`");
+  }
+  if (context.routingMode === "conservative" && !wantsScript && !wantsCcrConfigure) {
+    return error("routing-mode-requires-configuration", "`--route-mode` applies only when exporting or configuring a CCR rule", "Use `token-harness routing --configure-ccr --harness codex --route-mode conservative`");
+  }
+  if (wantsCcrConfigure) {
+    let managed;
+    try {
+      managed = await resolveManagedCcr(context);
+    } catch (errorValue) {
+      const issue = ccrFailure(errorValue);
+      return commandResult({
+        command: "routing",
+        exitCode: EXIT_CODES["problems-found"],
+        diagnostics: [diagnostic({ severity: "error", ...issue })]
+      });
+    }
+    if (managed.kind === "external")
+      return ccrConfiguration(context);
+    const ensured = await ensureManagedCcrRuntime({ context, action: "configure" });
+    if (ensured.kind === "result")
+      return ensured.result;
+    if (ensured.changed) {
+      const state = ensured.lifecycleAction === "install" ? "installed" : ensured.lifecycleAction === "update" ? "updated" : "started";
+      return commandResult({
+        command: "routing",
+        exitCode: EXIT_CODES.ok,
+        data: {
+          kind: "ccr-lifecycle",
+          action: ensured.lifecycleAction,
+          state,
+          version: CCR_REVIEWED_VERSION,
+          packagePath: ensured.packagePath,
+          executablePath: ensured.executablePath,
+          managementEndpoint: ensured.endpoint
+        },
+        diagnostics: [
+          diagnostic({
+            severity: "info",
+            code: `ccr-${ensured.lifecycleAction}-verified`,
+            message: `Token Harness ${state} and verified the local CCR CLI and gateway`,
+            remediation: `Next preview and configure the ${context.routingMode ?? "shadow"} routing rule with token-harness routing --configure-ccr --harness ${String(context.harness ?? "<claude|codex>")}; provider login/import remains a separate CCR choice`
+          })
+        ]
+      });
+    }
+    const configured = await ccrConfiguration({
+      ...context,
+      env: {
+        ...context.env ?? {},
+        CCR_WEB_URL: ensured.endpoint,
+        CCR_WEB_AUTH_TOKEN: ensured.token
+      }
+    });
+    return configured;
+  }
+  if (wantsCcrUpdate) {
+    let managed;
+    try {
+      managed = await resolveManagedCcr(context);
+    } catch (errorValue) {
+      const issue = ccrFailure(errorValue);
+      return commandResult({
+        command: "routing",
+        exitCode: EXIT_CODES["problems-found"],
+        diagnostics: [diagnostic({ severity: "error", ...issue })]
+      });
+    }
+    if (managed.kind !== "managed") {
+      return error("ccr-update-not-managed", "Token Harness updates only the CCR CLI installation it owns", "Install CCR through `token-harness routing --configure-ccr --harness <claude|codex>` first; external CCR installations are left to their owner");
+    }
+    const updated = await ensureManagedCcrRuntime({ context, action: "update" });
+    if (updated.kind === "result")
+      return updated.result;
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES.ok,
+      data: {
+        kind: "ccr-lifecycle",
+        action: updated.lifecycleAction,
+        state: updated.lifecycleAction === "start" ? "started" : updated.lifecycleAction === "update" ? "updated" : "installed",
+        version: CCR_REVIEWED_VERSION,
+        packagePath: updated.packagePath,
+        executablePath: updated.executablePath,
+        managementEndpoint: updated.endpoint
+      },
+      diagnostics: [
+        diagnostic({
+          severity: "info",
+          code: `ccr-${updated.lifecycleAction}-verified`,
+          message: updated.lifecycleAction === "update" ? `Token Harness updated its managed CCR CLI to ${CCR_REVIEWED_VERSION} and verified the gateway` : updated.lifecycleAction === "start" ? `Token Harness started its managed CCR ${CCR_REVIEWED_VERSION} service` : `Token Harness installed its managed CCR ${CCR_REVIEWED_VERSION} service`,
+          remediation: "This verifies the local gateway only; it does not prove that a Claude Code or Codex request was routed or that subscription quota was saved"
+        })
+      ]
+    });
+  }
+  if (wantsCcrRollback)
+    return rollbackCcrConfiguration(context);
+  const fs = context.adapters?.fs;
+  const stateRoot = context.stateRoot;
+  if (fs === void 0 || stateRoot === null) {
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES["unsupported-environment"],
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "routing-state-unavailable",
+          message: "Smart Model Routing requires the protected local Token Harness state directory",
+          remediation: "Resolve the local state directory with `token-harness doctor`"
+        })
+      ]
+    });
+  }
+  const telemetryDirectory = fs.join(stateRoot, "smart-routing");
+  if (wantsScript) {
+    if (!isSmartRoutingHarness(context.harness)) {
+      return error("routing-harness-required", "CCR script generation needs Claude Code or Codex as its harness", "Pass `--harness claude` or `--harness codex`");
+    }
+    await fs.createDirectory(telemetryDirectory);
+    const script = createCcrSmartRoutingScript({
+      harnessId: context.harness,
+      mode: context.routingMode ?? "shadow",
+      telemetryDirectory,
+      pathSeparator: context.platform.os === "windows" ? "\\" : "/"
+    });
+    return commandResult({
+      command: "routing",
+      exitCode: EXIT_CODES.ok,
+      data: {
+        kind: "ccr-script",
+        harnessId: context.harness,
+        mode: context.routingMode ?? "shadow",
+        telemetryDirectory,
+        script
+      }
+    });
+  }
+  const resolved = resolveMetricsWindow({
+    since: context.since,
+    until: context.until,
+    now: context.now()
+  });
+  if (!resolved.ok) {
+    return error("invalid-routing-window", resolved.failure === "start-after-end" ? `The routing metrics window is empty: ${resolved.detail}` : `${JSON.stringify(resolved.detail)} is not a duration such as \`7d\` or a date such as \`2026-09-01\``, "Pass `--since 7d`, or `--since 2026-09-01 --until 2026-09-24`");
+  }
+  const directoryEntries = (await fs.readDirectory(telemetryDirectory)).filter((name2) => new RegExp(`^${SMART_ROUTING_EVENT_PREFIX}\\d{13}-[a-z0-9]+\\.json$`).test(name2)).sort();
+  let prunedRecordCount = 0;
+  if (context.routingPrune === true && directoryEntries.length > SMART_ROUTING_EVENT_RETENTION_LIMIT) {
+    const removeCount = directoryEntries.length - SMART_ROUTING_EVENT_RETENTION_LIMIT;
+    for (const name2 of directoryEntries.slice(0, removeCount)) {
+      await fs.remove(fs.join(telemetryDirectory, name2));
+    }
+    prunedRecordCount = removeCount;
+  }
+  const retainedNames = context.routingPrune === true ? directoryEntries.slice(prunedRecordCount) : directoryEntries;
+  const events = [];
+  let malformedRecordCount = 0;
+  for (const name2 of retainedNames) {
+    try {
+      const content = new TextDecoder().decode(await fs.readFile(fs.join(telemetryDirectory, name2)));
+      const parsed = JSON.parse(content);
+      if (!isSmartRoutingDecisionEvent(parsed)) {
+        malformedRecordCount += 1;
+        continue;
+      }
+      const timestamp = Date.parse(parsed.timestamp);
+      if (!Number.isFinite(timestamp)) {
+        malformedRecordCount += 1;
+        continue;
+      }
+      if (timestamp < Date.parse(resolved.window.sinceInstant))
+        continue;
+      if (timestamp >= Date.parse(resolved.window.untilInstant))
+        continue;
+      if (context.harness !== null && parsed.harnessId !== context.harness)
+        continue;
+      events.push(parsed);
+    } catch {
+      malformedRecordCount += 1;
+    }
+  }
+  const metrics = aggregateSmartRoutingEvents({ events, malformedRecordCount, prunedRecordCount });
+  let ccrUsage;
+  const diagnostics = events.length === 0 && malformedRecordCount === 0 ? [
+    diagnostic({
+      severity: "info",
+      code: "routing-decisions-unavailable",
+      message: "No CCR routing decisions are stored for this window",
+      remediation: "Generate a CCR rule with `token-harness routing --script --harness codex` or configure one with `--configure-ccr`"
+    })
+  ] : [];
+  if (context.routingCcrUsage === true) {
+    try {
+      const observed = await observeCcrUsage({
+        context,
+        events,
+        since: resolved.window.sinceInstant,
+        until: resolved.window.untilInstant
+      });
+      ccrUsage = observed.usage;
+      if (observed.failedSessions > 0 || observed.usage.status === "unavailable") {
+        diagnostics.push(diagnostic({
+          severity: "warning",
+          code: observed.usage.status === "unavailable" ? "ccr-usage-unavailable" : "ccr-usage-partial",
+          message: observed.usage.status === "unavailable" ? "CCR request usage could not be matched to any retained routing session" : `CCR usage was read for ${String(observed.usage.observedSessionCount)} of ${String(observed.usage.sessionCount)} sessions`,
+          remediation: "Keep CCR request logging enabled, use the same local session, and rerun with a narrower time window"
+        }));
+      }
+    } catch (errorValue) {
+      const issue = ccrFailure(errorValue);
+      diagnostics.push(diagnostic({ severity: "warning", ...issue }));
+      ccrUsage = {
+        status: "unavailable",
+        sessionCount: 0,
+        observedSessionCount: 0,
+        requestCount: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        recordedCostUsd: null,
+        byModel: []
+      };
+    }
+  }
+  return commandResult({
+    command: "routing",
+    exitCode: EXIT_CODES.ok,
+    data: {
+      kind: "metrics",
+      since: resolved.window.sinceInstant,
+      until: resolved.window.untilInstant,
+      metrics,
+      ...ccrUsage === void 0 ? {} : { ccrUsage }
+    },
+    diagnostics
+  });
+}
+var OWNED_PROFILE_IDS;
+var init_smart_routing2 = __esm({
+  "apps/cli/dist/src/commands/smart-routing.js"() {
+    "use strict";
+    init_src3();
+    init_src();
+    init_routing_usage();
+    init_ccr_runtime();
+    OWNED_PROFILE_IDS = {
+      claude: "token-harness-smart-routing-claude-v1",
+      codex: "token-harness-smart-routing-codex-v1"
+    };
+  }
+});
+
 // apps/cli/dist/src/commands/verify.js
 async function runVerify(context) {
   const diagnostics = [];
@@ -29848,6 +32482,12 @@ async function runPackageChannelUpdate(context, options = {}) {
       report.providers.push(row2);
       continue;
     }
+    if (adapter.manifest.id === "rtk" && context.adapters.resolveExecutables !== void 0 && (context.platform.os === "linux" || context.platform.os === "macos")) {
+      row2.channel = "github-release";
+      row2.verdict = "unknown";
+      report.providers.push(row2);
+      continue;
+    }
     const packageName = channel.packageId ?? adapter.manifest.id;
     const query = await queryAvailableVersion({
       packageManager: channel.id,
@@ -30142,80 +32782,123 @@ var init_update_base = __esm({
 });
 
 // apps/cli/dist/src/commands/rtk-release-update.js
-async function planDirectRtkWindowsRelease(input) {
-  const empty2 = () => ({
+async function planDirectRtkRelease(input) {
+  const empty2 = (verdict = "unsupported", diagnostics = []) => ({
     plan: null,
-    diagnostics: [],
+    availableVersion: null,
+    verdict,
+    diagnostics,
     destinations: []
   });
   if (input.providerId !== "rtk")
     return empty2();
-  if (input.platform.os !== "windows" || input.platform.isWsl)
-    return empty2();
-  if (input.installedVersion === null)
-    return empty2();
-  const installed2 = parseSemanticVersion(input.installedVersion);
   const targetText = reviewedProviderPackageMaximum(input.providerId);
-  const target = targetText === null ? null : parseSemanticVersion(targetText);
-  if (installed2 === null || target === null || targetText === null)
-    return empty2();
-  if (compareVersions(target, installed2) <= 0)
-    return empty2();
-  const channel = input.channelAvailableVersion === null ? null : parseSemanticVersion(input.channelAvailableVersion);
-  if (channel !== null && compareVersions(channel, target) >= 0)
+  if (targetText === null)
     return empty2();
-  const admission = admitProviderPackageUpdate(input.providerId, targetText);
-  if (admission.state !== "admitted")
-    return empty2();
-  if (input.executablePaths.length !== 1) {
-    const detail2 = input.executablePaths.length === 0 ? "no concrete rtk.exe path could be resolved" : `${String(input.executablePaths.length)} different rtk.exe paths resolve: ${input.executablePaths.join(", ")}`;
+  const windows = input.platform.os === "windows" && !input.platform.isWsl;
+  if (rtkReleaseAssetForPlatform(input.platform) === null) {
+    return windows ? empty2("defer") : empty2("unavailable", [
+      diagnostic({
+        severity: "warning",
+        code: "rtk-release-platform-unsupported",
+        subject: input.providerId,
+        message: `The RTK GitHub release has no managed artifact for ${input.platform.os}/${input.platform.arch}`,
+        remediation: "Update RTK manually from its official installation instructions"
+      })
+    ]);
+  }
+  const installedText = input.installedVersion;
+  if (installedText === null)
+    return empty2("unavailable");
+  const installed2 = parseSemanticVersion(installedText);
+  const target = parseSemanticVersion(targetText);
+  if (installed2 === null || target === null)
+    return empty2("unavailable");
+  if (windows) {
+    const channel = input.channelAvailableVersion === null ? null : parseSemanticVersion(input.channelAvailableVersion);
+    if (channel !== null && compareVersions(channel, target) >= 0)
+      return empty2("defer");
+  }
+  if (compareVersions(target, installed2) <= 0) {
     return {
-      plan: null,
-      destinations: [],
-      diagnostics: [
-        diagnostic({
-          severity: "warning",
-          code: "rtk-release-target-ambiguous",
-          subject: input.providerId,
-          message: `The verified GitHub release fallback was not planned because ${detail2}`,
-          remediation: "Make exactly one intended RTK executable resolve on PATH, then re-run update; Token Harness will not choose an arbitrary binary to overwrite"
-        })
-      ]
+      ...empty2("current"),
+      availableVersion: targetText
     };
   }
-  const executablePath = input.executablePaths[0];
-  if (executablePath === void 0)
-    return empty2();
-  const runtime = rtkWindowsReleaseRuntimeFor(input.fs, input.runner);
+  const admission = admitProviderPackageUpdate(input.providerId, targetText);
+  if (admission.state !== "admitted")
+    return empty2("unavailable");
+  if (input.executables.length !== 1) {
+    const detail2 = input.executables.length === 0 ? "no concrete RTK executable path could be resolved" : `${String(input.executables.length)} RTK executable paths resolve: ${input.executables.map((entry) => entry.path).join(", ")}`;
+    return empty2("unavailable", [
+      diagnostic({
+        severity: "warning",
+        code: "rtk-release-target-ambiguous",
+        subject: input.providerId,
+        message: `The verified GitHub release update was not planned because ${detail2}`,
+        remediation: "Make exactly one intended RTK executable resolve on PATH, then re-run Check for updates; Token Harness will not choose an arbitrary binary to replace"
+      })
+    ]);
+  }
+  const executable = input.executables[0];
+  if (executable === void 0 || executable.kind !== "native") {
+    return empty2("unavailable", [
+      diagnostic({
+        severity: "warning",
+        code: "rtk-release-target-not-native",
+        subject: input.providerId,
+        message: "The resolved RTK path is not a native executable, so its file will not be replaced",
+        remediation: "Install RTK as a native binary, then retry the update check"
+      })
+    ]);
+  }
+  const canonicalPath = input.fs.canonicalPath;
+  if (canonicalPath === void 0)
+    return empty2("unavailable");
+  const targetPath = await canonicalPath.call(input.fs, executable.path);
+  if (targetPath === null) {
+    return empty2("unavailable", [
+      diagnostic({
+        severity: "warning",
+        code: "rtk-release-target-unresolved",
+        subject: input.providerId,
+        path: executable.path,
+        message: "The resolved RTK executable path could not be canonicalized",
+        remediation: "Check PATH and filesystem access, then retry the update check"
+      })
+    ]);
+  }
+  const runtime = rtkReleaseRuntimeFor(input.fs, input.runner, input.releaseFetch);
   if (runtime === null)
-    return empty2();
-  const queried = await runtime.query(targetText);
+    return empty2("unavailable");
+  const queried = await runtime.query(targetText, input.platform);
   if (queried.status !== "found") {
     return {
-      plan: null,
-      destinations: [RTK_RELEASE_METADATA_DESTINATION],
-      diagnostics: [
+      ...empty2("unavailable", [
         diagnostic({
           severity: "warning",
           code: "rtk-release-fallback-unavailable",
           subject: input.providerId,
-          message: `RTK ${targetText} is reviewed but its verified Windows GitHub release could not be selected: ${queried.message}`,
-          remediation: "Token Harness will keep using the ordinary package channel; retry after checking GitHub connectivity or release metadata"
+          message: `RTK ${targetText} is reviewed but its official GitHub release could not be selected: ${queried.message}`,
+          remediation: "Retry after checking GitHub connectivity and confirm that the RTK release includes an asset for this platform"
         })
-      ]
+      ]),
+      destinations: [RTK_RELEASE_METADATA_DESTINATION]
     };
   }
-  const digest = digestText(`${input.providerId} github-release ${input.installedVersion} ${targetText} ${executablePath}`);
+  const digest = digestText(`${input.providerId} github-release ${installedText} ${targetText} ${targetPath}`);
   return {
     plan: {
       id: digest.slice(digest.indexOf(":") + 1, digest.indexOf(":") + 9),
       providerId: input.providerId,
-      installed: input.installedVersion,
+      installed: installedText,
       target: targetText,
-      targetPath: executablePath,
+      targetPath,
       asset: queried.asset,
       runtime
     },
+    availableVersion: targetText,
+    verdict: "upgradable",
     diagnostics: [],
     destinations: [RTK_RELEASE_METADATA_DESTINATION]
   };
@@ -30251,47 +32934,50 @@ function execution(input) {
     receiptId: input.base?.receiptId ?? (input.outcome === "committed" && input.transactionId !== null ? input.transactionId : null)
   };
 }
-function withDirectRow(report, plan6, destinations) {
+function withDirectRow(report, direct) {
   return {
-    providers: report.providers.map((row2) => row2.providerId === plan6.providerId ? {
+    providers: report.providers.map((row2) => row2.providerId === "rtk" ? {
       ...row2,
-      available: plan6.target,
+      available: direct.availableVersion,
       channel: "github-release",
-      verdict: "upgradable"
+      verdict: direct.verdict === "current" ? "current" : direct.plan ? "upgradable" : "unavailable"
     } : row2),
     ...report.application === void 0 ? {} : { application: report.application },
-    network: [.../* @__PURE__ */ new Set([...report.network, ...destinations])].sort(),
+    network: [.../* @__PURE__ */ new Set([...report.network, ...direct.destinations])].sort(),
     execution: report.execution
   };
 }
 async function prepareDirectRtkUpdate(context) {
   if (context.adapters === null)
     return null;
-  if (context.platform.os !== "windows" || context.platform.isWsl)
+  if (!["windows", "linux", "macos"].includes(context.platform.os))
     return null;
   if (context.provider !== null && context.provider !== "rtk")
     return null;
+  if (context.adapters.resolveExecutables === void 0)
+    return null;
   const ordinary = await runPackageChannelUpdateCheck(context);
   if (ordinary.data === null)
     return null;
   const row2 = ordinary.data.providers.find((entry) => entry.providerId === "rtk");
   if (row2 === void 0 || row2.installed === null || row2.pin !== null)
     return null;
-  const resolved = context.adapters.resolveExecutables?.("rtk") ?? [];
-  const direct = await planDirectRtkWindowsRelease({
+  const executables = context.adapters.resolveExecutables("rtk");
+  const direct = await planDirectRtkRelease({
     providerId: row2.providerId,
     installedVersion: row2.installed,
-    executablePaths: resolved.map((entry) => entry.path),
+    executables,
     channelAvailableVersion: row2.available,
     platform: context.platform,
     fs: context.adapters.fs,
-    runner: context.adapters.runner
+    runner: context.adapters.runner,
+    ...context.adapters.rtkReleaseFetch === void 0 ? {} : { releaseFetch: context.adapters.rtkReleaseFetch }
   });
-  if (direct.plan === null && direct.diagnostics.length === 0)
+  if (direct.verdict === "defer" || direct.verdict === "unsupported")
     return null;
   return {
     ordinary,
-    report: direct.plan === null ? ordinary.data : withDirectRow(ordinary.data, direct.plan, direct.destinations),
+    report: withDirectRow(ordinary.data, direct),
     plan: direct.plan,
     directDiagnostics: direct.diagnostics
   };
@@ -30328,13 +33014,27 @@ function provenanceDiagnostic(plan6) {
 function result5(exitCode, data, diagnostics) {
   return commandResult({ command: "update", exitCode, data, diagnostics: [...diagnostics] });
 }
+function mergePreparedRtkRow(report, prepared) {
+  if (report === null)
+    return null;
+  const rtk = prepared.providers.find((row2) => row2.providerId === "rtk");
+  if (rtk === void 0)
+    return report;
+  return {
+    ...report,
+    providers: report.providers.some((row2) => row2.providerId === "rtk") ? report.providers.map((row2) => row2.providerId === "rtk" ? rtk : row2) : [...report.providers, rtk],
+    ...report.application === void 0 && prepared.application !== void 0 ? { application: prepared.application } : {},
+    network: [.../* @__PURE__ */ new Set([...report.network, ...prepared.network])].sort()
+  };
+}
 async function runUpdate(context) {
   const prepared = await prepareDirectRtkUpdate(context);
   if (prepared === null)
     return runPackageChannelUpdate(context);
   if (prepared.plan === null) {
     const ordinary = await runPackageChannelUpdate(context);
-    return result5(ordinary.exitCode, ordinary.data, [
+    const report2 = mergePreparedRtkRow(ordinary.data, prepared.report);
+    return result5(ordinary.exitCode, report2, [
       ...ordinary.diagnostics,
       ...prepared.directDiagnostics
     ]);
@@ -30412,7 +33112,7 @@ async function runUpdate(context) {
   let snapshot;
   try {
     snapshot = await snapshotCreation.store.capture(plan6.targetPath);
-  } catch (error) {
+  } catch (error2) {
     return result5(EXIT_CODES["internal-error"], null, [
       ...preparedDiagnostics,
       diagnostic({
@@ -30420,7 +33120,7 @@ async function runUpdate(context) {
         code: "rtk-release-snapshot-failed",
         subject: "rtk",
         path: plan6.targetPath,
-        message: `RTK was not touched because its pre-update snapshot could not be captured: ${error instanceof Error ? error.message : String(error)}`,
+        message: `RTK was not touched because its pre-update snapshot could not be captured: ${error2 instanceof Error ? error2.message : String(error2)}`,
         remediation: "Check the state directory and executable permissions, then retry"
       })
     ]);
@@ -30454,7 +33154,7 @@ async function runUpdate(context) {
   };
   try {
     await journalStore.write(directJournal);
-  } catch (error) {
+  } catch (error2) {
     return result5(EXIT_CODES["internal-error"], null, [
       ...preparedDiagnostics,
       diagnostic({
@@ -30462,7 +33162,7 @@ async function runUpdate(context) {
         code: "rtk-release-journal-failed",
         subject: "rtk",
         path: plan6.targetPath,
-        message: `RTK was not touched because its in-progress transaction journal could not be persisted: ${error instanceof Error ? error.message : String(error)}`,
+        message: `RTK was not touched because its in-progress transaction journal could not be persisted: ${error2 instanceof Error ? error2.message : String(error2)}`,
         remediation: "Check the Token Harness state directory, then retry"
       })
     ]);
@@ -30501,13 +33201,13 @@ async function runUpdate(context) {
       subject: "rtk",
       path: plan6.targetPath,
       message: installed2.message,
-      remediation: installed2.status === "dirty" ? `Recovery backup: ${installed2.backupPath ?? "unavailable"}. Do not retry until the executable path is inspected.` : "Correct the reported release or Windows application-control problem, then retry the update"
+      remediation: installed2.status === "dirty" ? `Recovery backup: ${installed2.backupPath ?? "unavailable"}. Do not retry until the executable path is inspected.` : "Correct the reported release or executable policy problem, then retry the update"
     });
     try {
       await finishDirectJournal(installed2.status === "dirty" ? "dirty" : "rolled-back", "failed", [
         failureDiagnostic
       ]);
-    } catch (error) {
+    } catch (error2) {
       return result5(EXIT_CODES["apply-failed-dirty"], null, [
         ...preparedDiagnostics,
         failureDiagnostic,
@@ -30516,7 +33216,7 @@ async function runUpdate(context) {
           code: "rtk-release-failure-journal-write-failed",
           subject: "rtk",
           path: plan6.targetPath,
-          message: `RTK update failed and its final journal state could not be persisted: ${error instanceof Error ? error.message : String(error)}`,
+          message: `RTK update failed and its final journal state could not be persisted: ${error2 instanceof Error ? error2.message : String(error2)}`,
           remediation: `Inspect transaction ${transactionId2} and its backups before retrying`
         })
       ]);
@@ -30535,7 +33235,7 @@ async function runUpdate(context) {
   }
   try {
     await markDirectAppliedInProgress();
-  } catch (error) {
+  } catch (error2) {
     const rollback = await plan6.runtime.rollback(installed2.handle, context.projectRoot);
     const dirty = rollback.status === "dirty";
     const persistenceDiagnostic = diagnostic({
@@ -30543,7 +33243,7 @@ async function runUpdate(context) {
       code: "rtk-release-applied-journal-write-failed",
       subject: "rtk",
       path: plan6.targetPath,
-      message: `RTK ${plan6.target} was installed but Token Harness could not persist the applied journal state: ${error instanceof Error ? error.message : String(error)}. ${rollback.message}`,
+      message: `RTK ${plan6.target} was installed but Token Harness could not persist the applied journal state: ${error2 instanceof Error ? error2.message : String(error2)}. ${rollback.message}`,
       remediation: `Inspect transaction ${transactionId2} and its backups before retrying`
     });
     try {
@@ -30620,7 +33320,7 @@ async function runUpdate(context) {
   });
   try {
     await finishDirectJournal("committed", "applied", [committedDiagnostic]);
-  } catch (error) {
+  } catch (error2) {
     const rollback = await plan6.runtime.rollback(installed2.handle, context.projectRoot);
     const dirty = rollback.status === "dirty";
     const persistenceDiagnostic = diagnostic({
@@ -30628,7 +33328,7 @@ async function runUpdate(context) {
       code: "rtk-release-commit-journal-write-failed",
       subject: "rtk",
       path: plan6.targetPath,
-      message: `RTK ${plan6.target} was installed but the committed journal could not be persisted: ${error instanceof Error ? error.message : String(error)}. ${rollback.message}`,
+      message: `RTK ${plan6.target} was installed but the committed journal could not be persisted: ${error2 instanceof Error ? error2.message : String(error2)}. ${rollback.message}`,
       remediation: `Inspect transaction ${transactionId2} and its backups before retrying`
     });
     await finishDirectJournal(dirty ? "dirty" : "rolled-back", "failed", [
@@ -30650,7 +33350,7 @@ async function runUpdateCheck(context) {
   if (prepared === null)
     return runPackageChannelUpdateCheck(context);
   if (prepared.plan === null) {
-    return result5(prepared.ordinary.exitCode, prepared.ordinary.data, [
+    return result5(prepared.ordinary.exitCode, prepared.report, [
       ...prepared.ordinary.diagnostics,
       ...prepared.directDiagnostics
     ]);
@@ -30865,7 +33565,8 @@ var init_apply2 = __esm({
 // apps/cli/dist/src/render/benchmark.js
 function receiptLine(label, receipt) {
   const local = receipt.localUsage === null ? "local tokens unknown" : `local ${formatCount(receipt.localUsage.totalTokens)} tokens`;
-  return `${label}: quality ${receipt.outcome.qualityGate}; attempts ${String(receipt.outcome.attempts)}; failed ${String(receipt.outcome.failedAttempts)}; errors ${String(receipt.outcome.errorCodes.length)}; ${local}`;
+  const ccr = receipt.ccrUsage === void 0 || receipt.ccrUsage === null ? "CCR usage not captured" : `CCR ${receipt.ccrUsage.status}, ${formatCount(receipt.ccrUsage.totalTokens)} tokens across ${String(receipt.ccrUsage.requestCount)} requests`;
+  return `${label}: quality ${receipt.outcome.qualityGate}; attempts ${String(receipt.outcome.attempts)}; failed ${String(receipt.outcome.failedAttempts)}; errors ${String(receipt.outcome.errorCodes.length)}; ${local}; ${ccr}`;
 }
 function policyLine(label, receipt) {
   const parts = [
@@ -30893,6 +33594,21 @@ function renderBenchmarkReport(report, _context) {
   } else {
     lines.push(...wrap(`Backend quota (${comparison.quota.scope}, ${comparison.quota.confidence}): baseline +${String(comparison.quota.baselineDeltaUsedPercent)}% vs optimized +${String(comparison.quota.optimizedDeltaUsedPercent)}%`, 0));
   }
+  const ccrUsage = comparison.ccrUsage;
+  if (ccrUsage === void 0 || ccrUsage.status === "not-measured") {
+    lines.push("CCR observed usage: not measured for both variants");
+  } else if (ccrUsage.status === "comparable") {
+    const modelPair = `${ccrUsage.baselineModels.join(", ") || "unknown"} \u2192 ${ccrUsage.optimizedModels.join(", ") || "unknown"}`;
+    lines.push(...wrap(`CCR request usage: ${formatCount(ccrUsage.baselineTokens ?? 0)} \u2192 ${formatCount(ccrUsage.optimizedTokens ?? 0)} tokens; delta ${String(ccrUsage.totalTokenDelta ?? 0)}; models ${modelPair}`, 0));
+    if (ccrUsage.recordedCostDeltaUsd !== null) {
+      lines.push(`CCR recorded provider-cost estimate delta: ${ccrUsage.recordedCostDeltaUsd.toFixed(6)} USD`);
+    }
+    lines.push("CCR request tokens and price estimates remain separate from subscription quota");
+  } else if (ccrUsage.status === "quality-gated") {
+    lines.push("CCR request usage: observed, but delta withheld until both task quality gates pass");
+  } else {
+    lines.push("CCR request usage: partial or ambiguous, not compared");
+  }
   const contextCounts = context.baseline === null || context.optimized === null ? "" : ` \u2014 static MCP tools ${String(context.baseline.effectiveStaticMcpToolCount)} \u2192 ${String(context.optimized.effectiveStaticMcpToolCount)}`;
   lines.push(...wrap(`Context: ${context.verdict}${contextCounts}`, 0));
   lines.push(...wrap(`Context evidence: ${context.reason}`, 2));
@@ -30949,7 +33665,7 @@ function renderBenchmarkStartReport(report, context) {
 }
 function renderBenchmarkFinishReport(report, context) {
   const { receipt } = report;
-  const receiptPath3 = truncatePath(displayPath(report.receiptPath, context.home), MAX_WIDTH - "Receipt: ".length);
+  const receiptPath4 = truncatePath(displayPath(report.receiptPath, context.home), MAX_WIDTH - "Receipt: ".length);
   return document([
     `Benchmark receipt \u2014 ${receipt.benchmarkId} / ${receipt.variant}`,
     `${receipt.taskClass} on ${receipt.harnessId}`,
@@ -30957,7 +33673,7 @@ function renderBenchmarkFinishReport(report, context) {
     ...wrap(`Quality ${receipt.outcome.qualityGate}; attempts ${String(receipt.outcome.attempts)}; failed attempts ${String(receipt.outcome.failedAttempts)}`, 0),
     `Quota windows: ${String(receipt.usageBefore.length)} before / ${String(receipt.usageAfter.length)} after`,
     receipt.localUsage === null ? "Local usage: unavailable or ambiguous" : `Local usage: ${String(receipt.localUsage.totalTokens)} tokens (local evidence only)`,
-    `Receipt: ${receiptPath3}`,
+    `Receipt: ${receiptPath4}`,
     "",
     ...wrap(`After both variants are complete, review the project evidence with: token-harness benchmark-matrix --harness ${receipt.harnessId} --task ${receipt.taskClass}. Use token-harness benchmark --baseline <baseline.json> --optimized <optimized.json> only when you need one specific pair.`, 0)
   ]);
@@ -30998,6 +33714,30 @@ function localLine(summary) {
   }
   return `local tokens across ${String(summary.localComparablePairs)} quality-passed pairs \u2014 baseline ${formatCount(summary.baselineLocalTokens)}, optimized ${formatCount(summary.optimizedLocalTokens)}, delta ${percent2(summary.localTokenSavingPercent)}`;
 }
+function signedCount(value3) {
+  return `${value3 > 0 ? "+" : ""}${formatCount(value3)}`;
+}
+function signedUsd(value3) {
+  return `${value3 > 0 ? "+" : ""}${value3.toFixed(6)}`;
+}
+function ccrUsageLines(summary, indent) {
+  const usage = summary.ccrUsage;
+  if (usage === void 0)
+    return [];
+  const lines = [];
+  if (usage.comparablePairs > 0 && usage.baselineTokens !== null && usage.optimizedTokens !== null && usage.totalTokenDelta !== null) {
+    lines.push(...wrap(`CCR observed tokens across ${String(usage.comparablePairs)} quality-passed pairs \u2014 baseline ${formatCount(usage.baselineTokens)}, optimized ${formatCount(usage.optimizedTokens)}, delta ${signedCount(usage.totalTokenDelta)}`, indent));
+  } else if (usage.partialPairs > 0 || usage.qualityGatedPairs > 0) {
+    lines.push(...wrap(`CCR usage deltas withheld \u2014 partial ${String(usage.partialPairs)}, quality-gated ${String(usage.qualityGatedPairs)}`, indent));
+  }
+  if (usage.recordedCostPairs > 0 && usage.baselineRecordedCostUsd !== null && usage.optimizedRecordedCostUsd !== null && usage.recordedCostDeltaUsd !== null) {
+    lines.push(...wrap(`CCR recorded provider-cost estimate across ${String(usage.recordedCostPairs)} pairs \u2014 baseline ${usage.baselineRecordedCostUsd.toFixed(6)} USD, optimized ${usage.optimizedRecordedCostUsd.toFixed(6)} USD, delta ${signedUsd(usage.recordedCostDeltaUsd)} USD`, indent));
+  }
+  if (usage.comparablePairs > 0 || usage.partialPairs > 0 || usage.qualityGatedPairs > 0) {
+    lines.push(...wrap("CCR usage and cost estimates are separate from subscription quota and billed savings.", indent));
+  }
+  return lines;
+}
 function candidateSummaryLine(summary) {
   return `${String(summary.pairs)} pairs; evidence ${String(summary.evidencePairs)}/${String(summary.pairs)} (${percent2(summary.evidenceCoveragePercent)}); optimized ${String(summary.optimizedBetter)}, baseline ${String(summary.baselineBetter)}, equal ${String(summary.equivalent)}, inconclusive ${String(summary.inconclusive)}, incomparable ${String(summary.incomparable)}`;
 }
@@ -31015,11 +33755,12 @@ function candidateTimingLine(summary) {
 }
 function entryLine(entry) {
   const local = entry.localTokenSavingPercent === null ? "" : `; local delta ${percent2(entry.localTokenSavingPercent)}`;
+  const ccr = entry.ccrUsage?.status === "comparable" && entry.ccrUsage.totalTokenDelta !== null ? `; CCR ${signedCount(entry.ccrUsage.totalTokenDelta)} tokens` : "";
   if (!("context" in entry)) {
-    return `${entry.benchmarkId} \u2014 ${entry.verdict}; ${entry.basis}; ${entry.evidenceLevel}${local}`;
+    return `${entry.benchmarkId} \u2014 ${entry.verdict}; ${entry.basis}; ${entry.evidenceLevel}${local}${ccr}`;
   }
   const contextCounts = entry.context.baseline === null || entry.context.optimized === null ? "" : ` ${String(entry.context.baseline.effectiveStaticMcpToolCount)}\u2192${String(entry.context.optimized.effectiveStaticMcpToolCount)} static tools`;
-  return `${entry.benchmarkId} \u2014 ${entry.verdict}; ${entry.basis}; ${entry.evidenceLevel}${local}; context ${entry.context.verdict}${contextCounts}`;
+  return `${entry.benchmarkId} \u2014 ${entry.verdict}; ${entry.basis}; ${entry.evidenceLevel}${local}${ccr}; context ${entry.context.verdict}${contextCounts}`;
 }
 function renderCampaign(lines, campaign) {
   lines.push("", "Candidate campaign \u2014 experimental");
@@ -31077,6 +33818,7 @@ function renderBenchmarkMatrixReport(report, _context) {
     const local = localLine(summary);
     if (local !== null)
       lines.push(...wrap(local, 4));
+    lines.push(...ccrUsageLines(summary, 4));
   }
   lines.push("", "Overall");
   lines.push(...wrap(summaryLine(report.overall), 2));
@@ -31086,6 +33828,7 @@ function renderBenchmarkMatrixReport(report, _context) {
   const overallLocal = localLine(report.overall);
   if (overallLocal !== null)
     lines.push(...wrap(overallLocal, 2));
+  lines.push(...ccrUsageLines(report.overall, 2));
   if (report.candidateEvidence !== void 0 && report.campaign === void 0) {
     lines.push("", "Candidate evidence \u2014 experimental");
     for (const candidate of report.candidateEvidence) {
@@ -31778,14 +34521,14 @@ function renderMetricsReport(report, _context) {
   if (report.errorBreakdown.length > 0) {
     lines.push("");
     lines.push("Errors by code");
-    for (const error of report.errorBreakdown) {
-      lines.push(...wrap(error.code, 2));
+    for (const error2 of report.errorBreakdown) {
+      lines.push(...wrap(error2.code, 2));
       const scope = [];
-      if (error.providerIds.length > 0)
-        scope.push(`providers ${error.providerIds.join(", ")}`);
-      if (error.harnesses.length > 0)
-        scope.push(`harnesses ${error.harnesses.join(", ")}`);
-      lines.push(...wrap(`${formatCount(error.count)} operation${error.count === 1 ? "" : "s"}` + (scope.length > 0 ? ` - ${scope.join(" - ")}` : ""), 4));
+      if (error2.providerIds.length > 0)
+        scope.push(`providers ${error2.providerIds.join(", ")}`);
+      if (error2.harnesses.length > 0)
+        scope.push(`harnesses ${error2.harnesses.join(", ")}`);
+      lines.push(...wrap(`${formatCount(error2.count)} operation${error2.count === 1 ? "" : "s"}` + (scope.length > 0 ? ` - ${scope.join(" - ")}` : ""), 4));
     }
   }
   return document(lines);
@@ -32128,6 +34871,63 @@ var init_stack_review2 = __esm({
   }
 });
 
+// apps/cli/dist/src/render/smart-routing.js
+function renderSmartRoutingReport(report) {
+  if (report.kind === "ccr-script")
+    return `${report.script}
+`;
+  if (report.kind === "ccr-configuration") {
+    return [
+      `CCR ${report.action}: ${report.state}`,
+      `Harness: ${report.harnessId}`,
+      `Mode: ${report.mode}`,
+      `CCR version: ${report.ccrVersion}`,
+      `Gateway: ${report.gatewayState}`,
+      `Rule: ${report.ruleId}`,
+      `Script: ${report.scriptPath}`,
+      `Management endpoint: ${report.managementEndpoint}`,
+      ...report.profileId === void 0 || report.profileId === null ? [] : [`CCR profile: ${report.profileId}`],
+      ...report.launchCommand === void 0 || report.launchCommand === null ? [] : [`Launch: ${report.launchCommand}`]
+    ].join("\n");
+  }
+  if (report.kind === "ccr-lifecycle") {
+    return [
+      `CCR ${report.action}: ${report.state}`,
+      `Version: ${report.version}`,
+      `Package: ${report.packagePath}`,
+      `CLI: ${report.executablePath}`,
+      `Management endpoint: ${report.managementEndpoint}`
+    ].join("\n");
+  }
+  const { metrics } = report;
+  const harnesses = Object.entries(metrics.byHarness).filter(([, count]) => count > 0).map(([name2, count]) => `${name2} ${String(count)}`).join(", ") || "none";
+  const tiers = Object.entries(metrics.byTier).filter(([, count]) => count > 0).map(([name2, count]) => `${name2} ${String(count)}`).join(", ") || "none";
+  const modes = Object.entries(metrics.byMode).filter(([, count]) => count > 0).map(([name2, count]) => `${name2} ${String(count)}`).join(", ") || "none";
+  const lines = [
+    "Smart Model Routing decisions",
+    `Window: ${report.since} to ${report.until}`,
+    `Retained decisions: ${String(metrics.retainedDecisionCount)}`,
+    `By harness: ${harnesses}`,
+    `By mode: ${modes}`,
+    `By tier: ${tiers}`,
+    `CCR route changes requested: ${String(metrics.routeMutationRequestCount)}`,
+    `Malformed records: ${String(metrics.malformedRecordCount)}`,
+    `Pruned records: ${String(metrics.prunedRecordCount)}`,
+    "Model savings: not measured",
+    `Cleanup: token-harness routing --route-metrics --prune (keeps ${String(metrics.retentionLimit)} newest records)`
+  ];
+  if (report.ccrUsage !== void 0) {
+    const models = report.ccrUsage.byModel.map((item) => item.model).join(", ") || "none";
+    lines.push(`CCR observed requests: ${String(report.ccrUsage.requestCount)} across ${String(report.ccrUsage.observedSessionCount)}/${String(report.ccrUsage.sessionCount)} sessions (${report.ccrUsage.status})`, `CCR reported tokens: ${String(report.ccrUsage.totalTokens)} total, ${String(report.ccrUsage.inputTokens)} input, ${String(report.ccrUsage.outputTokens)} output`, `CCR logged models: ${models}`, `CCR recorded cost: ${report.ccrUsage.recordedCostUsd === null ? "unavailable" : report.ccrUsage.recordedCostUsd.toFixed(6) + " USD (provider estimate)"}`, "CCR usage is observed request telemetry, not subscription quota or measured savings");
+  }
+  return lines.join("\n");
+}
+var init_smart_routing3 = __esm({
+  "apps/cli/dist/src/render/smart-routing.js"() {
+    "use strict";
+  }
+});
+
 // apps/cli/dist/src/render/update.js
 function widthOf(values, floor) {
   return Math.max(floor, ...values.map((value3) => value3.length + 2));
@@ -32668,6 +35468,8 @@ function renderHuman(result6, context) {
         return plain(renderSimpleMcp(data));
       case "metrics":
         return plain(renderSimpleMetrics(data));
+      case "routing":
+        return plain(renderSmartRoutingReport(data));
       case "optimize":
         return plain(renderSimpleOptimize(data));
       case "plan":
@@ -32721,6 +35523,8 @@ function renderHuman(result6, context) {
       return plain(renderVerifyReport(data, context));
     case "metrics":
       return plain(renderMetricsReport(data, context));
+    case "routing":
+      return plain(renderSmartRoutingReport(data));
     case "update":
       return plain(renderUpdateReport(data, context));
     default:
@@ -32744,6 +35548,7 @@ var init_render = __esm({
     init_plan3();
     init_status2();
     init_stack_review2();
+    init_smart_routing3();
     init_update2();
     init_verify2();
     init_simple();
@@ -32791,6 +35596,7 @@ Advanced commands
   apply       Apply a reviewed plan
   verify      Check that configured integrations work
   metrics     Show measured savings
+  routing     Install/configure CCR or inspect routing decisions
   update      Check or update installed providers
   rollback    Restore the previous configuration
   uninstall   Remove only configuration Token Harness owns
@@ -32803,6 +35609,14 @@ Useful flags
   --yes                Confirm a configuration-changing operation
   --harness <id>       Restrict the operation to one harness
   --provider <id>      Restrict the operation to one provider
+  --script             Export a CCR script rule (routing command)
+  --route-metrics      Show local routing decision telemetry
+  --route-mode <mode>  shadow by default; conservative requires opt-in
+  --prune              Keep only the 200 newest routing decision records
+  --configure-ccr      Preview managed CCR setup; --yes applies one step
+  --update-ccr         Preview update of the managed CCR CLI
+  --rollback-ccr       Preview rollback; --yes removes owned rule/profile
+  --ccr-usage          Read CCR model/token aggregates for local sessions
   --project <dir>      Use that project instead of the current directory
   --help               Show help for a command
   --version            Print the version
@@ -33065,6 +35879,36 @@ Figures are never merged across measurement classes or units: tokens are not
 added to characters, and an estimate is not added to an exact figure. A
 counterfactual reduction is reported on its own line and never as a saving.
 Exits 0 whatever the figures say \u2014 an empty report is a fact, not a failure.`,
+      routing: `token-harness routing \u2014 inspect or export Smart Model Routing
+
+Usage
+  token-harness routing --script --harness <claude|codex>
+                        [--route-mode <shadow|conservative>] [--json]
+  token-harness routing --configure-ccr --harness <claude|codex> [--yes]
+  token-harness routing --update-ccr [--yes]
+  token-harness routing --rollback-ccr --harness <claude|codex> [--yes]
+  token-harness routing --route-metrics [--since <duration|date>]
+                        [--until <date>] [--harness <claude|codex>]
+                        [--ccr-usage] [--prune] [--json]
+
+Script export defaults to shadow mode. Add the generated script as a Node.js script rule in CCR;
+it records local, prompt-free decisions and returns no route rewrite in shadow mode. Conservative
+mode is explicit and only proposes a configured simple model for high-confidence, low-risk requests.
+It leaves requests with tool schemas unchanged unless the CCR process explicitly sets
+TOKEN_HARNESS_ROUTING_ALLOW_TOOLS=true. No API call or local model is used to classify.
+
+CCR must run on this machine as the same user for the local telemetry path to be writable. A failed
+telemetry write never blocks the agent request. Decision records contain no prompt or credentials.
+Routing choices are not measured token savings; this command keeps them separate from \`metrics\`.
+Use --prune to remove all but the 200 newest decision records.
+
+When no authenticated local CCR service is present, configure first previews an npm install/start
+of CCR 3.1.1 in Token Harness' protected local state; after approving that step, run configure again
+to preview the routing rule and optional CCR-only CLI profile. A Token Harness-owned service keeps
+its Web RPC token in a private local file; existing services can use CCR_WEB_AUTH_TOKEN and
+optionally CCR_WEB_URL. --update-ccr only updates a Token Harness-owned CLI to the reviewed pin.
+Rollback removes only the exact rule, profile, and script Token Harness owns. CCR usage is observed
+request telemetry, not subscription quota or measured savings.`,
       uninstall: `token-harness uninstall \u2014 remove what Token Harness owns
 
 Usage
@@ -33225,8 +36069,8 @@ function emit(result6, options, renderContext, json) {
   if (json) {
     try {
       options.streams.out(serializeEnvelope(toEnvelope(result6, toolVersion)));
-    } catch (error) {
-      options.streams.err(`internal-error  envelope-serialization-failed: ${error instanceof Error ? error.message : String(error)}
+    } catch (error2) {
+      options.streams.err(`internal-error  envelope-serialization-failed: ${error2 instanceof Error ? error2.message : String(error2)}
 `);
       return EXIT_CODES["internal-error"];
     }
@@ -33345,6 +36189,16 @@ async function run(options) {
     tasksRemaining: invocation.options.tasksLeft,
     contextSnapshotPath: invocation.options.contextSnapshot,
     nativePolicy: invocation.options.nativePolicy,
+    routingScript: invocation.options.routingScript,
+    routingMetrics: invocation.options.routingMetrics,
+    routingMode: invocation.options.routingMode,
+    routingPrune: invocation.options.routingPrune,
+    routingCcrConfigure: invocation.options.routingCcrConfigure,
+    routingCcrRollback: invocation.options.routingCcrRollback,
+    routingCcrUpdate: invocation.options.routingCcrUpdate,
+    routingCcrUsage: invocation.options.routingCcrUsage,
+    env: options.env ?? {},
+    ...options.ccrFetch === void 0 ? {} : { ccrFetch: options.ccrFetch },
     agentSkill: invocation.options.agentSkill,
     since: invocation.options.since,
     until: invocation.options.until,
@@ -33368,7 +36222,7 @@ async function run(options) {
   let result6;
   try {
     result6 = await table[invocation.command](context);
-  } catch (error) {
+  } catch (error2) {
     result6 = commandResult({
       command: invocation.command,
       exitCode: EXIT_CODES["internal-error"],
@@ -33376,7 +36230,7 @@ async function run(options) {
         diagnostic({
           severity: "error",
           code: "internal-error",
-          message: `The command \`${invocation.command}\` failed unexpectedly: ${error instanceof Error ? error.message : String(error)}`,
+          message: `The command \`${invocation.command}\` failed unexpectedly: ${error2 instanceof Error ? error2.message : String(error2)}`,
           remediation: "Report this with the command you ran at https://github.com/giuliastro/TokenHarness/issues"
         })
       ]
@@ -33403,6 +36257,7 @@ var init_run = __esm({
     init_optimize();
     init_plan2();
     init_rollback();
+    init_smart_routing2();
     init_setup2();
     init_status();
     init_stack_review();
@@ -33426,6 +36281,7 @@ var init_run = __esm({
       optimize: runOptimize,
       plan: runPlan,
       rollback: runRollback,
+      routing: runSmartRouting,
       setup: runSetup,
       status: runStatus,
       "stack-review": runStackReview,
@@ -39850,9 +42706,9 @@ function createGuideHandler(input) {
         return;
       }
       send(404, '{"error":"Not found"}');
-    } catch (error) {
-      send(error instanceof GuideError ? error.status : 500, JSON.stringify({
-        error: error instanceof GuideError ? error.message : "The operation could not finish. No automatic retry was made. Refresh and check the current state."
+    } catch (error2) {
+      send(error2 instanceof GuideError ? error2.status : 500, JSON.stringify({
+        error: error2 instanceof GuideError ? error2.message : "The operation could not finish. No automatic retry was made. Refresh and check the current state."
       }));
     }
   };
@@ -39879,7 +42735,7 @@ var init_guided_http = __esm({
 });
 
 // apps/cli/dist/src/commands/rtk-hook-proxy.js
-function isRecord5(value3) {
+function isRecord7(value3) {
   return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
 }
 function shellQuote(value3) {
@@ -39891,7 +42747,7 @@ function powershellQuote(value3) {
 function toolNameFromInput(input, harness) {
   try {
     const parsed = JSON.parse(input);
-    if (!isRecord5(parsed))
+    if (!isRecord7(parsed))
       return null;
     const name2 = parsed["tool_name"] ?? parsed["toolName"];
     if (typeof name2 === "string")
@@ -39919,13 +42775,13 @@ function attributeRtkHookResponse(stdout, input, databasePath, harness) {
   } catch {
     return stdout;
   }
-  if (!isRecord5(response))
+  if (!isRecord7(response))
     return stdout;
   const hookOutput = response["hookSpecificOutput"];
-  if (!isRecord5(hookOutput))
+  if (!isRecord7(hookOutput))
     return stdout;
   const updatedInput = hookOutput["updatedInput"];
-  if (!isRecord5(updatedInput) || typeof updatedInput["command"] !== "string")
+  if (!isRecord7(updatedInput) || typeof updatedInput["command"] !== "string")
     return stdout;
   const attributed = withDatabaseEnvironment(updatedInput["command"], databasePath, toolNameFromInput(input, harness));
   if (attributed === null)
@@ -39977,7 +42833,7 @@ __export(main_exports, {
 });
 import process5 from "node:process";
 import { createServer } from "node:http";
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { randomBytes as randomBytes3 } from "node:crypto";
 async function runAsDatabaseReader(argv2) {
   if (argv2[0] !== SQLITE_CHILD_FLAG)
     return false;
@@ -40190,8 +43046,8 @@ async function runUi(options, baseOptions) {
   let initial;
   try {
     initial = await collectDashboard(baseOptions);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     if (options.json) {
       process5.stdout.write(serializeEnvelope(toEnvelope(commandResult({
         command: "ui",
@@ -40265,8 +43121,8 @@ async function runUi(options, baseOptions) {
       server.once("error", reject);
       server.listen(options.port, "127.0.0.1", () => resolve());
     });
-  } catch (error) {
-    process5.stderr.write(`Token Harness dashboard could not listen locally: ${error instanceof Error ? error.message : String(error)}
+  } catch (error2) {
+    process5.stderr.write(`Token Harness dashboard could not listen locally: ${error2 instanceof Error ? error2.message : String(error2)}
 `);
     return EXIT_CODES["internal-error"];
   }
@@ -40293,7 +43149,7 @@ async function runGuidedUi(options, base) {
     }
     return result6;
   };
-  const service = new GuideService(guideCall, () => Date.now(), () => randomBytes2(32).toString("hex"), async (harness) => {
+  const service = new GuideService(guideCall, () => Date.now(), () => randomBytes3(32).toString("hex"), async (harness) => {
     if (base.adapters === null || base.adapters === void 0) {
       return {
         state: "unavailable",
@@ -40308,7 +43164,7 @@ async function runGuidedUi(options, base) {
       harness
     });
   });
-  const token = randomBytes2(32).toString("hex");
+  const token = randomBytes3(32).toString("hex");
   let authority = "";
   const server = createServer(createGuideHandler({
     service,