instar 1.3.771 → 1.3.773

package/dist/core/IntelligenceRouter.d.ts

@@ -26,7 +26,7 @@
 import type { IntelligenceProvider, IntelligenceOptions } from './types.js';
 import type { IntelligenceFramework } from './intelligenceProviderFactory.js';
 import { type ComponentCategory } from './componentCategories.js';
-import { type RoutingNature } from '../data/llmBenchCoverage.js';
+import { type RoutingNature, type TaskNature, type RoutingChain, type RoutingDoor, type ChainPosition, type NatureRoutingChains } from '../data/llmBenchCoverage.js';
 export interface ComponentFrameworksConfig {
     /** Framework for anything not otherwise specified. Defaults to the router's defaultFramework. */
     default?: IntelligenceFramework;
@@ -158,6 +158,23 @@ export interface IntelligenceRouterOptions {
         /** Bound (ms) for a single enqueued deferrable call so a stuck/abandoned one self-terminates. */
         queueAttemptTimeoutMs?: number;
     };
+    /**
+     * S4 A2 — the live, dev-gate-RESOLVED view of `sessions.natureRouting` (read on EVERY
+     * call so the kill switch is hot). `enabled` is already the gate-resolved boolean
+     * (resolved at the construction boundary, like `ladder`). Absent OR `enabled:false`
+     * ⇒ the nature router is inert and routing is BYTE-IDENTICAL to today. When enabled +
+     * dryRun (the dev-agent default) the resolver OBSERVES (computes + logs the plan via
+     * `onNatureRoutePlan`) and still passes through to today's selection. Enforcing
+     * selection (dryRun:false) is a tracked A2.2 remainder.
+     */
+    resolveNatureRouting?: () => NatureRoutingRuntime | undefined;
+    /**
+     * S4 A2 — the dryRun observation sink (FD11 readable canary). Invoked with the resolved
+     * plan when nature routing is enabled + dryRun. No-op downstream by default; the router
+     * calls it freely. The durable `logs/nature-routing.jsonl` + `GET /intelligence/routing`
+     * surfaces that consume this are a tracked A2.2 remainder.
+     */
+    onNatureRoutePlan?: (plan: NatureRoutePlan) => void;
 }
 /**
  * resolveSwapCap — per-TARGET swap-attempt cap resolution
@@ -224,6 +241,146 @@ export declare function routingNatureFor(component: string | undefined): Routing
  * map, so it never depends on `sessions.natureRouting` being set.
  */
 export declare function isBoundedGatingDegrade(component: string | undefined, options?: IntelligenceOptions): boolean;
+/**
+ * The critical-gate fail-closed outcome (spec CR10-3/CR8-4): a DISTINCT typed error
+ * so a caller can never mistake it for an ordinary model failure. A mapped FD6
+ * critical gate whose chain has NO available door throws this; the caller applies its
+ * existing gating fail-closed semantics (block/deny). The low-stakes empty-set case is
+ * deliberately the ordinary non-gating error instead ('no-route'), typed apart on purpose.
+ */
+export declare class RouterFailClosedError extends Error {
+    readonly component: string | undefined;
+    readonly resolvedChain: RoutingChain;
+    constructor(component: string | undefined, resolvedChain: RoutingChain);
+}
+/** A chain position resolved to a concrete model id, after the FD4 allowlist clamp. */
+export interface ResolvedRoutePosition {
+    readonly door: RoutingDoor;
+    /** The original benchmark label / tier hint from the chain position. */
+    readonly label: string;
+    /** The concrete model id the door should be asked for (post-registry, post-clamp). */
+    readonly modelId: string;
+    /** Whether the FD4 harness-door allowlist clamp rewrote this position to the reserve id. */
+    readonly clamped: boolean;
+}
+/** The four load-bearing `resolveRoute` outcomes (verifier r7 — never collapse them). */
+export type RouteResolution = {
+    outcome: 'route';
+    resolvedNature: TaskNature;
+    resolvedChain: RoutingChain;
+    primary: ResolvedRoutePosition;
+    swapTail: ResolvedRoutePosition[];
+} | {
+    outcome: 'fall-through';
+} | {
+    outcome: 'no-route';
+};
+/**
+ * FD3 — resolve `{ resolvedNature, resolvedChain }` from the component's static map row
+ * and an optional caller-declared `attribution.nature`. The component's OWN map row
+ * `{nature, chain}` is authoritative by default (preserving a per-component A/FAST vs
+ * A/SORT choice a pure nature→chain function could not). A caller-declared nature that
+ * TIGHTENS (strictly raises the tier) replaces the chain with the deterministically
+ * safe `JUDGE`; anything else is ignored. Returns `undefined` for an unmapped component.
+ * Pure — always available, independent of `sessions.natureRouting`.
+ */
+export declare function resolveNatureAndChain(component: string | undefined, declaredNature?: unknown): {
+    resolvedNature: TaskNature;
+    resolvedChain: RoutingChain;
+} | undefined;
+/**
+ * FD-LABEL / FD4.1 — resolve a chain position's `model` label to a concrete model id via
+ * `ROUTING_LABEL_TO_MODEL_ID`. A label absent from the registry (a tier hint like `fast`
+ * / `capable`) passes through unchanged and is resolved downstream by the existing
+ * per-adapter tier map. Pure.
+ */
+export declare function resolvePositionModelId(pos: ChainPosition): string;
+/**
+ * FD4 place 3 — the harness-door ALLOWLIST clamp (deny-by-default), the nature-routing
+ * RUNTIME safety guarantee. For a bounded/gating (FAST/SORT/JUDGE) chain, the ONLY
+ * permitted `claude-code` position is the single sanctioned CONCRETE reserve id
+ * (`CLAUDE_CODE_RESERVE_MODEL_ID`); any OTHER claude-code id is clamped down to it. This
+ * is an allowlist, NOT a denylist — a future/unrecognized capable Claude id can never
+ * slip past. `WRITE` is exempt (its Opus-via-CLI quality lane is legitimate), and every
+ * non-claude-code door passes through.
+ *
+ * DELIBERATELY SEPARATE from A1's `clampClaudeCliSwapModel` (which returns the `balanced`
+ * TIER token and fires UNCONDITIONALLY on the always-on degrade/swap path): touching that
+ * function would change A1's shipped, byte-identical-when-off behavior. This clamp is
+ * nature-routing-scoped and concrete-id-based (FD4.1), applied only inside `resolveRoute`.
+ */
+export declare function clampToReserveOnCleanDoor(pos: ResolvedRoutePosition, resolvedChain: RoutingChain): ResolvedRoutePosition;
+/** The three FD4 static-ban rules a chain position can violate. */
+export type NatureChainBanRule = 'claude-code-non-reserve' | 'claude-code-tier-label' | 'fable-banned';
+/** One authored chain position that violates the FD4 harness-door ban. */
+export interface NatureChainViolation {
+    chain: RoutingChain;
+    index: number;
+    door: RoutingDoor;
+    model: string;
+    resolvedModelId: string;
+    rule: NatureChainBanRule;
+    detail: string;
+}
+/** A model label/id names a Fable model — FD8 §393, never emitted by any nature chain. Pure. */
+export declare function isFableModel(s: string): boolean;
+/**
+ * Validate ONE chain position against the FD4 static ban (pure). Returns a violation or
+ * null. The claude-code allowlist test compares the REGISTRY-RESOLVED concrete id against
+ * the single sanctioned reserve id (FD4.1 — a tier label is permitted ONLY because/if it
+ * pins through `ROUTING_LABEL_TO_MODEL_ID` to that concrete id; an unpinned label fails).
+ */
+export declare function validateChainPosition(chain: RoutingChain, pos: ChainPosition, index: number): NatureChainViolation | null;
+/** Validate ONE chain's positions against the FD4 ban (pure). */
+export declare function validateNatureRoutingChain(chain: RoutingChain, positions: ReadonlyArray<ChainPosition>): NatureChainViolation[];
+/** Validate ALL four chains against the FD4 ban (pure). Empty array ⇒ the chain map is clean. */
+export declare function validateNatureRoutingChains(chains: NatureRoutingChains): NatureChainViolation[];
+/** True iff every chain passes the FD4 static harness-door ban. Pure. */
+export declare function isNatureRoutingChainsValid(chains: NatureRoutingChains): boolean;
+/**
+ * The PURE nature-routing fold (spec §Resolver, steps 1–7). Deps are injected so the
+ * function is side-effect-free + trivially testable: `isDoorReachable` reports CLI-door
+ * reachability (the class wraps its provider cache). Metered doors are ALWAYS skipped in
+ * Increment A. The empty-`available` branch splits by authority class (CR6-2/CR3-1):
+ * unmapped → 'fall-through'; low-stakes mapped → 'no-route'; FD6 critical gate → throw
+ * RouterFailClosedError. (The R6 doc-tree refuse-to-author branch is a tracked A2.2
+ * remainder; until it lands a `claudeBanned` component falls into the low-stakes 'no-route'
+ * path — never onto Claude, since resolveRoute never emits a claude-code position for it
+ * unless its chain contains one, and R6 chains are authored off-Claude.)
+ */
+export declare function resolveRoute(component: string | undefined, declaredNature: unknown, chains: NatureRoutingChains, deps: {
+    isDoorReachable: (door: RoutingDoor) => boolean;
+    /** FD4.3 — called when a live chain is rejected for a harness-door-ban violation (→ defaults). */
+    onInvalidChain?: (chain: RoutingChain, violations: NatureChainViolation[]) => void;
+}): RouteResolution;
+/**
+ * Merge an operator's partial `chains` override (config) over the built-in v3 defaults,
+ * per-chain. A chain the operator did not override keeps its default. (The FD4.3
+ * resolve-time validation that REJECTS a harness-door-violating override → defaults +
+ * notice is a tracked A2.2 remainder; the FD4 place-3 runtime clamp above already keeps
+ * the banned route closed on every resolved position regardless.)
+ */
+export declare function mergeNatureRoutingChains(override: Partial<Record<RoutingChain, ReadonlyArray<ChainPosition>>> | undefined, onReject?: (chain: RoutingChain, violations: NatureChainViolation[]) => void): NatureRoutingChains;
+/**
+ * The dev-gate-resolved live view of `sessions.natureRouting` the router reads per call.
+ * `enabled` is ALREADY gate-resolved at the construction boundary (like `ladder`), so the
+ * router just reads the boolean. Absent ⇒ feature off ⇒ byte-identical routing.
+ */
+export interface NatureRoutingRuntime {
+    enabled: boolean;
+    /** Observe-only (default true on first enable): compute + log the plan, do NOT re-route. */
+    dryRun: boolean;
+    chains?: Partial<Record<RoutingChain, ReadonlyArray<ChainPosition>>>;
+}
+/** The dryRun observation record handed to `onNatureRoutePlan` (FD11 readable canary). */
+export interface NatureRoutePlan {
+    component: string | undefined;
+    category: ComponentCategory;
+    dryRun: boolean;
+    resolution?: RouteResolution;
+    /** Set when the resolver would FAIL CLOSED (critical-gate empty set). */
+    failClosed?: boolean;
+}
 export declare class IntelligenceRouter implements IntelligenceProvider {
     private readonly opts;
     private readonly cache;
@@ -261,6 +418,32 @@ export declare class IntelligenceRouter implements IntelligenceProvider {
     private providerFor;
     /** Default framework → shared provider; else the cached per-framework provider (null if binary missing). */
     private resolveProvider;
+    /** Already warned that nature-routing enforcing mode is not yet wired (warn ONCE). */
+    private warnedNatureEnforceNotWired;
+    /**
+     * S4 A2 — CLI-door reachability probe for the nature router (FD5 availability walk).
+     * CLI doors coincide 1:1 with `IntelligenceFramework`. `resolveRoute` skips metered
+     * doors before ever calling this, so `door` is always a CLI door. The default framework
+     * is always reachable (shared provider); a non-default door is reachable iff its provider
+     * builds (binary present). Result is cached by `providerFor`.
+     */
+    private isCliDoorReachable;
+    /**
+     * S4 A2 — enforcing-mode honesty guard. Flipping `dryRun:false` in A2.1 does NOT re-route
+     * (the selection integration is a tracked A2.2 remainder); routing stays byte-identical.
+     * Warn ONCE so the flip is an honest no-op rather than a silent dead switch.
+     */
+    private warnNatureEnforceNotWired;
+    /** Chains already warned about as rejected (warn ONCE per chain, never per call). */
+    private warnedRejectedChains?;
+    /**
+     * FD4.3 — a live/hot chain (an operator `PATCH /config` override, or a resolved chain)
+     * violated the static harness-door ban and was REJECTED → built-in defaults. Warn ONCE
+     * per chain so the rejection is visible (the banned route is never opened; the built-in
+     * default is used instead). The full FD6 aggregated critical-gate attention item is a
+     * tracked A2.2 remainder; this is the honest, non-silent minimum.
+     */
+    private warnNatureChainRejected;
     evaluate(prompt: string, options?: IntelligenceOptions): Promise<string>;
     /**
      * Queue rung (Resilient Degradation Ladder §3b.3) — DEFERRABLE calls only. Enqueue the SAME

package/dist/core/IntelligenceRouter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntelligenceRouter.d.ts","sourceRoot":"","sources":["../../src/core/IntelligenceRouter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"IntelligenceRouter.d.ts","sourceRoot":"","sources":["../../src/core/IntelligenceRouter.ts"],"names":[],"mappings":"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"}

package/dist/core/IntelligenceRouter.js

@@ -24,7 +24,7 @@
  *    outage's worth of calls onto Claude all at once.
  */
 import { isComponentCategory, categoryForComponent, } from './componentCategories.js';
-import { LLM_ROUTING_NATURE } from '../data/llmBenchCoverage.js';
+import { LLM_ROUTING_NATURE, NATURE_ROUTING_DEFAULT_CHAINS, ROUTING_LABEL_TO_MODEL_ID, CLAUDE_CODE_RESERVE_MODEL_ID, METERED_ROUTING_DOORS, NATURE_ROUTING_CRITICAL_GATES, } from '../data/llmBenchCoverage.js';
 /**
  * Runtime framework ids for the unknown-key hygiene warning on
  * `swapAttemptTimeoutMsByFramework` (per-target-swap-timeout-spec.md, change
@@ -174,6 +174,286 @@ export function isBoundedGatingDegrade(component, options) {
         return false; // unmapped + not gating ⇒ out of R1's scope, unchanged
     return row.chain !== 'WRITE'; // WRITE is the sanctioned Opus-CLI lane; everything else is bounded/gating
 }
+/* ────────────────────────────────────────────────────────────────────────────
+ * S4 Increment A2 — the nature-axis routing RESOLVER (dark/dryRun mechanism).
+ *
+ * `resolveRoute` is a PURE, side-effect-free evaluator (spec CR2-5): a stateless
+ * fold `component → resolvedNature → ordered eligible positions → { primary, swapTail }
+ * | 'fall-through' | 'no-route' | throw`. It owns no retry/backoff/breaker/budget
+ * machinery — those stay in the existing IntelligenceRouter primitives. Wired into
+ * `evaluate()` ONLY when `sessions.natureRouting.enabled` (dev-gated dark). In dryRun
+ * (the dev-agent default) it OBSERVES: computes + logs the plan, then passes through to
+ * today's routing (byte-identical selection). Enforcing selection (dryRun:false) is a
+ * tracked A2.2 remainder — see the honest guard in `evaluate()`.
+ * Spec: docs/specs/nature-axis-routing.md §Resolver / FD3 / FD4 / FD9.
+ * ──────────────────────────────────────────────────────────────────────────── */
+/**
+ * The critical-gate fail-closed outcome (spec CR10-3/CR8-4): a DISTINCT typed error
+ * so a caller can never mistake it for an ordinary model failure. A mapped FD6
+ * critical gate whose chain has NO available door throws this; the caller applies its
+ * existing gating fail-closed semantics (block/deny). The low-stakes empty-set case is
+ * deliberately the ordinary non-gating error instead ('no-route'), typed apart on purpose.
+ */
+export class RouterFailClosedError extends Error {
+    component;
+    resolvedChain;
+    constructor(component, resolvedChain) {
+        super(`RouterFailClosedError: critical gate '${component ?? '(none)'}' has no available door on ` +
+            `chain ${resolvedChain} — failing closed (never legacy category routing, never the harness door)`);
+        this.component = component;
+        this.resolvedChain = resolvedChain;
+        this.name = 'RouterFailClosedError';
+    }
+}
+/**
+ * Tier ordering for the FD3 nature tighten rule `E, B ≥ D ≥ A`. E and B are
+ * EQUIVALENT (both JUDGE-tier). A caller-declared nature may only ever RAISE the tier
+ * (tighten, the safe direction); a same-tier or lower declared nature is ignored (map
+ * wins), and a value outside {A,B,D,E} is ignored.
+ */
+const NATURE_TIER_RANK = { A: 0, D: 1, B: 2, E: 2 };
+function isTaskNature(v) {
+    return v === 'A' || v === 'B' || v === 'D' || v === 'E';
+}
+/**
+ * FD3 — resolve `{ resolvedNature, resolvedChain }` from the component's static map row
+ * and an optional caller-declared `attribution.nature`. The component's OWN map row
+ * `{nature, chain}` is authoritative by default (preserving a per-component A/FAST vs
+ * A/SORT choice a pure nature→chain function could not). A caller-declared nature that
+ * TIGHTENS (strictly raises the tier) replaces the chain with the deterministically
+ * safe `JUDGE`; anything else is ignored. Returns `undefined` for an unmapped component.
+ * Pure — always available, independent of `sessions.natureRouting`.
+ */
+export function resolveNatureAndChain(component, declaredNature) {
+    const row = routingNatureFor(component);
+    if (!row)
+        return undefined;
+    const tightened = isTaskNature(declaredNature) && NATURE_TIER_RANK[declaredNature] > NATURE_TIER_RANK[row.nature];
+    if (tightened) {
+        // A tightened nature is always B or E (you only tighten UP a tier) → JUDGE ladder.
+        return { resolvedNature: declaredNature, resolvedChain: 'JUDGE' };
+    }
+    return { resolvedNature: row.nature, resolvedChain: row.chain };
+}
+/**
+ * FD-LABEL / FD4.1 — resolve a chain position's `model` label to a concrete model id via
+ * `ROUTING_LABEL_TO_MODEL_ID`. A label absent from the registry (a tier hint like `fast`
+ * / `capable`) passes through unchanged and is resolved downstream by the existing
+ * per-adapter tier map. Pure.
+ */
+export function resolvePositionModelId(pos) {
+    return ROUTING_LABEL_TO_MODEL_ID[pos.door]?.[pos.model] ?? pos.model;
+}
+/**
+ * FD4 place 3 — the harness-door ALLOWLIST clamp (deny-by-default), the nature-routing
+ * RUNTIME safety guarantee. For a bounded/gating (FAST/SORT/JUDGE) chain, the ONLY
+ * permitted `claude-code` position is the single sanctioned CONCRETE reserve id
+ * (`CLAUDE_CODE_RESERVE_MODEL_ID`); any OTHER claude-code id is clamped down to it. This
+ * is an allowlist, NOT a denylist — a future/unrecognized capable Claude id can never
+ * slip past. `WRITE` is exempt (its Opus-via-CLI quality lane is legitimate), and every
+ * non-claude-code door passes through.
+ *
+ * DELIBERATELY SEPARATE from A1's `clampClaudeCliSwapModel` (which returns the `balanced`
+ * TIER token and fires UNCONDITIONALLY on the always-on degrade/swap path): touching that
+ * function would change A1's shipped, byte-identical-when-off behavior. This clamp is
+ * nature-routing-scoped and concrete-id-based (FD4.1), applied only inside `resolveRoute`.
+ */
+export function clampToReserveOnCleanDoor(pos, resolvedChain) {
+    if (resolvedChain === 'WRITE')
+        return pos; // WRITE is the sole Opus-via-CLI-exempt lane
+    if (pos.door !== 'claude-code')
+        return pos; // the ban applies only to the harness door
+    if (pos.modelId === CLAUDE_CODE_RESERVE_MODEL_ID)
+        return pos; // allowlisted — the sanctioned reserve
+    return { ...pos, modelId: CLAUDE_CODE_RESERVE_MODEL_ID, clamped: true }; // deny-by-default → reserve
+}
+/** Tier LABELS (as opposed to concrete model ids) — for message classification only; not load-bearing. */
+const KNOWN_TIER_LABELS = new Set([
+    'fast',
+    'balanced',
+    'capable',
+    'ultra',
+    'reasoning',
+]);
+/** A model label/id names a Fable model — FD8 §393, never emitted by any nature chain. Pure. */
+export function isFableModel(s) {
+    return /fable/i.test(s);
+}
+/**
+ * Validate ONE chain position against the FD4 static ban (pure). Returns a violation or
+ * null. The claude-code allowlist test compares the REGISTRY-RESOLVED concrete id against
+ * the single sanctioned reserve id (FD4.1 — a tier label is permitted ONLY because/if it
+ * pins through `ROUTING_LABEL_TO_MODEL_ID` to that concrete id; an unpinned label fails).
+ */
+export function validateChainPosition(chain, pos, index) {
+    const resolvedModelId = ROUTING_LABEL_TO_MODEL_ID[pos.door]?.[pos.model] ?? pos.model;
+    // FD8 §393 — no chain (incl. the Opus-CLI-exempt WRITE lane) may resolve to a Fable model.
+    if (isFableModel(resolvedModelId) || isFableModel(pos.model)) {
+        return {
+            chain,
+            index,
+            door: pos.door,
+            model: pos.model,
+            resolvedModelId,
+            rule: 'fable-banned',
+            detail: `chain ${chain}[${index}] (${pos.door}/'${pos.model}') resolves to a Fable model ` +
+                `('${resolvedModelId}') — no nature chain may emit Fable (FD8 §393).`,
+        };
+    }
+    // The FD4 harness-door ban is scoped to bounded/gating chains; WRITE is the sole
+    // Opus-via-CLI-exempt lane (open-ended writing is where Opus-via-CLI is the best route).
+    if (chain === 'WRITE')
+        return null;
+    if (pos.door !== 'claude-code')
+        return null; // the ban targets ONLY the harness door
+    if (resolvedModelId === CLAUDE_CODE_RESERVE_MODEL_ID)
+        return null; // allowlisted — the sanctioned pinned reserve
+    const pinnedInRegistry = ROUTING_LABEL_TO_MODEL_ID['claude-code']?.[pos.model] !== undefined;
+    if (!pinnedInRegistry && KNOWN_TIER_LABELS.has(pos.model)) {
+        return {
+            chain,
+            index,
+            door: pos.door,
+            model: pos.model,
+            resolvedModelId,
+            rule: 'claude-code-tier-label',
+            detail: `chain ${chain}[${index}] is claude-code/'${pos.model}' — an UNPINNED tier label. The one ` +
+                `permitted claude-code position in a bounded/gating (FAST/SORT/JUDGE) chain must be the PINNED ` +
+                `concrete reserve id '${CLAUDE_CODE_RESERVE_MODEL_ID}', not a tier label (FD4 §205: a label could ` +
+                `resolve differently under a future CLI alias/tier remap).`,
+        };
+    }
+    return {
+        chain,
+        index,
+        door: pos.door,
+        model: pos.model,
+        resolvedModelId,
+        rule: 'claude-code-non-reserve',
+        detail: `chain ${chain}[${index}] resolves claude-code → '${resolvedModelId}', which is NOT the sanctioned ` +
+            `reserve '${CLAUDE_CODE_RESERVE_MODEL_ID}'. Deny-by-default allowlist ban — the only permitted ` +
+            `claude-code FAST/SORT/JUDGE position is that single reserve id (FD4 §202-217).`,
+    };
+}
+/** Validate ONE chain's positions against the FD4 ban (pure). */
+export function validateNatureRoutingChain(chain, positions) {
+    const out = [];
+    positions.forEach((p, i) => {
+        const v = validateChainPosition(chain, p, i);
+        if (v)
+            out.push(v);
+    });
+    return out;
+}
+/** Validate ALL four chains against the FD4 ban (pure). Empty array ⇒ the chain map is clean. */
+export function validateNatureRoutingChains(chains) {
+    const out = [];
+    for (const c of ['FAST', 'SORT', 'JUDGE', 'WRITE']) {
+        out.push(...validateNatureRoutingChain(c, chains[c] ?? []));
+    }
+    return out;
+}
+/** True iff every chain passes the FD4 static harness-door ban. Pure. */
+export function isNatureRoutingChainsValid(chains) {
+    return validateNatureRoutingChains(chains).length === 0;
+}
+/** The base component key (strip a "/segment" operation suffix + a `server:` prefix). */
+function baseComponentKey(component) {
+    if (!component)
+        return undefined;
+    return component.split('/')[0].replace(/^server:/, '').trim();
+}
+/**
+ * The PURE nature-routing fold (spec §Resolver, steps 1–7). Deps are injected so the
+ * function is side-effect-free + trivially testable: `isDoorReachable` reports CLI-door
+ * reachability (the class wraps its provider cache). Metered doors are ALWAYS skipped in
+ * Increment A. The empty-`available` branch splits by authority class (CR6-2/CR3-1):
+ * unmapped → 'fall-through'; low-stakes mapped → 'no-route'; FD6 critical gate → throw
+ * RouterFailClosedError. (The R6 doc-tree refuse-to-author branch is a tracked A2.2
+ * remainder; until it lands a `claudeBanned` component falls into the low-stakes 'no-route'
+ * path — never onto Claude, since resolveRoute never emits a claude-code position for it
+ * unless its chain contains one, and R6 chains are authored off-Claude.)
+ */
+export function resolveRoute(component, declaredNature, chains, deps) {
+    const nc = resolveNatureAndChain(component, declaredNature);
+    if (!nc)
+        return { outcome: 'fall-through' }; // unmapped ⇒ legacy category routing (LA5 byte-identical)
+    // FD4.3 resolve-time assertion (spec §221-225 / §Resolver step 3): a live chain that
+    // violates the static harness-door ban is REJECTED → built-in defaults + notice. Because
+    // chains are read live per call and an operator may `PATCH /config` a chain wholesale, this
+    // runs on EVERY resolution (the same predicate the config-load merge + the build-lint use) —
+    // a runtime chain edit can never open the banned route. The per-position clamp below is a
+    // belt-and-suspenders third place; this rejection keeps the whole banned chain out.
+    let positions = chains[nc.resolvedChain] ?? NATURE_ROUTING_DEFAULT_CHAINS[nc.resolvedChain];
+    const chainViolations = validateNatureRoutingChain(nc.resolvedChain, positions);
+    if (chainViolations.length > 0) {
+        deps.onInvalidChain?.(nc.resolvedChain, chainViolations);
+        positions = NATURE_ROUTING_DEFAULT_CHAINS[nc.resolvedChain];
+    }
+    const available = [];
+    for (const p of positions) {
+        // Increment A: metered-API doors are DEFINED but always unavailable (skipped) until Increment B.
+        if (METERED_ROUTING_DOORS.has(p.door))
+            continue;
+        if (!deps.isDoorReachable(p.door))
+            continue;
+        const resolved = {
+            door: p.door,
+            label: p.model,
+            modelId: resolvePositionModelId(p),
+            clamped: false,
+        };
+        available.push(clampToReserveOnCleanDoor(resolved, nc.resolvedChain));
+    }
+    if (available.length === 0) {
+        // FD6 critical gate with no door ⇒ FAIL CLOSED (distinct typed error). NEVER legacy routing.
+        if (NATURE_ROUTING_CRITICAL_GATES.has(baseComponentKey(component) ?? '')) {
+            throw new RouterFailClosedError(component, nc.resolvedChain);
+        }
+        // Low-stakes mapped ⇒ the caller's own non-gating heuristic (the ordinary provider-down contract).
+        return { outcome: 'no-route' };
+    }
+    return {
+        outcome: 'route',
+        resolvedNature: nc.resolvedNature,
+        resolvedChain: nc.resolvedChain,
+        primary: available[0],
+        swapTail: available.slice(1),
+    };
+}
+/**
+ * Merge an operator's partial `chains` override (config) over the built-in v3 defaults,
+ * per-chain. A chain the operator did not override keeps its default. (The FD4.3
+ * resolve-time validation that REJECTS a harness-door-violating override → defaults +
+ * notice is a tracked A2.2 remainder; the FD4 place-3 runtime clamp above already keeps
+ * the banned route closed on every resolved position regardless.)
+ */
+export function mergeNatureRoutingChains(override, onReject) {
+    if (!override)
+        return NATURE_ROUTING_DEFAULT_CHAINS;
+    // FD4.3 config-load assertion (spec §221-225): an operator override chain that violates the
+    // static harness-door ban is REJECTED at LOAD → the built-in default for that chain (never the
+    // banned override). Same predicate as the build-lint + the resolve-time assertion. A valid
+    // override is passed through verbatim; an un-overridden chain keeps its default (unvalidated —
+    // the shipped defaults are lint-verified clean).
+    const pick = (c) => {
+        const ov = override[c];
+        if (!ov)
+            return NATURE_ROUTING_DEFAULT_CHAINS[c];
+        const violations = validateNatureRoutingChain(c, ov);
+        if (violations.length > 0) {
+            onReject?.(c, violations);
+            return NATURE_ROUTING_DEFAULT_CHAINS[c]; // reject the banned override → built-in default
+        }
+        return ov;
+    };
+    return {
+        FAST: pick('FAST'),
+        SORT: pick('SORT'),
+        JUDGE: pick('JUDGE'),
+        WRITE: pick('WRITE'),
+    };
+}
 export class IntelligenceRouter {
     opts;
     cache = new Map();
@@ -256,6 +536,51 @@ export class IntelligenceRouter {
     resolveProvider(framework) {
         return framework === this.opts.defaultFramework ? this.opts.defaultProvider : this.providerFor(framework);
     }
+    /** Already warned that nature-routing enforcing mode is not yet wired (warn ONCE). */
+    warnedNatureEnforceNotWired = false;
+    /**
+     * S4 A2 — CLI-door reachability probe for the nature router (FD5 availability walk).
+     * CLI doors coincide 1:1 with `IntelligenceFramework`. `resolveRoute` skips metered
+     * doors before ever calling this, so `door` is always a CLI door. The default framework
+     * is always reachable (shared provider); a non-default door is reachable iff its provider
+     * builds (binary present). Result is cached by `providerFor`.
+     */
+    isCliDoorReachable(door) {
+        return this.resolveProvider(door) !== null;
+    }
+    /**
+     * S4 A2 — enforcing-mode honesty guard. Flipping `dryRun:false` in A2.1 does NOT re-route
+     * (the selection integration is a tracked A2.2 remainder); routing stays byte-identical.
+     * Warn ONCE so the flip is an honest no-op rather than a silent dead switch.
+     */
+    warnNatureEnforceNotWired() {
+        if (this.warnedNatureEnforceNotWired)
+            return;
+        this.warnedNatureEnforceNotWired = true;
+        console.warn('IntelligenceRouter: sessions.natureRouting.dryRun is false, but nature-routing ENFORCING ' +
+            'selection is not wired in this build (Increment A2.1 ships the dark/dryRun observation ' +
+            'mechanism; enforcing selection is the tracked A2.2 remainder). Routing stays byte-identical — ' +
+            'the resolver plan is logged but not applied.');
+    }
+    /** Chains already warned about as rejected (warn ONCE per chain, never per call). */
+    warnedRejectedChains;
+    /**
+     * FD4.3 — a live/hot chain (an operator `PATCH /config` override, or a resolved chain)
+     * violated the static harness-door ban and was REJECTED → built-in defaults. Warn ONCE
+     * per chain so the rejection is visible (the banned route is never opened; the built-in
+     * default is used instead). The full FD6 aggregated critical-gate attention item is a
+     * tracked A2.2 remainder; this is the honest, non-silent minimum.
+     */
+    warnNatureChainRejected(chain, violations) {
+        if (!this.warnedRejectedChains)
+            this.warnedRejectedChains = new Set();
+        if (this.warnedRejectedChains.has(chain))
+            return;
+        this.warnedRejectedChains.add(chain);
+        console.warn(`IntelligenceRouter: nature-routing chain '${chain}' REJECTED — it violates the FD4 harness-door ` +
+            `ban and was replaced with the built-in default (the banned route is never opened). ` +
+            violations.map((v) => v.detail).join(' | '));
+    }
     async evaluate(prompt, options) {
         const component = options?.attribution?.component;
         const explicitCategory = options?.attribution?.category;
@@ -263,6 +588,34 @@ export class IntelligenceRouter {
             ? explicitCategory
             : categoryForComponent(component);
         const cfg = this.opts.resolveConfig();
+        // ── S4 A2 — nature-axis routing OBSERVATION (dev-gated dark; dryRun-first). ──
+        // Byte-identical when unset/off: when the feature is absent OR `enabled:false` this
+        // whole block is skipped and NOTHING about selection changes. In dryRun (the dev-agent
+        // default) it OBSERVES only — computes + logs the plan via `onNatureRoutePlan` — and
+        // still falls through to today's selection below. Enforcing SELECTION (dryRun:false) is
+        // a tracked A2.2 remainder; guarded here so a flip is an HONEST no-op, never a silent
+        // dead switch and never a mis-route. A resolver error can never break routing here.
+        const natureRt = this.opts.resolveNatureRouting?.();
+        if (natureRt?.enabled) {
+            const dryRun = natureRt.dryRun !== false; // default true on first enable
+            try {
+                const resolution = resolveRoute(component, options?.attribution?.nature, mergeNatureRoutingChains(natureRt.chains, (c, v) => this.warnNatureChainRejected(c, v)), {
+                    isDoorReachable: (d) => this.isCliDoorReachable(d),
+                    onInvalidChain: (c, v) => this.warnNatureChainRejected(c, v),
+                });
+                this.opts.onNatureRoutePlan?.({ component, category, dryRun, resolution });
+            }
+            catch (e) {
+                if (e instanceof RouterFailClosedError) {
+                    this.opts.onNatureRoutePlan?.({ component, category, dryRun, failClosed: true });
+                }
+                else {
+                    this.opts.onNatureRoutePlan?.({ component, category, dryRun });
+                }
+            }
+            if (!dryRun)
+                this.warnNatureEnforceNotWired();
+        }
         // Unconfigured ⇒ exactly today's behavior.
         if (!cfg)
             return this.opts.defaultProvider.evaluate(prompt, options);