token-harness 0.1.23 → 0.1.24

package/token-harness.mjs

@@ -759,6 +759,27 @@ function parseBoundaryPolicy(value3) {
     return void 0;
   return { model, reasoningEffort, verbosity, verification: "config-only" };
 }
+function parseNativeRoutingObservation(value3) {
+  if (value3 === null)
+    return null;
+  const row2 = record(value3);
+  if (row2 === null)
+    return void 0;
+  const configured = row2["configured"];
+  const promptSubmissions = row2["promptSubmissions"];
+  const subagentsStarted = row2["subagentsStarted"];
+  const subagentsStopped = row2["subagentsStopped"];
+  const reportedModels = row2["reportedModels"];
+  if (!(configured === null || typeof configured === "boolean") || !Number.isSafeInteger(promptSubmissions) || typeof promptSubmissions !== "number" || promptSubmissions < 0 || !Number.isSafeInteger(subagentsStarted) || typeof subagentsStarted !== "number" || subagentsStarted < 0 || !Number.isSafeInteger(subagentsStopped) || typeof subagentsStopped !== "number" || subagentsStopped < 0 || !Array.isArray(reportedModels) || !reportedModels.every((model) => typeof model === "string" && model.length <= 80))
+    return void 0;
+  return {
+    configured,
+    promptSubmissions,
+    subagentsStarted,
+    subagentsStopped,
+    reportedModels: [...new Set(reportedModels)]
+  };
+}
 function parseTaskBenchmarkCapture(value3) {
   const row2 = record(value3);
   if (row2 === null) {
@@ -785,7 +806,9 @@ function parseTaskBenchmarkCapture(value3) {
   const localSessionsBefore = parsedLocalSessions === void 0 ? null : parsedLocalSessions;
   const hasContextAtStart = Object.hasOwn(row2, "contextAtStart");
   const contextAtStart = hasContextAtStart ? parseTaskBenchmarkContextSnapshot(row2["contextAtStart"]) : void 0;
-  if (typeof benchmarkId !== "string" || !isTaskBenchmarkId(benchmarkId) || typeof variant !== "string" || !isTaskBenchmarkVariant(variant) || typeof taskClass !== "string" || !isTaskClass(taskClass) || typeof harnessId2 !== "string" || !isHarnessId(harnessId2) || typeof projectId !== "string" || projectId === "" || model === void 0 || reasoningEffort === void 0 || verbosity === void 0 || !validInstant(startedAt) || usageBefore === null || parsedLocalSessions === void 0 || hasContextAtStart && contextAtStart === void 0) {
+  const hasNativeRoutingAtStart = Object.hasOwn(row2, "nativeRoutingAtStart");
+  const nativeRoutingAtStart = hasNativeRoutingAtStart ? parseNativeRoutingObservation(row2["nativeRoutingAtStart"]) : void 0;
+  if (typeof benchmarkId !== "string" || !isTaskBenchmarkId(benchmarkId) || typeof variant !== "string" || !isTaskBenchmarkVariant(variant) || typeof taskClass !== "string" || !isTaskClass(taskClass) || typeof harnessId2 !== "string" || !isHarnessId(harnessId2) || typeof projectId !== "string" || projectId === "" || model === void 0 || reasoningEffort === void 0 || verbosity === void 0 || !validInstant(startedAt) || usageBefore === null || parsedLocalSessions === void 0 || hasContextAtStart && contextAtStart === void 0 || hasNativeRoutingAtStart && nativeRoutingAtStart === void 0) {
     return {
       ok: false,
       reason: "invalid-shape",
@@ -807,6 +830,7 @@ function parseTaskBenchmarkCapture(value3) {
       startedAt,
       usageBefore,
       ...hasContextAtStart ? { contextAtStart: contextAtStart ?? null } : {},
+      ...hasNativeRoutingAtStart ? { nativeRoutingAtStart: nativeRoutingAtStart ?? null } : {},
       localSessionsBefore
     }
   };
@@ -842,7 +866,11 @@ 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 hasNativeRoutingAtStart = Object.hasOwn(row2, "nativeRoutingAtStart");
+  const nativeRoutingAtStart = hasNativeRoutingAtStart ? parseNativeRoutingObservation(row2["nativeRoutingAtStart"]) : void 0;
+  const hasNativeRoutingAtFinish = Object.hasOwn(row2, "nativeRoutingAtFinish");
+  const nativeRoutingAtFinish = hasNativeRoutingAtFinish ? parseNativeRoutingObservation(row2["nativeRoutingAtFinish"]) : 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 || hasNativeRoutingAtStart && nativeRoutingAtStart === void 0 || hasNativeRoutingAtFinish && nativeRoutingAtFinish === void 0) {
     return {
       ok: false,
       reason: "invalid-shape",
@@ -868,7 +896,9 @@ function parseTaskBenchmarkReceipt(value3) {
       outcome: outcome2,
       ...hasContextAtStart ? { contextAtStart: contextAtStart ?? null } : {},
       ...hasContextAtFinish ? { contextAtFinish: contextAtFinish ?? null } : {},
-      ...hasBoundaryPolicy ? { policyAtFinish: policyAtFinish ?? null } : {}
+      ...hasBoundaryPolicy ? { policyAtFinish: policyAtFinish ?? null } : {},
+      ...hasNativeRoutingAtStart ? { nativeRoutingAtStart: nativeRoutingAtStart ?? null } : {},
+      ...hasNativeRoutingAtFinish ? { nativeRoutingAtFinish: nativeRoutingAtFinish ?? null } : {}
     }
   };
 }
@@ -888,7 +918,9 @@ function completeTaskBenchmarkCapture(capture, input) {
     usageAfter: input.usageAfter,
     localUsage: input.localUsage ?? null,
     ...capture.contextAtStart !== void 0 ? { contextAtStart: capture.contextAtStart } : {},
+    ...capture.nativeRoutingAtStart !== void 0 ? { nativeRoutingAtStart: capture.nativeRoutingAtStart } : {},
     ...input.contextAtFinish !== void 0 ? { contextAtFinish: input.contextAtFinish } : {},
+    ...input.nativeRoutingAtFinish !== void 0 ? { nativeRoutingAtFinish: input.nativeRoutingAtFinish } : {},
     ...input.policyAtFinish !== void 0 ? { policyAtFinish: input.policyAtFinish } : {},
     outcome: {
       qualityGate: input.qualityGate,
@@ -1096,7 +1128,8 @@ function buildTaskBenchmarkMatrix(pairs, selection = {
       baselineLocalTokens,
       optimizedLocalTokens,
       localTokenSavingPercent: !bothQualityPassed || baselineLocalTokens === null || optimizedLocalTokens === null ? null : roundedPercent(baselineLocalTokens - optimizedLocalTokens, baselineLocalTokens),
-      quota: comparison.quota
+      quota: comparison.quota,
+      ...nativeRoutingComparison(baseline, optimized)
     };
   }).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) => ({
@@ -1110,6 +1143,36 @@ function buildTaskBenchmarkMatrix(pairs, selection = {
     selection
   };
 }
+function nativeRoutingComparison(baseline, optimized) {
+  const bStart = baseline.nativeRoutingAtStart;
+  const bFinish = baseline.nativeRoutingAtFinish;
+  const oStart = optimized.nativeRoutingAtStart;
+  const oFinish = optimized.nativeRoutingAtFinish;
+  if (bStart === void 0 && bFinish === void 0 && oStart === void 0 && oFinish === void 0)
+    return {};
+  const qualityGatesPassed = baseline.outcome.qualityGate === "passed" && optimized.outcome.qualityGate === "passed";
+  if (bStart == null || bFinish == null || oStart == null || oFinish == null || bStart.configured === null || oStart.configured === null) {
+    return {
+      nativeRouting: {
+        verdict: "unknown",
+        baselineSubagents: bFinish?.subagentsStarted ?? null,
+        optimizedSubagents: oFinish?.subagentsStarted ?? null,
+        optimizedReportedModels: oFinish?.reportedModels ?? [],
+        qualityGatesPassed
+      }
+    };
+  }
+  const attributed = bStart.configured === false && bFinish.configured === false && bFinish.subagentsStarted === 0 && oStart.configured === true && oFinish.configured === true && oFinish.promptSubmissions > 0 && oFinish.subagentsStarted > 0;
+  return {
+    nativeRouting: {
+      verdict: attributed ? "attributed" : "not-attributed",
+      baselineSubagents: bFinish.subagentsStarted,
+      optimizedSubagents: oFinish.subagentsStarted,
+      optimizedReportedModels: [...oFinish.reportedModels],
+      qualityGatesPassed
+    }
+  };
+}
 var TASK_BENCHMARK_RECEIPT_SCHEMA_VERSION, TASK_BENCHMARK_CAPTURE_SCHEMA_VERSION, BENCHMARK_ID, WINDOW_SCOPES, WINDOW_SOURCES, WINDOW_CONFIDENCES, WINDOW_KINDS, QUOTA_SCOPE_PRIORITY, TASK_CLASS_ORDER;
 var init_benchmark = __esm({
   "packages/core/dist/src/domain/benchmark.js"() {
@@ -4144,11 +4207,19 @@ function findCompatibilityRule(rules, query) {
     candidates.push(rule);
   }
   if (query.observedVersions !== void 0) {
-    const matchesObservedTuple = (rule) => Object.entries(rule.testedVersions).every(([provider, version3]) => query.observedVersions?.[provider] === version3) && Object.entries(rule.testedHarnessVersions ?? {}).every(([harness, version3]) => query.observedHarnessVersions?.[harness] === version3);
+    const matchesObservedTuple = (rule) => {
+      if (rule.providers.some((provider) => rule.testedVersions[provider] === void 0)) {
+        return false;
+      }
+      const testedHarnessVersion = rule.testedHarnessVersions?.[query.harness];
+      if (rule.outcome === "ordered" && testedHarnessVersion === void 0)
+        return false;
+      return Object.entries(rule.testedVersions).every(([provider, version3]) => query.observedVersions?.[provider] === version3) && (testedHarnessVersion === void 0 || query.observedHarnessVersions?.[query.harness] === testedHarnessVersion);
+    };
     const exact = candidates.find(matchesObservedTuple);
     if (exact !== void 0)
       return exact;
-    const matchingDimensions = (rule) => Object.entries(rule.testedVersions).filter(([provider, version3]) => query.observedVersions?.[provider] === version3).length + Object.entries(rule.testedHarnessVersions ?? {}).filter(([harness, version3]) => query.observedHarnessVersions?.[harness] === version3).length;
+    const matchingDimensions = (rule) => Object.entries(rule.testedVersions).filter(([provider, version3]) => query.observedVersions?.[provider] === version3).length + (rule.testedHarnessVersions?.[query.harness] !== void 0 && query.observedHarnessVersions?.[query.harness] === rule.testedHarnessVersions[query.harness] ? 1 : 0);
     candidates.sort((left, right) => matchingDimensions(right) - matchingDimensions(left));
   }
   return candidates[0] ?? null;
@@ -4160,26 +4231,24 @@ function coversVersion(recorded, observed) {
 }
 function staleRecordedVersions(rule, observed) {
   const stale2 = [];
-  for (const [provider, recorded] of Object.entries(rule.testedVersions)) {
+  for (const provider of rule.providers) {
+    const recorded = rule.testedVersions[provider];
     const seen = observed[provider] ?? null;
-    const recordedVersion = parseSemanticVersion(recorded);
+    const recordedVersion = recorded === void 0 ? null : parseSemanticVersion(recorded);
     const seenVersion = seen === null ? null : parseSemanticVersion(seen);
     if (recordedVersion !== null && seenVersion !== null && coversVersion(recordedVersion, seenVersion)) {
       continue;
     }
-    stale2.push({ provider, recorded, observed: seen });
+    stale2.push({ provider, recorded: recorded ?? null, observed: seen });
   }
   return stale2;
 }
-function staleRecordedHarnessVersions(rule, observed) {
-  const stale2 = [];
-  for (const [harness, recorded] of Object.entries(rule.testedHarnessVersions ?? {})) {
-    const seen = observed[harness] ?? null;
-    if (seen === recorded)
-      continue;
-    stale2.push({ harness, recorded, observed: seen });
-  }
-  return stale2;
+function staleRecordedHarnessVersions(rule, observed, harness) {
+  const recorded = rule.testedHarnessVersions?.[harness];
+  if (recorded === void 0 && rule.outcome !== "ordered")
+    return [];
+  const seen = observed[harness] ?? null;
+  return recorded !== void 0 && seen === recorded ? [] : [{ harness, recorded: recorded ?? null, observed: seen }];
 }
 var init_compatibility = __esm({
   "packages/core/dist/src/domain/compatibility.js"() {
@@ -4808,7 +4877,7 @@ function narrowChannelOverlaps(context) {
       ...input.observedHarnessVersions === void 0 ? {} : { observedHarnessVersions: input.observedHarnessVersions }
     });
     const staleProviders = found === null ? [] : staleRecordedVersions(found, input.observedVersions);
-    const staleHarnesses = found === null ? [] : staleRecordedHarnessVersions(found, input.observedHarnessVersions ?? {});
+    const staleHarnesses = found === null ? [] : staleRecordedHarnessVersions(found, input.observedHarnessVersions ?? {}, harness);
     const stale2 = [...staleProviders, ...staleHarnesses];
     const rule = stale2.length > 0 ? null : found;
     if (found !== null && stale2.length > 0) {
@@ -4819,8 +4888,8 @@ function narrowChannelOverlaps(context) {
         detail: [
           `${owners.join(" and ")} both use ${capability} on ${harness}/${toolFamily} at different interception points`,
           `Rule ${found.id} was tested at ${[
-            ...staleProviders.map((entry) => `${entry.provider} ${entry.recorded}`),
-            ...staleHarnesses.map((entry) => `${entry.harness} ${entry.recorded}`)
+            ...staleProviders.map((entry) => `${entry.provider} ${entry.recorded ?? "not recorded"}`),
+            ...staleHarnesses.map((entry) => `${entry.harness} ${entry.recorded ?? "not recorded"}`)
           ].join(", ")}`,
           `Installed now: ${[
             ...staleProviders.map((entry) => `${entry.provider} ${entry.observed ?? "unknown"}`),
@@ -4921,7 +4990,9 @@ function resolveContested(context) {
     ...input.observedHarnessVersions === void 0 ? {} : { observedHarnessVersions: input.observedHarnessVersions }
   });
   const stale2 = found === null ? [] : staleRecordedVersions(found, input.observedVersions);
-  const rule = stale2.length > 0 ? null : found;
+  const staleHarnesses = found === null ? [] : staleRecordedHarnessVersions(found, input.observedHarnessVersions ?? {}, scope.harness);
+  const staleAll = [...stale2, ...staleHarnesses];
+  const rule = staleAll.length > 0 ? null : found;
   if (rule === null) {
     if (found !== null) {
       conflicts.push({
@@ -4930,11 +5001,17 @@ function resolveContested(context) {
         claimants,
         detail: [
           `${claimants.join(" and ")} both claim ${capability} on ${formatCapabilityScope(scope)}`,
-          `Rule ${found.id} was tested at ${stale2.map((entry) => `${entry.provider} ${entry.recorded}`).join(", ")}`,
-          `Installed now: ${stale2.map((entry) => `${entry.provider} ${entry.observed ?? "unknown"}`).join(", ")}`,
+          `Rule ${found.id} was tested at ${[
+            ...stale2.map((entry) => `${entry.provider} ${entry.recorded ?? "not recorded"}`),
+            ...staleHarnesses.map((entry) => `${entry.harness} ${entry.recorded ?? "not recorded"}`)
+          ].join(", ")}`,
+          `Installed now: ${[
+            ...stale2.map((entry) => `${entry.provider} ${entry.observed ?? "unknown"}`),
+            ...staleHarnesses.map((entry) => `${entry.harness} ${entry.observed ?? "unknown"}`)
+          ].join(", ")}`,
           "A compatibility result covers the versions it records, so this one is withdrawn rather than applied outside them"
         ],
-        remediation: `Re-test ${found.id} against the installed versions and update its \`testedVersions\`, or assign the scope explicitly with \`profile: custom\``
+        remediation: `Re-test ${found.id} against the installed provider and harness versions, record the evidence for ${scope.harness}, or assign the scope explicitly with \`profile: custom\``
       });
       return;
     }
@@ -9784,7 +9861,7 @@ var TOOL_VERSION;
 var init_version2 = __esm({
   "apps/cli/dist/src/version.js"() {
     "use strict";
-    TOOL_VERSION = "0.1.23";
+    TOOL_VERSION = "0.1.24";
   }
 });
 
@@ -14677,7 +14754,10 @@ var init_claude = __esm({
       versionCommand: { executable: "claude", args: ["--version"] },
       interceptionPoints: [
         { scopeId: "pre-tool-use", eventName: "PreToolUse" },
-        { scopeId: "post-tool-use", eventName: "PostToolUse" }
+        { scopeId: "post-tool-use", eventName: "PostToolUse" },
+        { scopeId: "user-prompt-submit", eventName: "UserPromptSubmit" },
+        { scopeId: "subagent-start", eventName: "SubagentStart" },
+        { scopeId: "subagent-stop", eventName: "SubagentStop" }
       ],
       configFiles: [
         {
@@ -14686,7 +14766,13 @@ var init_claude = __esm({
           parser: "json",
           primary: true,
           interceptionFormat: "hooks-event-command-list",
-          interceptionPoints: ["pre-tool-use", "post-tool-use"]
+          interceptionPoints: [
+            "pre-tool-use",
+            "post-tool-use",
+            "user-prompt-submit",
+            "subagent-start",
+            "subagent-stop"
+          ]
         },
         { path: ".claude/settings.json", scope: "project", parser: "json", primary: false },
         { path: ".claude/settings.local.json", scope: "project", parser: "json", primary: false }
@@ -15854,7 +15940,10 @@ var init_codex = __esm({
        */
       interceptionPoints: [
         { scopeId: "pre-tool-use", eventName: "PreToolUse" },
-        { scopeId: "post-tool-use", eventName: "PostToolUse" }
+        { scopeId: "post-tool-use", eventName: "PostToolUse" },
+        { scopeId: "user-prompt-submit", eventName: "UserPromptSubmit" },
+        { scopeId: "subagent-start", eventName: "SubagentStart" },
+        { scopeId: "subagent-stop", eventName: "SubagentStop" }
       ],
       configFiles: [
         { path: ".codex/config.toml", scope: "user", parser: "toml", primary: true },
@@ -15864,7 +15953,13 @@ var init_codex = __esm({
           parser: "json",
           primary: false,
           interceptionFormat: "hooks-event-command-list",
-          interceptionPoints: ["pre-tool-use", "post-tool-use"]
+          interceptionPoints: [
+            "pre-tool-use",
+            "post-tool-use",
+            "user-prompt-submit",
+            "subagent-start",
+            "subagent-stop"
+          ]
         }
       ],
       toolFamilies: [
@@ -16632,10 +16727,49 @@ var init_pi = __esm({
   }
 });
 
+// packages/adapters/dist/src/harnesses/native-prompt-routing.js
+function nativePromptRoutingHookEntries(harness, executable = "token-harness") {
+  return NATIVE_PROMPT_ROUTING_EVENTS.map(({ eventName, commandEvent }) => {
+    if (harness === "codex") {
+      const command = `${executable} __internal-prompt-router codex ${commandEvent}`;
+      const handler2 = {
+        type: "command",
+        command,
+        commandWindows: command,
+        timeout: 10
+      };
+      if (commandEvent === "prompt-submit")
+        handler2["additionalContextLimit"] = 500;
+      return { eventName, value: { hooks: [handler2] } };
+    }
+    const handler = {
+      type: "command",
+      command: executable,
+      args: ["__internal-prompt-router", "claude", commandEvent],
+      timeout: 10
+    };
+    return { eventName, value: { hooks: [handler] } };
+  });
+}
+var NATIVE_PROMPT_ROUTING_EVENTS;
+var init_native_prompt_routing = __esm({
+  "packages/adapters/dist/src/harnesses/native-prompt-routing.js"() {
+    "use strict";
+    NATIVE_PROMPT_ROUTING_EVENTS = [
+      { eventName: "UserPromptSubmit", commandEvent: "prompt-submit" },
+      { eventName: "SubagentStart", commandEvent: "subagent-start" },
+      { eventName: "SubagentStop", commandEvent: "subagent-stop" }
+    ];
+  }
+});
+
 // packages/adapters/dist/src/harnesses/index.js
 function listHarnessAdapters() {
   return HARNESS_ADAPTERS;
 }
+function findHarnessAdapter(id) {
+  return HARNESS_ADAPTERS.find((adapter) => adapter.manifest.id === id) ?? null;
+}
 var HARNESS_ADAPTERS;
 var init_harnesses = __esm({
   "packages/adapters/dist/src/harnesses/index.js"() {
@@ -16653,6 +16787,7 @@ var init_harnesses = __esm({
     init_opencode();
     init_pi();
     init_claude();
+    init_native_prompt_routing();
     HARNESS_ADAPTERS = [
       claudeAdapter,
       codexAdapter,
@@ -17702,11 +17837,11 @@ async function plan(context, request) {
       }));
       continue;
     }
-    const actionId = `harnesstrim-${harness.id}-hook-${digestText(target.configPath).slice(7, 15)}`;
+    const actionId2 = `harnesstrim-${harness.id}-hook-${digestText(target.configPath).slice(7, 15)}`;
     actions.push(appendCommandHookAction({
       target,
       providerId: HARNESSTRIM2,
-      actionId,
+      actionId: actionId2,
       command,
       explanation: `Register HarnessTrim after ${harness.displayName} Bash commands and record reductions in ${metricsPath}${codexActivationNote(harness.id)}`
     }));
@@ -22453,6 +22588,8 @@ function parseArgv(argv2, plannedCommands = PLANNED_COMMANDS) {
     contextSnapshot: null,
     nativePolicy: false,
     agentSkill: false,
+    agentRouting: false,
+    disableAgentRouting: false,
     verbose: false,
     yes: false
   };
@@ -22491,6 +22628,10 @@ function parseArgv(argv2, plannedCommands = PLANNED_COMMANDS) {
         options.nativePolicy = true;
       if (name2 === "--agent-skill")
         options.agentSkill = true;
+      if (name2 === "--agent-routing")
+        options.agentRouting = true;
+      if (name2 === "--disable-agent-routing")
+        options.disableAgentRouting = true;
       if (name2 === "--verbose")
         options.verbose = true;
       continue;
@@ -22727,6 +22868,14 @@ function parseArgv(argv2, plannedCommands = PLANNED_COMMANDS) {
     }));
     return usageError(json, diagnostics);
   }
+  if (options.agentRouting && options.disableAgentRouting) {
+    diagnostics.push(diagnostic({
+      severity: "error",
+      code: "conflicting-prompt-routing-flags",
+      message: "--agent-routing and --disable-agent-routing cannot be used together",
+      remediation: "Choose one prompt-routing state to plan"
+    }));
+  }
   if (!isAvailableCommand(command)) {
     const planned = plannedCommands.includes(command);
     diagnostics.push(planned ? diagnostic({
@@ -22796,7 +22945,557 @@ var init_argv = __esm({
       "--tasks-left",
       "--context-snapshot"
     ]);
-    BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json", "--native-policy", "--agent-skill", "--verbose", "--yes"]);
+    BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+      "--json",
+      "--native-policy",
+      "--agent-skill",
+      "--agent-routing",
+      "--disable-agent-routing",
+      "--verbose",
+      "--yes"
+    ]);
+  }
+});
+
+// apps/cli/dist/src/prompt-router.js
+function isHarness(value3) {
+  return value3 === "claude" || value3 === "codex";
+}
+function expectedVersions(harness) {
+  return harness === "codex" ? ["0.159.0", "0.160.0"] : ["2.1.274", "2.1.288"];
+}
+function configTarget(input) {
+  if (!isHarness(input.harness) || input.home === null)
+    return null;
+  const adapter = findHarnessAdapter(harnessId(input.harness));
+  const declaration = adapter?.manifest.configFiles.find((file) => file.scope === "user" && file.parser === "json" && file.interceptionPoints?.includes("user-prompt-submit") === true);
+  if (declaration === void 0 || adapter === null)
+    return null;
+  const fileContext = {
+    fs: input.fs,
+    runner: input.runner,
+    facts: input.facts,
+    paths: { ...input.paths, home: input.home },
+    projectRoot: input.projectRoot
+  };
+  return {
+    harness: input.harness,
+    path: resolveConfigPath(declaration, fileContext),
+    version: input.version,
+    fileContext
+  };
+}
+function hookEntries(harness) {
+  return nativePromptRoutingHookEntries(harnessId(harness), "token-harness");
+}
+function asRecord(value3) {
+  return typeof value3 === "object" && value3 !== null && !Array.isArray(value3) ? value3 : null;
+}
+function parseHookDocument(text3) {
+  let decoded;
+  try {
+    decoded = JSON.parse(text3);
+  } catch {
+    return { ok: false, reason: "The hook settings file is malformed JSON or contains comments." };
+  }
+  const root = asRecord(decoded);
+  if (root === null)
+    return { ok: false, reason: "The hook settings root must be a JSON object." };
+  const hooksValue = root["hooks"];
+  if (hooksValue === void 0)
+    return { ok: true, hooks: {} };
+  const hooks = asRecord(hooksValue);
+  if (hooks === null)
+    return { ok: false, reason: "The settings hooks property must be an object." };
+  for (const { eventName } of hookEntries("codex")) {
+    const entries = hooks[eventName];
+    if (entries !== void 0 && !Array.isArray(entries))
+      return { ok: false, reason: `The ${eventName} hook property must be an array.` };
+  }
+  return { ok: true, hooks };
+}
+function containsRouterCommand(value3, harness) {
+  const row2 = asRecord(value3);
+  const hooks = row2?.["hooks"];
+  if (!Array.isArray(hooks))
+    return false;
+  return hooks.some((hook) => {
+    const handler = asRecord(hook);
+    if (handler === null)
+      return false;
+    if (harness === "codex")
+      return [handler["command"], handler["commandWindows"]].some((command) => typeof command === "string" && command.includes(ROUTE_MARKER));
+    const args = handler["args"];
+    return handler["command"] === "token-harness" && Array.isArray(args) && args[0] === ROUTE_MARKER;
+  });
+}
+function configHasExactRouter(hooks, harness) {
+  let exactCount = 0;
+  let routeCount = 0;
+  for (const expected of hookEntries(harness)) {
+    const live = hooks[expected.eventName];
+    const entries = Array.isArray(live) ? live : [];
+    const routeEntries = entries.filter((entry) => containsRouterCommand(entry, harness));
+    routeCount += routeEntries.length;
+    if (routeEntries.some((entry) => jsonValueDigest(entry) === jsonValueDigest(expected.value)))
+      exactCount += 1;
+  }
+  return {
+    complete: exactCount === hookEntries(harness).length,
+    partial: routeCount > 0 && exactCount !== hookEntries(harness).length,
+    conflict: routeCount > exactCount
+  };
+}
+function routerOwnedArtifacts(journals, path, harness) {
+  const expected = hookEntries(harness);
+  for (const journal of journals) {
+    const disabledHere = journal.entries.some((entry) => entry.actionId.startsWith(`native-prompt-routing:${harness}:disable:`) && entry.snapshots.some((snapshot) => snapshot.path === path));
+    if (disabledHere && journal.outcome === "committed")
+      return [];
+    const relevant = journal.ownership.filter((artifact) => artifact.kind === "owned-json-entry" && artifact.path === path && artifact.placement === "array-element" && expected.some((entry) => artifact.pointer === `hooks.${entry.eventName}` && artifact.valueDigest === jsonValueDigest(entry.value)));
+    if (relevant.length > 0)
+      return journal.outcome === "committed" ? relevant : [];
+  }
+  return [];
+}
+async function journalsFor(input) {
+  if (input.stateRoot === null)
+    return [];
+  const journalRoot = input.fs.join(input.stateRoot, "journals");
+  if ((await input.fs.stat(journalRoot))?.kind !== "directory")
+    return [];
+  return new FileJournalStore({
+    fs: input.fs,
+    journalRoot,
+    backupRoot: input.fs.join(input.stateRoot, "backups")
+  }).list();
+}
+function actionId(harness, intent, eventName) {
+  return `native-prompt-routing:${harness}:${intent}:${eventName}`;
+}
+async function planNativePromptRoutingInstall(input) {
+  const diagnostics = [];
+  const target = configTarget(input);
+  if (target === null) {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "prompt-routing-target-unavailable",
+      subject: input.harness,
+      message: "No supported user-scope native prompt hook target is available",
+      remediation: "Resolve the user home and harness installation, then refresh Token Harness"
+    }));
+    return { target: null, actions: [], diagnostics };
+  }
+  if (!expectedVersions(target.harness).includes(target.version ?? "")) {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "prompt-routing-version-unverified",
+      subject: target.harness,
+      message: `Native prompt routing has no hook fixture for ${target.harness} ${target.version ?? "unknown"}`,
+      path: target.path,
+      remediation: "Refresh Token Harness after the installed harness hook schema is fixture-tested"
+    }));
+    return { target: target.path, actions: [], diagnostics };
+  }
+  const runtimeCheck = await input.runner.run({
+    executable: "token-harness",
+    args: ["__internal-prompt-router", target.harness, "--check"],
+    cwd: input.projectRoot,
+    timeoutMs: 3e3,
+    maxOutputBytes: 256
+  });
+  if (runtimeCheck.failure !== null || runtimeCheck.exitCode !== 0 || runtimeCheck.stdout.trim() !== PROMPT_ROUTER_CHECK_MARKER) {
+    diagnostics.push(diagnostic({
+      severity: "error",
+      code: "prompt-routing-runtime-unavailable",
+      subject: target.harness,
+      message: "The Token Harness executable found on PATH cannot serve the native prompt hook",
+      path: target.path,
+      remediation: "Install or update Token Harness so the same executable is available to the coding agent, then refresh and plan again"
+    }));
+    return { target: target.path, actions: [], diagnostics };
+  }
+  const stat3 = await input.fs.stat(target.path);
+  if (stat3 !== null && stat3.kind !== "file") {
+    diagnostics.push(diagnostic({
+      severity: "error",
+      code: "prompt-routing-target-not-file",
+      subject: target.harness,
+      message: "A non-file occupies the native hook settings path",
+      path: target.path,
+      remediation: "Move the conflicting path and refresh Token Harness"
+    }));
+    return { target: target.path, actions: [], diagnostics };
+  }
+  let hooks = {};
+  if (stat3 !== null) {
+    const parsed = parseHookDocument(DECODER4.decode(await input.fs.readFile(target.path)));
+    if (!parsed.ok) {
+      diagnostics.push(diagnostic({
+        severity: "error",
+        code: "prompt-routing-settings-unmergeable",
+        subject: target.harness,
+        message: parsed.reason,
+        path: target.path,
+        remediation: "Repair the JSON settings file or configure native prompt routing manually"
+      }));
+      return { target: target.path, actions: [], diagnostics };
+    }
+    hooks = parsed.hooks;
+  }
+  const existing = configHasExactRouter(hooks, target.harness);
+  if (existing.complete) {
+    diagnostics.push(diagnostic({
+      severity: "info",
+      code: "prompt-routing-already-configured",
+      subject: target.harness,
+      message: "Native prompt routing hooks are already present; no settings are changed",
+      path: target.path,
+      remediation: null
+    }));
+    return { target: target.path, actions: [], diagnostics };
+  }
+  if (existing.partial || existing.conflict) {
+    diagnostics.push(diagnostic({
+      severity: "error",
+      code: "prompt-routing-existing-hook-conflict",
+      subject: target.harness,
+      message: "A partial or modified Token Harness prompt hook already exists and was left untouched",
+      path: target.path,
+      remediation: "Review the existing native routing entries before planning another change"
+    }));
+    return { target: target.path, actions: [], diagnostics };
+  }
+  const entries = hookEntries(target.harness);
+  const action = {
+    kind: "merge-json",
+    id: actionId(target.harness, "enable", "all"),
+    riskClass: "reversible",
+    requiresNetwork: false,
+    requiresElevation: false,
+    affectedPaths: [target.path],
+    affectedProcesses: [target.harness],
+    preconditions: [
+      "the harness hook settings remain absent or valid JSON",
+      "no Token Harness native prompt-routing hooks are already present"
+    ],
+    postconditions: entries.map((entry) => `${entry.eventName} has one Token Harness-owned hook`),
+    rollbackData: "file-snapshot",
+    explanation: `Enable automatic native prompt routing for ${target.harness}` + (target.harness === "codex" ? "; manually enable and trust this hook in Codex after applying" : "; start a new Claude Code session after applying"),
+    path: target.path,
+    ownedPointers: entries.map((entry) => `hooks.${entry.eventName}`),
+    operations: entries.map((entry) => ({
+      kind: "append",
+      pointer: `hooks.${entry.eventName}`,
+      value: entry.value,
+      expectedValueDigest: null
+    })),
+    createIfMissing: true
+  };
+  return { target: target.path, actions: [action], diagnostics };
+}
+async function planNativePromptRoutingRemoval(input) {
+  const diagnostics = [];
+  const target = configTarget(input);
+  if (target === null || input.stateRoot === null) {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "prompt-routing-removal-unavailable",
+      subject: input.harness,
+      message: "The owned native prompt-routing configuration could not be located safely",
+      remediation: "Refresh Token Harness from the signed-in user environment"
+    }));
+    return { target: target?.path ?? null, actions: [], diagnostics };
+  }
+  const expected = hookEntries(target.harness);
+  const journals = await journalsFor({ fs: input.fs, stateRoot: input.stateRoot });
+  const artifacts = routerOwnedArtifacts(journals, target.path, target.harness);
+  const actions = expected.flatMap((entry) => {
+    const pointer = `hooks.${entry.eventName}`;
+    const targetArtifact = artifacts.find((artifact) => artifact.kind === "owned-json-entry" && artifact.pointer === pointer && artifact.valueDigest === jsonValueDigest(entry.value));
+    if (targetArtifact === void 0)
+      return [];
+    const reverses = actionId(target.harness, "enable", "all");
+    return [
+      {
+        kind: "remove-owned-change",
+        id: actionId(target.harness, "disable", entry.eventName),
+        riskClass: "reversible",
+        requiresNetwork: false,
+        requiresElevation: false,
+        affectedPaths: [target.path],
+        affectedProcesses: [target.harness],
+        preconditions: [`${entry.eventName} still contains the exact Token Harness-owned hook`],
+        postconditions: [`${entry.eventName} no longer contains the owned prompt-routing hook`],
+        rollbackData: "file-snapshot",
+        explanation: `Disable automatic native prompt routing for ${target.harness}`,
+        path: target.path,
+        reverses,
+        target: targetArtifact
+      }
+    ];
+  });
+  if (actions.length === 0)
+    diagnostics.push(diagnostic({
+      severity: "info",
+      code: "prompt-routing-not-owned",
+      subject: target.harness,
+      message: "Token Harness owns no native prompt-routing hooks here, so nothing is removed",
+      path: target.path,
+      remediation: null
+    }));
+  return { target: target.path, actions, diagnostics };
+}
+async function readEvents(input) {
+  if (input.stateRoot === null)
+    return { state: "unavailable", events: [] };
+  const directory = input.fs.join(input.stateRoot, "prompt-routing");
+  if ((await input.fs.stat(directory))?.kind !== "directory")
+    return { state: "available", events: [] };
+  const files = (await input.fs.readDirectory(directory)).filter((name2) => /^events-\d{4}-\d{2}\.jsonl$/.test(name2)).sort().reverse();
+  const events = [];
+  let scannedBytes = 0;
+  try {
+    for (const file of files) {
+      const path = input.fs.join(directory, file);
+      const stat3 = await input.fs.stat(path);
+      if (stat3 === null || stat3.kind !== "file")
+        continue;
+      if (stat3.byteLength > MAX_EVENT_FILE_BYTES || scannedBytes + stat3.byteLength > MAX_EVENT_SCAN_BYTES)
+        return { state: "limited", events };
+      const bytes = await input.fs.readFile(path);
+      if (bytes.byteLength !== stat3.byteLength)
+        return { state: "limited", events };
+      scannedBytes += bytes.byteLength;
+      const text3 = DECODER4.decode(bytes);
+      for (const line of text3.split("\n")) {
+        if (line === "")
+          continue;
+        try {
+          const value3 = JSON.parse(line);
+          if (!isPromptRouterEvent(value3))
+            continue;
+          if (input.harness !== void 0 && value3.harness !== input.harness)
+            continue;
+          if (input.projectId !== void 0 && value3.projectId !== input.projectId)
+            continue;
+          if (input.since !== void 0 && value3.timestamp < input.since)
+            continue;
+          events.push(value3);
+        } catch {
+        }
+      }
+      if (input.since !== void 0 && file.slice(7, 14) < input.since.slice(0, 7))
+        break;
+    }
+    return { state: "available", events };
+  } catch {
+    return { state: "unavailable", events: [] };
+  }
+}
+function isPromptRouterEvent(value3) {
+  const row2 = asRecord(value3);
+  return row2?.["schemaVersion"] === 1 && typeof row2["timestamp"] === "string" && Number.isFinite(Date.parse(row2["timestamp"])) && (row2["harness"] === "claude" || row2["harness"] === "codex") && typeof row2["projectId"] === "string" && ["prompt-submit", "subagent-start", "subagent-stop"].includes(String(row2["type"])) && (row2["model"] === null || typeof row2["model"] === "string" && row2["model"].length <= 80) && (row2["agentType"] === null || typeof row2["agentType"] === "string" && row2["agentType"].length <= 80);
+}
+async function recordNativePromptRoutingHook(input) {
+  if (input.fs === null || input.stateRoot === null || input.projectId === null)
+    return;
+  let payload = null;
+  if (input.event !== "prompt-submit" && input.hookInput !== null) {
+    try {
+      payload = asRecord(JSON.parse(input.hookInput));
+    } catch {
+      payload = null;
+    }
+  }
+  const agentTypeRaw = payload?.["agent_type"];
+  const agentType = input.event !== "prompt-submit" && typeof agentTypeRaw === "string" && agentTypeRaw.length <= 80 ? agentTypeRaw : null;
+  const timestamp = new Date(input.now).toISOString();
+  const event = {
+    schemaVersion: 1,
+    timestamp,
+    harness: input.harness,
+    projectId: input.projectId,
+    type: input.event,
+    // Hook payload model fields can identify the root session, not the spawned child. Until an
+    // adapter has a versioned child-model field, keep actual worker identity unknown.
+    model: null,
+    agentType
+  };
+  const partition = `events-${timestamp.slice(0, 7)}.jsonl`;
+  const directory = input.fs.join(input.stateRoot, "prompt-routing");
+  await input.fs.createDirectory(directory);
+  await input.fs.appendFile(input.fs.join(directory, partition), UTF84.encode(`${JSON.stringify(event)}
+`));
+}
+function summarizeEvents(events) {
+  return {
+    promptSubmissions: events.filter((event) => event.type === "prompt-submit").length,
+    subagentsStarted: events.filter((event) => event.type === "subagent-start").length,
+    subagentsStopped: events.filter((event) => event.type === "subagent-stop").length,
+    reportedModels: [
+      ...new Set(events.filter((event) => event.type === "subagent-start" || event.type === "subagent-stop").flatMap((event) => event.model === null ? [] : [event.model]))
+    ],
+    lastObservedAt: events.map((event) => event.timestamp).sort().at(-1) ?? null
+  };
+}
+async function observeNativePromptRouting(input) {
+  const harness = isHarness(input.harness) ? input.harness : "codex";
+  const base = {
+    harness,
+    state: "unavailable",
+    label: "Not verified",
+    detail: "Native prompt routing could not be checked on this harness.",
+    configPath: null,
+    configured: null,
+    promptSubmissions: 0,
+    subagentsStarted: 0,
+    subagentsStopped: 0,
+    reportedModels: [],
+    lastObservedAt: null,
+    receiptState: "unavailable"
+  };
+  const target = configTarget({ ...input, harness: input.harness });
+  if (target === null)
+    return base;
+  const eventResult = await readEvents({
+    fs: input.fs,
+    stateRoot: input.stateRoot,
+    harness,
+    ...input.projectId === null ? {} : { projectId: input.projectId },
+    since: new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString()
+  });
+  const summary = summarizeEvents(eventResult.events);
+  const stat3 = await input.fs.stat(target.path);
+  if (stat3 === null) {
+    return {
+      ...base,
+      state: "absent",
+      label: "Disabled",
+      detail: "Automatic routing is off. No Token Harness native prompt hook is installed.",
+      configPath: target.path,
+      configured: false,
+      ...summary,
+      receiptState: eventResult.state
+    };
+  }
+  if (stat3.kind !== "file")
+    return {
+      ...base,
+      state: "conflict",
+      label: "Path conflict",
+      detail: "A non-file occupies the native hook settings path.",
+      configPath: target.path,
+      ...summary,
+      receiptState: eventResult.state
+    };
+  let hooks;
+  try {
+    const parsed = parseHookDocument(DECODER4.decode(await input.fs.readFile(target.path)));
+    if (!parsed.ok)
+      return {
+        ...base,
+        state: "conflict",
+        label: "Settings need review",
+        detail: parsed.reason,
+        configPath: target.path,
+        ...summary,
+        receiptState: eventResult.state
+      };
+    hooks = parsed.hooks;
+  } catch {
+    return {
+      ...base,
+      state: "unavailable",
+      label: "Not verified",
+      detail: "The hook settings file could not be read safely.",
+      configPath: target.path,
+      ...summary,
+      receiptState: eventResult.state
+    };
+  }
+  const match = configHasExactRouter(hooks, harness);
+  if (match.conflict || match.partial) {
+    return {
+      ...base,
+      state: "conflict",
+      label: "Custom hook needs review",
+      detail: "A partial or edited Token Harness prompt-routing hook was found and was not changed.",
+      configPath: target.path,
+      ...summary,
+      receiptState: eventResult.state
+    };
+  }
+  if (!match.complete) {
+    return {
+      ...base,
+      state: "absent",
+      label: "Disabled",
+      detail: "Automatic routing is off. No Token Harness native prompt hook is installed.",
+      configPath: target.path,
+      configured: false,
+      ...summary,
+      receiptState: eventResult.state
+    };
+  }
+  const artifacts = routerOwnedArtifacts(await journalsFor(input), target.path, harness);
+  const state = artifacts.length === hookEntries(harness).length ? "managed" : "external";
+  const hasRuntimeReceipt = summary.promptSubmissions > 0;
+  const label = state === "external" ? hasRuntimeReceipt ? "Runtime observed \xB7 external" : "Enabled externally" : hasRuntimeReceipt ? "Runtime observed" : harness === "codex" ? "Configured \xB7 trust or runtime pending" : "Configured \xB7 runtime pending";
+  const detail2 = summary.promptSubmissions > 0 ? `${String(summary.promptSubmissions)} prompt hook(s), ${String(summary.subagentsStarted)} native agent start(s), ${String(summary.subagentsStopped)} stop(s) observed in this project during the last 30 days.${eventResult.state === "limited" ? " Counts are partial because the local receipt scan reached its safety limit." : eventResult.state === "unavailable" ? " Local runtime receipts could not be read." : ""}` : harness === "codex" ? "The hook is configured. Review and trust it in Codex with /hooks, then submit a prompt to produce a runtime receipt." : "The hook is configured. Start a new Claude Code session, submit a prompt, and Token Harness will show the runtime receipt.";
+  return {
+    ...base,
+    state,
+    label,
+    detail: detail2,
+    configPath: target.path,
+    configured: true,
+    ...summary,
+    receiptState: eventResult.state
+  };
+}
+async function nativeRoutingObservationForBenchmark(input) {
+  const observed = await observeNativePromptRouting({
+    ...input,
+    projectId: input.projectId
+  });
+  const configured = observed.configured;
+  if (input.startedAt === void 0)
+    return {
+      configured,
+      promptSubmissions: 0,
+      subagentsStarted: 0,
+      subagentsStopped: 0,
+      reportedModels: []
+    };
+  const found = await readEvents({
+    fs: input.fs,
+    stateRoot: input.stateRoot,
+    harness: observed.harness,
+    projectId: input.projectId,
+    since: input.startedAt
+  });
+  const summary = summarizeEvents(found.events);
+  return {
+    configured,
+    promptSubmissions: summary.promptSubmissions,
+    subagentsStarted: summary.subagentsStarted,
+    subagentsStopped: summary.subagentsStopped,
+    reportedModels: summary.reportedModels
+  };
+}
+var UTF84, DECODER4, ROUTE_MARKER, MAX_EVENT_FILE_BYTES, MAX_EVENT_SCAN_BYTES, PROMPT_ROUTER_CHECK_MARKER;
+var init_prompt_router = __esm({
+  "apps/cli/dist/src/prompt-router.js"() {
+    "use strict";
+    init_src();
+    init_src3();
+    UTF84 = new TextEncoder();
+    DECODER4 = new TextDecoder("utf-8", { fatal: true });
+    ROUTE_MARKER = "__internal-prompt-router";
+    MAX_EVENT_FILE_BYTES = 4 * 1024 * 1024;
+    MAX_EVENT_SCAN_BYTES = 16 * 1024 * 1024;
+    PROMPT_ROUTER_CHECK_MARKER = "token-harness-prompt-router-v1";
   }
 });
 
@@ -24065,7 +24764,7 @@ var init_agent_skill = __esm({
   "apps/cli/dist/src/agent-skill.js"() {
     "use strict";
     init_src();
-    TOKEN_HARNESS_AGENT_SKILL = "---\nname: token-harness\ndescription: Optimizes local Claude Code or Codex work against observed subscription allowance, context pressure, quality floors, and project-local benchmark evidence using the Token Harness CLI. Use when the user asks to conserve or maximize coding-agent allowance, choose reasoning/model/verbosity deliberately, check whether a task fits current quota, or explicitly asks to use Token Harness.\n---\n\n# Token Harness\n\nUse Token Harness as a local deterministic policy engine. Do not reproduce its quota math or invent provider conversions yourself.\n\n## Default workflow\n\n1. Confirm `token-harness --version` works. If it is missing, do not install it silently. If the user asked to install or set up Token Harness, follow that request; otherwise explain that the local CLI is required.\n2. Identify the harness you are currently running as: `claude` for Claude Code or `codex` for Codex. Do not guess from repository files.\n3. Classify the current task conservatively:\n   - `mechanical`: formatting, rename, lookup, simple edits, deterministic scaffolding.\n   - `standard`: ordinary implementation, tests, focused bug fixes.\n   - `hard`: multi-file reasoning, ambiguous failures, migrations, difficult reviews.\n   - `critical`: architecture, security-sensitive work, releases, or high-regression-risk changes.\n   If uncertain between two classes, use the higher class.\n4. For a substantial task, or whenever the user asks about allowance/efficiency, run:\n\n   `token-harness optimize --harness <claude|codex> --task <class> --profile balanced --json`\n\n5. Treat the JSON result as evidence, not as permission to mutate configuration. Prefer recommendations that reduce avoidable context or session overhead before lowering a quality floor.\n6. Continue with the user's task. Mention Token Harness only when it materially changes the plan, recommends a user-visible action, or lacks enough evidence.\n\nDo not run Token Harness before every trivial tool call. One observation at a meaningful task boundary is normally enough; re-observe when the task class changes materially, after a quota reset, after a substantial session/context change, or when the user asks.\n\n## Active context evidence\n\nWhen the current conversation or your own tool results directly establish useful task-state evidence, you may pass a short-lived `--context-snapshot` file to `optimize`. This metadata is for the CLI; never ask the user to write or understand the JSON. Skip the snapshot when no actionable evidence is directly observable or a temporary file cannot be safely created and removed.\n\n- Set task boundary, validation and quality only from explicit task state and checks you observed. Use `unknown` when those facts are missing or ambiguous.\n- Mark material superseded or condensable only when its current state is directly clear. Include `byteLength` only when tooling measured the exact local bytes; otherwise use `null`. Never estimate bytes from tokens.\n- Set reducer attribution only when directly known; otherwise use `unknown`. Do not include transcript text, prompts, tool payloads, source text, paths, MCP names or schemas.\n- Add a checkpoint byte ceiling only when you will use that same ceiling for the existing bounded `token-harness handoff` command. Omit it when no artifact budget is configured.\n- Create the metadata file temporarily, run `optimize`, then remove it. Treat the decision as advice; do not mask, summarize, compact or start a session on the user's behalf.\n\n## Explicit workload\n\nOnly pass `--tasks-left N` when the remaining accepted-task count is explicit from the user or an explicit task list already in the conversation. Never infer it from token history, source files, GitHub issues, or a guessed backlog. When it is explicit, add it to the same advisory call:\n\n`token-harness optimize --harness <claude|codex> --task <class> --profile balanced --tasks-left <N> --json`\n\nFor multiple independent new tasks whose explicit list can be classified by task class, Token Harness can compare Claude and Codex with:\n\n`token-harness schedule --current <current> --candidate <other> --workload mechanical=N,standard=N,hard=N,critical=N --json`\n\nOmit zero-count classes. This is for queued new work, not an in-progress handoff. Never switch harnesses automatically from this result.\n\n## Persistent native changes\n\n`optimize` is advisory. If it recommends a persistent model/reasoning/verbosity change and the user wants it applied:\n\n1. Build a reviewed plan with `token-harness plan --harness <claude|codex> --native-policy --task <class> --profile balanced --json`.\n2. Summarize the exact proposed change, scope, and any limitations to the user.\n3. Apply only after the user explicitly approves the proposed mutation. Use the returned plan id with `token-harness apply --plan <id> --yes`.\n4. Do not treat a persisted preference as a live change to an already-running session. Follow the plan/result instructions about when it takes effect.\n\nNever silently change authentication, billing, provider, model routing, hooks, trust, or purchase/redeem credits.\n\n## Evidence rules\n\n- Never equate local token counts with subscription quota.\n- Never compare raw Claude and Codex percentages as if they were the same currency.\n- Unknown allowance or benchmark evidence stays unknown.\n- Preserve task quality floors; do not lower effort merely because a cheaper setting exists.\n- Prefer project-local measured outcomes and backend quota deltas when Token Harness exposes them.\n- Do not add an MCP server or background model just to use this skill. The local CLI is the tool surface.\n";
+    TOKEN_HARNESS_AGENT_SKILL = "---\nname: token-harness\ndescription: Optimizes local Claude Code or Codex work against observed subscription allowance, context pressure, quality floors, and project-local benchmark evidence using the Token Harness CLI. Guides native subagent model routing for substantial bounded coding tasks. Use for substantial coding work where native delegation may apply, or when the user asks about allowance, model/effort/verbosity choices, quota fit, or Token Harness.\n---\n\n# Token Harness\n\nUse Token Harness as a local deterministic policy engine. Do not reproduce its quota math or invent provider conversions yourself.\n\n## Automatic routing\n\nWhen enabled in the Token Harness dashboard, a native prompt hook supplies the routing policy on every submitted prompt. This works without invoking this skill or prefixing the prompt with a command. The hook asks the coding agent to delegate only eligible bounded work; it does not change the root model or prove which child model ran. Use this skill when the user asks for explicit quota-aware advice or a benchmark.\n\n## Default workflow\n\n1. Confirm `token-harness --version` works. If it is missing, do not install it silently. If the user asked to install or set up Token Harness, follow that request; otherwise explain that the local CLI is required.\n2. Identify the harness you are currently running as: `claude` for Claude Code or `codex` for Codex. Do not guess from repository files.\n3. Classify the current task conservatively:\n   - `mechanical`: formatting, rename, lookup, simple edits, deterministic scaffolding.\n   - `standard`: ordinary implementation, tests, focused bug fixes.\n   - `hard`: multi-file reasoning, ambiguous failures, migrations, difficult reviews.\n   - `critical`: architecture, security-sensitive work, releases, or high-regression-risk changes.\n   If uncertain between two classes, use the higher class.\n4. For a substantial task, or whenever the user asks about allowance/efficiency, run:\n\n   `token-harness optimize --harness <claude|codex> --task <class> --profile balanced --json`\n\n5. Treat the JSON result as evidence, not as permission to mutate configuration. Prefer recommendations that reduce avoidable context or session overhead before lowering a quality floor.\n6. Continue with the user's task. Mention Token Harness only when it materially changes the plan, recommends a user-visible action, or lacks enough evidence.\n\nDo not run Token Harness before every trivial tool call. One observation at a meaningful task boundary is normally enough; re-observe when the task class changes materially, after a quota reset, after a substantial session/context change, or when the user asks.\n\n## Active context evidence\n\nWhen the current conversation or your own tool results directly establish useful task-state evidence, you may pass a short-lived `--context-snapshot` file to `optimize`. This metadata is for the CLI; never ask the user to write or understand the JSON. Skip the snapshot when no actionable evidence is directly observable or a temporary file cannot be safely created and removed.\n\n- Set task boundary, validation and quality only from explicit task state and checks you observed. Use `unknown` when those facts are missing or ambiguous.\n- Mark material superseded or condensable only when its current state is directly clear. Include `byteLength` only when tooling measured the exact local bytes; otherwise use `null`. Never estimate bytes from tokens.\n- Set reducer attribution only when directly known; otherwise use `unknown`. Do not include transcript text, prompts, tool payloads, source text, paths, MCP names or schemas.\n- Add a checkpoint byte ceiling only when you will use that same ceiling for the existing bounded `token-harness handoff` command. Omit it when no artifact budget is configured.\n- Create the metadata file temporarily, run `optimize`, then remove it. Treat the decision as advice; do not mask, summarize, compact or start a session on the user's behalf.\n\n## Explicit workload\n\nOnly pass `--tasks-left N` when the remaining accepted-task count is explicit from the user or an explicit task list already in the conversation. Never infer it from token history, source files, GitHub issues, or a guessed backlog. When it is explicit, add it to the same advisory call:\n\n`token-harness optimize --harness <claude|codex> --task <class> --profile balanced --tasks-left <N> --json`\n\nFor multiple independent new tasks whose explicit list can be classified by task class, Token Harness can compare Claude and Codex with:\n\n`token-harness schedule --current <current> --candidate <other> --workload mechanical=N,standard=N,hard=N,critical=N --json`\n\nOmit zero-count classes. This is for queued new work, not an in-progress handoff. Never switch harnesses automatically from this result.\n\n## Native subagent model routing\n\nUse native subagents as the only model-routing surface. This routes delegated work; it never changes the model already selected for the root conversation. Keep Codex as the first supported path.\n\nFor Codex, when the task is substantial and contains a complete, bounded implementation unit that can be handed off without duplicating work, delegate that unit to one native subagent with `model: gpt-6-luna` if Luna is present in the current Codex model picker/catalog. Set the model explicitly in the native spawn request: when it is omitted, Codex inherits the root model and reasoning effort, so a generic delegation is not a cost-routed delegation. If a higher-priority instruction forbids specifying the child model, skip cost routing and continue with the root model. Keep the root model responsible for task framing, integration, and acceptance review. Do not run the same implementation in both agents. Use at most one cost-routed worker at a time.\n\nSkip routing for trivial tasks, tightly coupled or shared-write work, architecture/security/release decisions, work that needs the root model's full context or judgment throughout, when the user asks not to delegate, when the root model is Luna or cannot be identified, or when the requested model is not currently available. Do not substitute an unverified model ID or silently fall back to another harness. If no supported route is available, continue with the current root model.\n\nFor Claude Code, apply the same bounded-task rules only when Claude Code is already configured and authenticated and native subagents are available. Request the current native `haiku` alias for an eligible worker; do not configure Claude Code or authenticate on the user's behalf.\n\nTreat the selected child model as a routing request until Codex or Claude Code visibly reports the worker's actual model. A skill instruction is not runtime telemetry. Subagents add context and coordination overhead and can consume more total tokens than single-agent work; do not claim token, quota, or cost savings without paired, quality-gated usage evidence for the same harness and task class.\n\n## Persistent native changes\n\n`optimize` is advisory. If it recommends a persistent model/reasoning/verbosity change and the user wants it applied:\n\n1. Build a reviewed plan with `token-harness plan --harness <claude|codex> --native-policy --task <class> --profile balanced --json`.\n2. Summarize the exact proposed change, scope, and any limitations to the user.\n3. Apply only after the user explicitly approves the proposed mutation. Use the returned plan id with `token-harness apply --plan <id> --yes`.\n4. Do not treat a persisted preference as a live change to an already-running session. Follow the plan/result instructions about when it takes effect.\n\nNever silently change authentication, billing, provider, model routing, hooks, trust, or purchase/redeem credits.\n\n## Evidence rules\n\n- Never equate local token counts with subscription quota.\n- Never compare raw Claude and Codex percentages as if they were the same currency.\n- Unknown allowance or benchmark evidence stays unknown.\n- Preserve task quality floors; do not lower effort merely because a cheaper setting exists.\n- Prefer project-local measured outcomes and backend quota deltas when Token Harness exposes them.\n- Do not add an MCP server or background model just to use this skill. The local CLI is the tool surface.\n";
     ENCODER = new TextEncoder();
     SKILL_DIGEST = digestBytes(ENCODER.encode(TOKEN_HARNESS_AGENT_SKILL));
     TARGETS = {
@@ -26045,6 +26744,41 @@ async function computePlan(context) {
       }
     }
   }
+  if (context.agentRouting === true || context.disableAgentRouting === true) {
+    const harness = context.harness;
+    if (harness !== harnessId("claude") && harness !== CODEX12) {
+      diagnostics.push(diagnostic({
+        severity: "warning",
+        code: "prompt-routing-harness-required",
+        subject: harness,
+        message: "Automatic prompt routing requires an explicit Claude Code or Codex harness",
+        remediation: "Choose the detected agent in the guided app, or pass --harness claude|codex"
+      }));
+    } else if (context.adapters === null) {
+      diagnostics.push(diagnostic({
+        severity: "warning",
+        code: "prompt-routing-adapters-unavailable",
+        subject: harness,
+        message: "The native prompt hook could not be planned without filesystem adapters",
+        remediation: "Refresh Token Harness from a supported local environment"
+      }));
+    } else {
+      const input = {
+        fs: context.adapters.fs,
+        home: context.home,
+        harness,
+        version: versions.harnesses[harness] ?? null,
+        runner: context.adapters.runner,
+        facts: context.platform,
+        paths: context.adapters.paths,
+        projectRoot: context.projectRoot,
+        stateRoot: context.stateRoot
+      };
+      const routingPlan = context.agentRouting ? await planNativePromptRoutingInstall(input) : await planNativePromptRoutingRemoval(input);
+      actions.push(...routingPlan.actions);
+      diagnostics.push(...routingPlan.diagnostics);
+    }
+  }
   if (context.nativePolicy === true && context.harness === harnessId("claude")) {
     if (context.taskClass === void 0 || context.taskClass === null) {
       diagnostics.push(diagnostic({
@@ -26227,6 +26961,7 @@ var init_plan2 = __esm({
     init_src3();
     init_src();
     init_agent_skill();
+    init_prompt_router();
     init_apply();
     init_context_cost2();
     init_optimize();
@@ -26303,6 +27038,48 @@ async function verifyManagedIntegrationPostconditions(context, integrations) {
   }
   return diagnostics;
 }
+async function verifyNativePromptRoutingPostconditions(context, actions) {
+  const routing = actions.filter((action) => action.id.startsWith("native-prompt-routing:"));
+  if (routing.length === 0)
+    return [];
+  if (context.adapters === null || context.stateRoot === null || context.harness !== harnessId("claude") && context.harness !== harnessId("codex")) {
+    return [
+      diagnostic({
+        severity: "error",
+        code: "prompt-routing-postcondition-unavailable",
+        subject: context.harness,
+        message: "Native prompt-routing configuration could not be read after the change",
+        remediation: "Keep the transaction rollback and review a fresh plan from the local agent environment"
+      })
+    ];
+  }
+  const observed = await observeNativePromptRouting({
+    fs: context.adapters.fs,
+    home: context.home,
+    stateRoot: context.stateRoot,
+    harness: context.harness,
+    version: null,
+    runner: context.adapters.runner,
+    facts: context.platform,
+    paths: context.adapters.paths,
+    projectRoot: context.projectRoot,
+    projectId: context.adapters.projectIdFor(context.projectRoot)
+  });
+  const shouldBeEnabled = routing.some((action) => action.id.includes(":enable:"));
+  const satisfied = shouldBeEnabled ? observed.configured === true : observed.configured === false;
+  if (satisfied)
+    return [];
+  return [
+    diagnostic({
+      severity: "error",
+      code: "prompt-routing-postcondition-unmet",
+      subject: context.harness,
+      path: observed.configPath,
+      message: `Native prompt-routing hooks were not observed in the requested state after the change: ${observed.label}`,
+      remediation: "Review the hook settings and allow the transaction to restore its backup"
+    })
+  ];
+}
 function transactionIdFor(planId, at) {
   const digest = digestText(`${planId} ${at}`);
   return digest.slice(digest.indexOf(":") + 1, digest.indexOf(":") + 13);
@@ -26369,6 +27146,8 @@ async function runApply(context) {
   const diagnostics = [];
   let stored = null;
   let storedAgentSkill = false;
+  let storedAgentRouting = false;
+  let storedAgentRoutingRemoval = false;
   let planningContext = context;
   const rejectedReport = () => ({
     ...emptyReport3("rejected"),
@@ -26422,11 +27201,15 @@ async function runApply(context) {
         return finish3("rejected", EXIT_CODES["precondition-drift"], rejectedReport(), diagnostics);
       }
       storedAgentSkill = stored.actions.some((action) => action.id.startsWith("agent-skill:"));
+      storedAgentRouting = stored.actions.some((action) => action.id.startsWith("native-prompt-routing:") && action.id.includes(":enable:"));
+      storedAgentRoutingRemoval = stored.actions.some((action) => action.id.startsWith("native-prompt-routing:") && action.id.includes(":disable:"));
       planningContext = {
         ...context,
         harness: stored.harness,
         provider,
-        agentSkill: storedAgentSkill
+        agentSkill: storedAgentSkill,
+        agentRouting: storedAgentRouting,
+        disableAgentRouting: storedAgentRoutingRemoval
       };
     } catch {
       diagnostics.push(diagnostic({
@@ -26450,6 +27233,16 @@ async function runApply(context) {
     }));
     return finish3("rejected", EXIT_CODES["precondition-drift"], rejectedReport(), diagnostics);
   }
+  if (stored !== null && (storedAgentRouting || storedAgentRoutingRemoval) && computed.report.planId !== stored.planId) {
+    diagnostics.push(diagnostic({
+      severity: "error",
+      code: "prompt-routing-plan-drift",
+      subject: stored.harness,
+      message: "The native prompt-routing target or ownership changed after the reviewed preview",
+      remediation: "Review a fresh prompt-routing preview; nothing was written"
+    }));
+    return finish3("rejected", EXIT_CODES["precondition-drift"], rejectedReport(), diagnostics);
+  }
   if (computed.blocked.length > 0 && computed.report.actions.length === 0) {
     return finish3("rejected", EXIT_CODES["unsupported-environment"], rejectedReport(), diagnostics);
   }
@@ -26553,7 +27346,10 @@ async function runApply(context) {
     // RFC 0004 §Process policy: an installer reaches the machine through the runner or not at all.
     runner: context.adapters.runner,
     now: context.now,
-    verifyPostconditions: async () => verifyManagedIntegrationPostconditions(context, computed.managedIntegrations)
+    verifyPostconditions: async () => [
+      ...await verifyManagedIntegrationPostconditions(context, computed.managedIntegrations),
+      ...await verifyNativePromptRoutingPostconditions(context, actions)
+    ]
   });
   diagnostics.push(...transaction.diagnostics);
   const report = {
@@ -26589,6 +27385,7 @@ var init_apply = __esm({
     "use strict";
     init_src();
     init_src3();
+    init_prompt_router();
     init_candidate_lifecycle();
     init_plan2();
     init_snapshot_safety();
@@ -26888,6 +27685,18 @@ async function runBenchmarkStart(context) {
     runContext(observedContext),
     runHistory({ ...observedContext, since: "1d", until: null })
   ]);
+  const nativeRoutingAtStart = context.adapters === null ? null : await nativeRoutingObservationForBenchmark({
+    fs: context.adapters.fs,
+    home: context.home,
+    stateRoot: context.stateRoot,
+    harness,
+    version: null,
+    runner: context.adapters.runner,
+    facts: context.platform,
+    paths: context.adapters.paths,
+    projectRoot: context.projectRoot,
+    projectId
+  });
   const budget = budgetResult.data?.harnesses.find((item) => item.harnessId === harness);
   const contextObservation = contextResult.data?.harnesses.find((item) => item.harnessId === harness);
   const policy = benchmarkPolicySnapshot(contextObservation);
@@ -26906,7 +27715,8 @@ async function runBenchmarkStart(context) {
     startedAt,
     usageBefore: budget?.windows ?? [],
     contextAtStart,
-    localSessionsBefore
+    localSessionsBefore,
+    nativeRoutingAtStart
   };
   if (!await writeJson(context, paths.capturePath, capture)) {
     return commandResult({
@@ -27091,6 +27901,19 @@ async function runBenchmarkFinish(context) {
     runContext(completedContext),
     runHistory({ ...completedContext, since: "1d", until: null })
   ]);
+  const nativeRoutingAtFinish = context.adapters === null ? null : await nativeRoutingObservationForBenchmark({
+    fs: context.adapters.fs,
+    home: context.home,
+    stateRoot: context.stateRoot,
+    harness: parsed.capture.harnessId,
+    version: null,
+    runner: context.adapters.runner,
+    facts: context.platform,
+    paths: context.adapters.paths,
+    projectRoot: context.projectRoot,
+    projectId,
+    startedAt: parsed.capture.startedAt
+  });
   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);
@@ -27102,7 +27925,8 @@ async function runBenchmarkFinish(context) {
     failedAttempts,
     localUsage,
     contextAtFinish: taskBenchmarkContextSnapshot(finishContextObservation),
-    policyAtFinish: benchmarkPolicySnapshot(finishContextObservation)
+    policyAtFinish: benchmarkPolicySnapshot(finishContextObservation),
+    nativeRoutingAtFinish
   });
   if (!completed.ok) {
     return commandResult({
@@ -27159,6 +27983,7 @@ var init_benchmark_capture = __esm({
     init_budget2();
     init_context_cost2();
     init_history2();
+    init_prompt_router();
     CLAUDE13 = harnessId("claude");
     CODEX13 = harnessId("codex");
     CAPTURE_HARNESSES = /* @__PURE__ */ new Set([CLAUDE13, CODEX13]);
@@ -33774,12 +34599,19 @@ not-exercised, which is not a failure.`,
 
 Usage
   token-harness plan [--json] [--harness <id>] [--provider <id>] [--project <dir>]
+                     [--agent-routing | --disable-agent-routing]
                      [--native-policy] [--task <class>] [--profile <name>]
                      [--reserve <0-95>] [--tasks-left <n>]
 
 Read-only. Exits 0 when a plan was produced, and 4 when a hard conflict prevents
 apply. Nothing is changed either way.
 
+--agent-routing adds the native per-prompt hook for the selected Claude Code or Codex
+harness. --disable-agent-routing removes only exact hook entries owned by Token Harness.
+Both changes use the normal stored-plan, approval, verification and rollback path. Claude
+loads the change in a new session; Codex requires the user to review and trust the hook in
+/hooks. Configuration is shown separately from runtime callbacks in the guided app.
+
 --native-policy adds reviewed Codex native settings derived from the same optimizer
 policy as token-harness optimize. This build manages reasoning effort and verbosity
 only. A field coming from project config or a selected profile is left untouched.
@@ -33998,6 +34830,8 @@ async function run(options) {
     nativePolicy: invocation.options.nativePolicy,
     env: options.env ?? {},
     agentSkill: invocation.options.agentSkill,
+    agentRouting: invocation.options.agentRouting,
+    disableAgentRouting: invocation.options.disableAgentRouting,
     since: invocation.options.since,
     until: invocation.options.until,
     planId: invocation.options.plan,
@@ -34488,6 +35322,48 @@ function allowanceEvidence(entries, scope, quality) {
     pairs: deltas.length
   };
 }
+function routedAllowanceEvidence(entries, scope) {
+  const deltas = entries.flatMap((entry) => {
+    const quota = entry.quota;
+    if (quota === null || quota.scope !== scope || quota.confidence !== "authoritative")
+      return [];
+    return [quota.baselineDeltaUsedPercent - quota.optimizedDeltaUsedPercent];
+  });
+  const savedPercent = median2(deltas);
+  return {
+    state: savedPercent === null ? "not-measured" : "measured",
+    scope,
+    savedPercent: savedPercent === null ? null : roundOne(savedPercent),
+    equivalentMinutes: scope === "five-hour" && savedPercent !== null ? roundOne(savedPercent * 3) : null,
+    pairs: deltas.length
+  };
+}
+function routingEvidence(entries) {
+  const routed = entries.filter((entry) => entry.nativeRouting?.verdict === "attributed");
+  const eligible = routed.filter((entry) => entry.nativeRouting?.qualityGatesPassed === true);
+  const local = eligible.filter((entry) => entry.baselineLocalTokens !== null && entry.optimizedLocalTokens !== null);
+  const baselineLocalTokens = local.length ? local.reduce((total, entry) => total + (entry.baselineLocalTokens ?? 0), 0) : null;
+  const optimizedLocalTokens = local.length ? local.reduce((total, entry) => total + (entry.optimizedLocalTokens ?? 0), 0) : null;
+  const savedLocalTokens = baselineLocalTokens === null || optimizedLocalTokens === null ? null : baselineLocalTokens - optimizedLocalTokens;
+  const localTokenSavingPercent = baselineLocalTokens === null || optimizedLocalTokens === null || baselineLocalTokens <= 0 ? null : roundOne(savedLocalTokens / baselineLocalTokens * 100);
+  const qualityBlockedPairs = routed.length - eligible.length;
+  return {
+    state: routed.length === 0 ? "not-measured" : eligible.length === 0 ? "blocked-by-quality" : "measured",
+    pairs: eligible.length,
+    qualityBlockedPairs,
+    localPairs: local.length,
+    baselineLocalTokens,
+    optimizedLocalTokens,
+    savedLocalTokens,
+    localTokenSavingPercent,
+    allowance5h: routedAllowanceEvidence(eligible, "five-hour"),
+    allowance7d: routedAllowanceEvidence(eligible, "weekly"),
+    reportedChildModels: [
+      ...new Set(eligible.flatMap((entry) => entry.nativeRouting?.optimizedReportedModels ?? []))
+    ],
+    basis: routed.length === 0 ? "No paired benchmark currently proves that a native prompt hook ran and started a subagent." : eligible.length === 0 ? "Routing callbacks were observed, but all attributed pairs failed the quality gate; no savings are credited." : local.length > 0 || eligible.some((entry) => entry.quota?.confidence === "authoritative") ? "Exact local token counts and authoritative quota deltas are reported in separate units, only for attributed pairs that passed both quality gates." : "Routing was observed and both quality gates passed, but local token or authoritative quota usage was unavailable; no savings amount is inferred."
+  };
+}
 function guidedValueEvidence(report) {
   const entries = report?.entries ?? [];
   const quality = qualityEvidence(entries);
@@ -34496,6 +35372,7 @@ function guidedValueEvidence(report) {
     allowance5h: allowanceEvidence(entries, "five-hour", quality),
     allowance7d: allowanceEvidence(entries, "weekly", quality),
     quality,
+    routing: routingEvidence(entries),
     candidates: (report?.candidateEvidence ?? []).map((item) => ({ ...item })),
     apiCost: {
       state: "not-measured",
@@ -34740,7 +35617,7 @@ function guidanceView(id, observation) {
     ...observation.state === "absent" ? { action: { kind: "skill", label: "Enable in-session guidance", harness: id } } : {}
   };
 }
-function agentRules(id, providers, context, guidance) {
+function agentRules(id, providers, context, guidance, promptRouting) {
   const observation = context?.harnesses.find((item) => item.harnessId === id);
   const reasoning = reasoningView(id, observation);
   return [
@@ -34790,6 +35667,29 @@ function agentRules(id, providers, context, guidance) {
       next: guidance?.state === "managed" ? "Keep coding normally. Ask the agent to use Token Harness when you want an explicit quota-aware check." : guidance?.state === "external" ? "The matching skill can be used as-is. Token Harness keeps it user-owned." : guidance?.state === "conflict" ? "Review the existing skill manually. Token Harness will not overwrite it." : "Enable this once, then keep coding normally. Ask the agent to use Token Harness for a task when you want an explicit check.",
       ...guidance?.action ? { action: guidance.action } : {}
     },
+    {
+      id: `${id}-prompt-routing`,
+      title: "Automatic prompt routing",
+      state: promptRouting?.label ?? "Not verified",
+      mode: promptRouting?.state === "absent" ? "not-enabled" : promptRouting?.state === "managed" || promptRouting?.state === "external" ? "automatic" : "integration",
+      what: promptRouting?.detail ?? "Adds a native prompt hook that supplies the routing policy on every submitted prompt.",
+      why: "Eligible bounded work may use a cheaper native subagent. The root conversation model stays unchanged, and the model decides whether a native subagent is appropriate.",
+      evidence: promptRouting?.promptSubmissions ? `${String(promptRouting.promptSubmissions)} prompt callback(s) and ${String(promptRouting.subagentsStarted)} subagent start(s) observed in the last 30 days. Actual child model is shown only when the harness reports it.` : promptRouting?.configured ? "The hook is configured, but no prompt callback has been observed yet. Configuration alone is not runtime proof." : "No runtime routing evidence has been recorded yet.",
+      next: promptRouting?.state === "absent" ? "Enable routing once, restart or trust the hook if the harness requires it, then keep using prompts normally." : promptRouting?.state === "managed" ? "Routing is enabled. Disable it here if you want to stop injecting the policy on each prompt." : promptRouting?.state === "external" ? "This hook is user-owned. Token Harness can report it but will not remove it." : promptRouting?.detail ?? "Refresh to inspect the native prompt-hook state.",
+      ...promptRouting?.state === "absent" ? {
+        action: {
+          kind: "routing-enable",
+          label: "Enable automatic routing",
+          harness: id
+        }
+      } : promptRouting?.state === "managed" ? {
+        action: {
+          kind: "routing-disable",
+          label: "Disable automatic routing",
+          harness: id
+        }
+      } : {}
+    },
     {
       id: `${id}-mcp`,
       title: "Connected tools",
@@ -35023,11 +35923,13 @@ var init_guided = __esm({
       now;
       random;
       observeGuidance;
-      constructor(call, now, random, observeGuidance = null) {
+      observeRouting;
+      constructor(call, now, random, observeGuidance = null, observeRouting = null) {
         this.call = call;
         this.now = now;
         this.random = random;
         this.observeGuidance = observeGuidance;
+        this.observeRouting = observeRouting;
       }
       status() {
         return {
@@ -35099,6 +36001,7 @@ var init_guided = __esm({
         const empty2 = () => ({ data: null, diagnostics: [], exitCode: 9 });
         let doctor = empty2(), budget = empty2(), context = empty2();
         let guidance;
+        let promptRouting;
         const observe = async (id, args) => {
           let result6;
           try {
@@ -35116,7 +36019,7 @@ var init_guided = __esm({
           loading.agents = this.agentView(doctor, budget, context, {
             rules: loading.stages.find((item) => item.id === "rules")?.state !== "working",
             allowance: loading.stages.find((item) => item.id === "allowance")?.state !== "working"
-          }, guidance);
+          }, guidance, promptRouting);
         };
         const [, , , metrics, status, benchmark] = await Promise.all([
           observe("agents", ["doctor"]).then((result6) => {
@@ -35143,6 +36046,29 @@ var init_guided = __esm({
                 }
               }));
             }
+            if (this.observeRouting !== null) {
+              promptRouting = {};
+              await Promise.all(["claude", "codex"].map(async (harness) => {
+                try {
+                  promptRouting[harness] = await this.observeRouting(harness);
+                } catch {
+                  promptRouting[harness] = {
+                    harness,
+                    state: "unavailable",
+                    label: "Not verified",
+                    detail: "Native prompt-hook status could not be checked.",
+                    configPath: null,
+                    configured: null,
+                    promptSubmissions: 0,
+                    subagentsStarted: 0,
+                    subagentsStopped: 0,
+                    reportedModels: [],
+                    lastObservedAt: null,
+                    receiptState: "unavailable"
+                  };
+                }
+              }));
+            }
             updateAgents();
           }),
           observe("savings", [
@@ -35156,7 +36082,7 @@ var init_guided = __esm({
           observe("checks", ["status"]),
           observe("value", ["benchmark-matrix"])
         ]);
-        const agents = this.agentView(doctor, budget, context, { rules: true, allowance: true }, guidance);
+        const agents = this.agentView(doctor, budget, context, { rules: true, allowance: true }, guidance, promptRouting);
         const notices = [];
         if (doctor.data === null)
           notices.push("The agent inventory could not be read. Check the local installation and refresh.");
@@ -35184,7 +36110,7 @@ var init_guided = __esm({
           notices
         };
       }
-      agentView(doctor, budget, context, complete2, guidance) {
+      agentView(doctor, budget, context, complete2, guidance, promptRouting) {
         const present = (doctor.data?.harnesses ?? []).filter((item) => item.state !== "absent" && (item.harnessId === "claude" || item.harnessId === "codex"));
         return present.map((agent) => {
           const providers = (doctor.data?.providers ?? []).filter((provider) => provider.state === "configured" && provider.configuredHarnesses.includes(agent.harnessId)).map((p) => p.providerId);
@@ -35207,8 +36133,9 @@ var init_guided = __esm({
             effort: observed?.nativeEffort?.current ?? observed?.reasoningEffort ?? null,
             reasoning: reasoningView(agent.harnessId, observed),
             ...guidance?.[agent.harnessId] ? { guidance: guidance[agent.harnessId] } : {},
+            ...promptRouting?.[agent.harnessId] ? { promptRouting: promptRouting[agent.harnessId] } : {},
             allowanceAction: allowanceAction(usage?.diagnostics ?? []),
-            rules: agentRules(agent.harnessId, providers, context.data, guidance?.[agent.harnessId]),
+            rules: agentRules(agent.harnessId, providers, context.data, guidance?.[agent.harnessId], promptRouting?.[agent.harnessId]),
             allowance: (usage?.windows ?? []).map((window) => ({
               label: window.scope === "five-hour" ? "5-hour allowance" : `${window.scope} allowance`,
               remaining: window.remainingPercent,
@@ -35243,11 +36170,13 @@ var init_guided = __esm({
           "setup",
           "effort",
           "skill",
+          "routing-enable",
+          "routing-disable",
           "undo",
           "remove",
           "candidate-setup",
           "candidate-remove"
-        ].includes(action) || data["harness"] !== void 0 && !["claude", "codex"].includes(String(data["harness"])) || data["harnesses"] !== void 0 && !validHarnesses || data["harnesses"] !== void 0 && action !== "setup" || data["harnesses"] !== void 0 && data["harness"] !== void 0 || data["task"] !== void 0 && !TASKS.has(String(data["task"])) || data["provider"] !== void 0 && !["rtk", "harnesstrim", "mcptoon", "gitnexus", "headroom"].includes(String(data["provider"])) || data["candidate"] !== void 0 && !["mcptoon", "gitnexus"].includes(String(data["candidate"])) || action === "effort" && (data["harness"] === void 0 || data["task"] === void 0) || action === "skill" && data["harness"] === void 0 || action === "remove" && (data["provider"] === void 0 || data["harness"] !== void 0 || data["harnesses"] !== void 0 || data["task"] !== void 0 || data["candidate"] !== void 0) || data["provider"] !== void 0 && action !== "remove" && action !== "setup" || candidateAction && (data["candidate"] === void 0 || data["harness"] === void 0 || data["provider"] !== void 0 || data["task"] !== void 0) || !candidateAction && data["candidate"] !== void 0)
+        ].includes(action) || data["harness"] !== void 0 && !["claude", "codex"].includes(String(data["harness"])) || data["harnesses"] !== void 0 && !validHarnesses || data["harnesses"] !== void 0 && action !== "setup" || data["harnesses"] !== void 0 && data["harness"] !== void 0 || data["task"] !== void 0 && !TASKS.has(String(data["task"])) || data["provider"] !== void 0 && !["rtk", "harnesstrim", "mcptoon", "gitnexus", "headroom"].includes(String(data["provider"])) || data["candidate"] !== void 0 && !["mcptoon", "gitnexus"].includes(String(data["candidate"])) || action === "effort" && (data["harness"] === void 0 || data["task"] === void 0) || action === "skill" && data["harness"] === void 0 || (action === "routing-enable" || action === "routing-disable") && data["harness"] === void 0 || action === "remove" && (data["provider"] === void 0 || data["harness"] !== void 0 || data["harnesses"] !== void 0 || data["task"] !== void 0 || data["candidate"] !== void 0) || data["provider"] !== void 0 && action !== "remove" && action !== "setup" || candidateAction && (data["candidate"] === void 0 || data["harness"] === void 0 || data["provider"] !== void 0 || data["task"] !== void 0) || !candidateAction && data["candidate"] !== void 0)
           throw new GuideError(400, "Choose a supported agent and action.");
         return this.exclusive(async () => {
           this.approval = null;
@@ -35435,13 +36364,17 @@ var init_guided = __esm({
                 args.push("--provider", setupProvider);
               if (data["action"] === "skill") {
                 args.push("--provider", "none", "--agent-skill");
+              } else if (data["action"] === "routing-enable") {
+                args.push("--provider", "none", "--agent-routing");
+              } else if (data["action"] === "routing-disable") {
+                args.push("--provider", "none", "--disable-agent-routing");
               } else if (data["action"] === "effort")
                 args.push("--provider", "none", "--native-policy", "--task", String(data["task"]), "--profile", data["task"] === "mechanical" ? "economy" : data["task"] === "standard" ? "balanced" : "quality");
               const result6 = await this.call(args);
               const report = result6.data;
               if (report === null || result6.exitCode !== 0 || report.conflicts.length > 0 || report.actions.length === 0 || !report.persisted || report.planId === null) {
                 const subject = setupProvider !== null ? `${name(agent.harnessId)} \xB7 ${name(setupProvider)}` : name(agent.harnessId);
-                notices.push(`${subject}: ${explainGuideIssue(result6.diagnostics, data["action"] === "effort" ? "No supported preference change is needed or available. Your current preference is kept." : data["action"] === "skill" ? "In-session guidance is already present, or an existing user-owned skill location was left untouched." : "No safe setup change is available for the current provider, agent version and platform.")}`);
+                notices.push(`${subject}: ${explainGuideIssue(result6.diagnostics, data["action"] === "effort" ? "No supported preference change is needed or available. Your current preference is kept." : data["action"] === "skill" ? "In-session guidance is already present, or an existing user-owned skill location was left untouched." : data["action"] === "routing-enable" || data["action"] === "routing-disable" ? "No safe native prompt-routing change is available for the current harness, hook state and ownership evidence." : "No safe setup change is available for the current provider, agent version and platform.")}`);
                 continue;
               }
               plans.push(report.planId);
@@ -35451,6 +36384,8 @@ var init_guided = __esm({
                   description: "Installs one reviewed Token Harness Agent Skill in the standard user skill directory. It does not change model, login, billing, hooks, trust, or the current conversation.",
                   files: 1
                 });
+              } else if (data["action"] === "routing-enable" || data["action"] === "routing-disable") {
+                changes.push(...report.actions.map((action2) => describeChange(action2, agent.harnessId)));
               } else {
                 changes.push(...report.actions.map((action2) => describeChange(action2, agent.harnessId)));
               }
@@ -35468,7 +36403,7 @@ var init_guided = __esm({
               plans,
               transactionId: null,
               provider: null,
-              description: data["action"] === "effort" ? "Task preference" : data["action"] === "skill" ? "In-session guidance" : "Integration setup",
+              description: data["action"] === "effort" ? "Task preference" : data["action"] === "skill" ? "In-session guidance" : data["action"] === "routing-enable" || data["action"] === "routing-disable" ? "Automatic prompt routing" : "Integration setup",
               operation: "apply",
               network
             };
@@ -35480,7 +36415,7 @@ var init_guided = __esm({
             notices,
             expiresAt: id === null ? null : new Date(expires).toISOString(),
             network,
-            restart: data["action"] === "effort" || data["action"] === "skill"
+            restart: data["action"] === "effort" || data["action"] === "skill" || data["action"] === "routing-enable" || data["action"] === "routing-disable"
           };
         });
       }
@@ -38470,6 +39405,31 @@ var init_guided_product_client = __esm({
           'caption',
         ),
       );
+      const routing = agent.promptRouting;
+      const routingCard = node('div', undefined, 'routing-feature');
+      const routingHead = node('div', undefined, 'tool-head');
+      routingHead.append(
+        node('strong', 'Automatic prompt routing'),
+        pill(routing?.label || 'Not verified', routing?.state === 'managed' ? 'good' : routing?.state === 'absent' ? '' : 'warn'),
+      );
+      routingCard.append(
+        routingHead,
+        node(
+          'p',
+          routing?.detail || 'A native hook can inject the routing policy on every submitted prompt. Setup and runtime activity are tracked separately.',
+          'caption',
+        ),
+      );
+      const routingActions = node('div', undefined, 'inline-actions');
+      if (routing?.state === 'absent') {
+        routingActions.append(actionButton('Enable routing', () => reviewPromptRouting(agent.id, true), 'secondary'));
+      } else if (routing?.state === 'managed') {
+        routingActions.append(actionButton('Disable routing', () => reviewPromptRouting(agent.id, false), 'secondary'));
+      } else if (routing?.state === 'external') {
+        routingActions.append(node('span', 'Managed elsewhere · left untouched', 'caption'));
+      }
+      if (routingActions.children.length) routingCard.append(routingActions);
+      card.append(routingCard);
       if (baseline.unavailable.length) {
         const details = node('details', undefined, 'agent-details');
         details.append(node('summary', 'Connection limitations'));
@@ -38561,6 +39521,57 @@ var init_guided_product_client = __esm({
       });
   }
 
+  function reviewPromptRouting(agentId, enabled) {
+    if (busy) return;
+    const run = modal((enabled ? 'Enable' : 'Disable') + ' automatic routing · ' + agentName(agentId));
+    $('modal-content').append(
+      messageBox(
+        'How this works',
+        enabled
+          ? 'Token Harness adds a native UserPromptSubmit hook that supplies a short routing policy on each prompt. The agent may delegate eligible bounded work to a lower-cost native subagent; the root model stays the same.'
+          : 'Token Harness removes only the exact native routing entries it owns. User-edited or manually installed hooks remain untouched.',
+      ),
+      progress('Preparing a read-only plan', 'No harness settings change until you approve the exact preview.'),
+    );
+    $('modal-actions').append(modalClose('Cancel'));
+    setBusy(true, false);
+    ensureSession()
+      .then(() => request('/api/preview', {
+        action: enabled ? 'routing-enable' : 'routing-disable',
+        harness: agentId,
+      }))
+      .then(data => {
+        if (run !== modalRun || !$('modal').open) return;
+        pendingTicket = data.ticket;
+        $('modal-content').replaceChildren();
+        for (const change of data.changes || []) {
+          const item = node('article', undefined, 'preview-change');
+          item.append(node('h3', change.title), node('p', change.description));
+          $('modal-content').append(item);
+        }
+        if (!(data.changes || []).length)
+          $('modal-content').append(messageBox('No change proposed', (data.notices || []).join(' ') || 'The current routing state or ownership evidence does not support a safe change.'));
+        for (const notice of data.notices || []) $('modal-content').append(node('p', notice, 'notice-row'));
+        $('modal-content').append(messageBox(
+          agentId === 'codex' ? 'Codex trust step' : 'When it takes effect',
+          agentId === 'codex'
+            ? 'After Apply, review and trust the UserPromptSubmit hook in Codex using /hooks. Until a callback is observed, the dashboard will show it as configured but not runtime verified.'
+            : 'After Apply, start a new Claude Code session. The dashboard will show configured state first and runtime activity after the next prompt callback.',
+          'safe',
+        ));
+        $('modal-actions').replaceChildren(modalClose(data.ticket ? 'Cancel' : 'Done'));
+        if (data.ticket) $('modal-actions').append(actionButton(enabled ? 'Apply routing hook' : 'Remove owned routing hook', () => applyTicket(data.ticket)));
+      })
+      .catch(error => {
+        if (run !== modalRun) return;
+        $('modal-error').textContent = error.message;
+        $('modal-error').hidden = false;
+      })
+      .finally(() => {
+        if (run === modalRun) setBusy(false, false);
+      });
+  }
+
   function reviewSetup(providerId = null) {
     if (busy) return;
     const choices = setupChoiceData(providerId);
@@ -39251,10 +40262,6 @@ var init_guided_product_client = __esm({
         node('strong', component?.configuredHarnesses?.length ? component.configuredHarnesses.map(agentName).join(', ') : 'No detected agent'),
       );
       const measured = rows.filter(row => row.providerId === id);
-      facts.append(
-        node('span', 'Recorded results'),
-        node('strong', measured.length ? measured.length + ' recorded result' + (measured.length === 1 ? '' : 's') : 'None in this period'),
-      );
       card.append(facts);
       if (!measured.length) {
         card.append(
@@ -39358,6 +40365,29 @@ var init_guided_product_client = __esm({
       metricCard('5h / 7d allowance', allowance.value, allowance.detail, allowance.cls),
       metricCard('Quality', quality.value, quality.detail, quality.cls),
     );
+    const routed = current?.value?.routing;
+    const quotaParts = [];
+    if (routed?.allowance5h?.state === 'measured' && routed.allowance5h.savedPercent !== null)
+      quotaParts.push(routed.allowance5h.savedPercent >= 0
+        ? '5h saved ' + count(routed.allowance5h.savedPercent) + '%'
+        : '5h use +' + count(Math.abs(routed.allowance5h.savedPercent)) + '%');
+    if (routed?.allowance7d?.state === 'measured' && routed.allowance7d.savedPercent !== null)
+      quotaParts.push(routed.allowance7d.savedPercent >= 0
+        ? '7d saved ' + count(routed.allowance7d.savedPercent) + '%'
+        : '7d use +' + count(Math.abs(routed.allowance7d.savedPercent)) + '%');
+    const routingValue = routed?.state === 'blocked-by-quality'
+      ? 'Not credited'
+      : routed?.savedLocalTokens !== null && routed?.savedLocalTokens !== undefined
+        ? (routed.savedLocalTokens >= 0
+          ? count(routed.savedLocalTokens) + ' tokens saved' + (routed.localTokenSavingPercent === null ? '' : ' · ' + count(routed.localTokenSavingPercent) + '%')
+          : count(Math.abs(routed.savedLocalTokens)) + ' tokens added' + (routed.localTokenSavingPercent === null ? '' : ' · ' + count(Math.abs(routed.localTokenSavingPercent)) + '%'))
+        : quotaParts.length ? 'Allowance measured' : routed?.state === 'measured' ? 'Usage unavailable' : 'Not measured yet';
+    const routingDetail = routed?.state === 'blocked-by-quality'
+      ? routed.basis
+      : (quotaParts.length ? quotaParts.join(' · ') + '. ' : '') +
+        (routed?.pairs ? count(routed.pairs) + ' quality-passed routed pair(s). ' : '') +
+        'Local tokens and allowance percentages are separate measurements. Actual child model is not exposed by every harness hook.';
+    $('result-summary').append(metricCard('Automatic routing', routingValue, routingDetail, routed?.state === 'measured' ? 'positive' : ''));
     renderResultOptimizers();
     renderResultAgents();
     renderSavings();
@@ -39505,6 +40535,7 @@ var init_guided_product_styles = __esm({
 .setup-step{margin:1.6rem 0}.step-heading{display:grid;grid-template-columns:34px 1fr;gap:.65rem;align-items:start;margin-bottom:.7rem}.step-number{display:grid;place-items:center;width:32px;height:32px;border-radius:9px;background:var(--accent);color:#fff;font-weight:900}.step-heading h2{margin:0}.step-heading p{margin:.2rem 0;color:var(--muted)}
 .connection-overview{display:grid;gap:.75rem}.connection-summary{display:flex;align-items:center;justify-content:space-between;gap:1rem;background:var(--panel);border:1px solid var(--line);border-radius:var(--radius);padding:1rem}.connection-summary p{margin:.15rem 0 0}.connection-scroll{overflow-x:auto;border:1px solid var(--line);border-radius:var(--radius);background:var(--panel)}.connection-table{min-width:max(720px,100%)}.connection-row{display:grid;grid-template-columns:minmax(170px,1.25fr) repeat(var(--connection-columns),minmax(130px,1fr)) minmax(155px,.8fr);align-items:center;gap:.6rem;padding:.72rem .8rem;border-bottom:1px solid var(--line)}.connection-row:last-child{border-bottom:0}.connection-head{background:var(--panel-soft);color:var(--muted);font-size:.8rem}.connection-name{display:grid;gap:.12rem}.connection-cell,.connection-action{min-width:0}.connection-action{display:flex;justify-content:flex-end}.tool-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:.8rem}.candidate-comparison-toolbar{grid-column:1/-1;justify-content:flex-end;align-self:start}.tool-card{background:var(--panel);border:1px solid var(--line);border-radius:var(--radius);padding:1rem;box-shadow:var(--shadow)}.tool-card.experimental{border-style:dashed}.tool-card.compact{box-shadow:none}.tool-card>p{color:var(--muted);margin:.65rem 0}.tool-head{display:flex;align-items:flex-start;justify-content:space-between;gap:.75rem}.tool-head h3{margin:0}.tool-facts{display:grid;grid-template-columns:auto 1fr;gap:.3rem .75rem;border-top:1px solid var(--line);border-bottom:1px solid var(--line);padding:.65rem 0;margin:.65rem 0}.tool-facts span{color:var(--muted);font-size:.8rem}.tool-facts strong{font-size:.85rem}
 .connection-role{max-width:28ch}.setup-choice-list{display:grid;gap:.55rem;margin:.9rem 0}.setup-choice-list h3{margin:.25rem 0 0}.setup-choice{display:grid;grid-template-columns:auto 1fr;align-items:start;gap:.7rem;padding:.8rem;border:1px solid var(--line);border-radius:12px;background:var(--panel);cursor:pointer}.setup-choice:hover{border-color:var(--accent);background:var(--accent-soft)}.setup-choice input{inline-size:1.1rem;block-size:1.1rem;margin:.15rem 0 0;accent-color:var(--accent)}.setup-choice-copy{display:grid;gap:.2rem}.setup-choice-limitation{color:var(--muted)}
+.routing-feature{margin:.8rem 0;padding:.8rem;border:1px solid var(--line);border-radius:12px;background:var(--panel-soft)}.routing-feature .tool-head{align-items:center}.routing-feature p{margin:.55rem 0;color:var(--muted)}
 .managed-action-box{margin-top:.8rem;background:var(--panel-soft);border:1px solid var(--line);border-radius:12px;padding:.85rem}.managed-action-box p{margin:.1rem 0 .65rem}
 .maintenance-list{display:grid;gap:.55rem}.maintenance-row{display:flex;align-items:center;justify-content:space-between;gap:1rem;background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:.8rem}.maintenance-row p{margin:.15rem 0}
 .explain-box{background:var(--panel-soft);border:1px solid var(--line);border-radius:12px;padding:.8rem;margin:.6rem 0}.explain-box p{margin:.25rem 0;color:var(--muted)}.explain-box.warn{background:var(--warn-soft);border-color:color-mix(in srgb,var(--warn) 35%,var(--line))}.explain-box.safe{background:var(--good-soft);border-color:color-mix(in srgb,var(--good) 30%,var(--line))}.operation-progress{margin:.75rem 0;padding:.8rem;border:1px solid var(--line);border-radius:12px}.operation-progress p{margin:.35rem 0 0}
@@ -40185,7 +41216,7 @@ ${GUIDE_CANDIDATE_READINESS_JS}`;
 </div>
 
 <section class="setup-step" id="coding-agents">
-<div class="section-title"><div><h2>Coding agents</h2><p>Detected coding apps are shown here as status. Optimizer setup is managed centrally below; a detected setup does not prove that it ran or recorded results.</p></div></div>
+<div class="section-title"><div><h2>Coding agents</h2><p>Enable automatic per-prompt routing here for each detected coding app. The card distinguishes hook configuration from callbacks actually observed at runtime.</p></div></div>
 <div id="setup-agents" class="tool-grid"><article class="tool-card"><h3>Checking agents\u2026</h3></article></div>
 <details class="disclosure advanced-disclosure">
 <summary>Agent details and optional reasoning settings</summary>
@@ -40653,6 +41684,19 @@ async function runAsDatabaseReader(argv2) {
   process5.exitCode = 0;
   return true;
 }
+function parsePromptRouterEvent(value3) {
+  if (value3 === "prompt-submit" || value3 === "subagent-start" || value3 === "subagent-stop")
+    return value3;
+  return null;
+}
+function emitPromptRouterContext(harness) {
+  process5.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "UserPromptSubmit",
+      additionalContext: ROUTING_CONTEXT[harness]
+    }
+  }) + "\n");
+}
 async function readStandardInput() {
   const chunks = [];
   let bytes = 0;
@@ -40677,6 +41721,16 @@ async function main(argv2) {
     }
     return;
   }
+  if (argv2[0] === PROMPT_ROUTER_FLAG && argv2[2] === "--check") {
+    if (argv2[1] === "claude" || argv2[1] === "codex") {
+      process5.stdout.write(`${PROMPT_ROUTER_CHECK_MARKER2}
+`);
+      process5.exitCode = EXIT_CODES.ok;
+    } else {
+      process5.exitCode = EXIT_CODES["usage-error"];
+    }
+    return;
+  }
   const opensGuide = argv2.length === 0 || argv2[0] === "start" || argv2[0] === "ui";
   const readOnly = argv2.includes("--read-only");
   const uiInvocation = opensGuide ? parseUiArgs(argv2.slice(1).filter((arg) => arg !== "--read-only")) : null;
@@ -40746,6 +41800,34 @@ Run token-harness ui --help for usage.
     env: process5.env,
     stdoutIsTty: process5.stdout.isTTY === true
   };
+  if (argv2[0] === PROMPT_ROUTER_FLAG) {
+    const selected = argv2[1];
+    const event = parsePromptRouterEvent(argv2[2]);
+    if (selected !== "claude" && selected !== "codex" || event === null) {
+      process5.exitCode = EXIT_CODES.ok;
+      return;
+    }
+    const input = await readStandardInput();
+    if (resolution.ok && fs !== null && input !== null) {
+      try {
+        const projectId = attribution.salt === null ? null : deriveProjectId(process5.cwd(), attribution.salt, resolution.environment.facts.os === "windows");
+        await recordNativePromptRoutingHook({
+          fs,
+          stateRoot: resolution.environment.paths.state,
+          harness: selected,
+          event,
+          projectId,
+          now: (/* @__PURE__ */ new Date()).toISOString(),
+          hookInput: input
+        });
+      } catch {
+      }
+    }
+    if (event === "prompt-submit")
+      emitPromptRouterContext(selected);
+    process5.exitCode = EXIT_CODES.ok;
+    return;
+  }
   if (argv2[0] === RTK_HOOK_PROXY_FLAG) {
     const selected = argv2[1];
     if (selected !== "claude" && selected !== "codex") {
@@ -40968,6 +42050,35 @@ async function runGuidedUi(options, base) {
       stateRoot: base.stateRoot ?? null,
       harness
     });
+  }, async (harness) => {
+    if (base.adapters === null || base.adapters === void 0 || base.platform === null) {
+      return {
+        harness,
+        state: "unavailable",
+        label: "Not verified",
+        detail: "The local filesystem is unavailable, so native prompt routing cannot be checked.",
+        configPath: null,
+        configured: null,
+        promptSubmissions: 0,
+        subagentsStarted: 0,
+        subagentsStopped: 0,
+        reportedModels: [],
+        lastObservedAt: null,
+        receiptState: "unavailable"
+      };
+    }
+    return observeNativePromptRouting({
+      fs: base.adapters.fs,
+      home: base.home,
+      stateRoot: base.stateRoot ?? null,
+      harness: harnessId(harness),
+      version: null,
+      runner: base.adapters.runner,
+      facts: base.platform,
+      paths: base.adapters.paths,
+      projectRoot: base.cwd,
+      projectId: base.adapters.projectIdFor(base.cwd)
+    });
   });
   const token = randomBytes2(32).toString("hex");
   let authority = "";
@@ -41068,7 +42179,7 @@ async function runSavingsView(args, base) {
   }
   return result6.exitCode;
 }
-var RTK_HOOK_PROXY_FLAG, MAX_HOOK_INPUT_BYTES, UI_SECURITY_HEADERS;
+var RTK_HOOK_PROXY_FLAG, PROMPT_ROUTER_FLAG, PROMPT_ROUTER_CHECK_MARKER2, MAX_HOOK_INPUT_BYTES, ROUTING_CONTEXT, UI_SECURITY_HEADERS;
 var init_main = __esm({
   "apps/cli/dist/src/main.js"() {
     "use strict";
@@ -41079,11 +42190,19 @@ var init_main = __esm({
     init_version2();
     init_guided();
     init_agent_skill();
+    init_prompt_router();
     init_guided_candidate_campaign_status();
     init_guided_http();
     init_rtk_hook_proxy();
+    init_prompt_router();
     RTK_HOOK_PROXY_FLAG = "__internal-rtk-hook";
+    PROMPT_ROUTER_FLAG = "__internal-prompt-router";
+    PROMPT_ROUTER_CHECK_MARKER2 = "token-harness-prompt-router-v1";
     MAX_HOOK_INPUT_BYTES = 1024 * 1024;
+    ROUTING_CONTEXT = {
+      codex: "For substantial coding work, delegate at most one independent bounded subtask to a native subagent with gpt-6-luna if available and the root is not Luna. Keep trivial, coupled, security, architecture, release, and integration decisions on the root. Specify the model; if unavailable, stay on the root. The root reviews. Claim savings only from paired, quality-gated measurements.",
+      claude: "For substantial coding work, delegate at most one independent bounded subtask to a native subagent with the current Haiku alias if available and cheaper than the root. Keep trivial, coupled, security, architecture, release, and integration decisions on the root. Specify the model; if unavailable, stay on the root. The root reviews. Claim savings only from paired, quality-gated measurements."
+    };
     UI_SECURITY_HEADERS = {
       "Cache-Control": "no-store",
       "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self' data:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'",