@moretea-labs/forge 1.8.0 → 1.8.1

package/src/runtime/context/cognitive-attention.ts

@@ -0,0 +1,173 @@
+import { getWorkContract } from '../../../packages/kernel/work/api/index';
+import { listCurrentControllerRoundRelays } from '../../../packages/kernel/controller/api/index';
+import type { ScopeRef } from '../../../packages/kernel/identity/api/index';
+import {
+  memoryAddressKey,
+  parseMemoryAddressKey,
+  type ActivationPack,
+  type CognitiveUsageFeedback,
+  type MemoryUnit,
+} from '../../../packages/kernel/cognition/api/index';
+import {
+  activateCognitiveMemory,
+  readCognitiveUsageFeedback,
+} from '../control-plane/persistence/cognition-store';
+import { cognitiveScopesForWork } from '../control-plane/persistence/experience-store';
+
+/**
+ * Canonical usage truth remains ControllerRound observationWindow plus direct usage observations.
+ * This function only derives a bounded retrieval projection; it owns no usage lifecycle.
+ */
+export function cognitiveUsageFeedbackForContext(input: {
+  controllerHome: string;
+  repoId: string;
+  scopes: readonly ScopeRef[];
+  projectId?: string;
+}): CognitiveUsageFeedback[] {
+  const allowedScopes = new Set(input.scopes.map(scope => `${scope.kind}:${scope.id}`));
+  const feedback = new Map<string, CognitiveUsageFeedback>();
+  const seen = new Set<string>();
+
+  for (const relay of listCurrentControllerRoundRelays({ controllerHome: input.controllerHome, repoId: input.repoId }, 100)) {
+    for (const observation of (relay.observationWindow ?? []).slice(-8)) {
+      if (input.projectId && observation.assistantContext?.projectId !== input.projectId) continue;
+      const delivered = new Set((observation.assistantContext?.items ?? [])
+        .filter(item => item.kind === 'knowledge')
+        .map(item => item.itemId));
+      for (const usage of observation.assistantContextUsage ?? []) {
+        if (usage.kind !== 'knowledge' || !delivered.has(usage.itemId)) continue;
+        const address = parseMemoryAddressKey(usage.itemId);
+        if (!address || !allowedScopes.has(`${address.scope.kind}:${address.scope.id}`)) continue;
+        const observationKey = `${observation.roundRef}:${usage.kind}:${usage.itemId}`;
+        if (seen.has(observationKey)) continue;
+        seen.add(observationKey);
+        const key = memoryAddressKey(address);
+        const current = feedback.get(key) ?? {
+          address,
+          usedCount: 0,
+          rejectedCount: 0,
+          conflictCount: 0,
+          staleCount: 0,
+        };
+        if (usage.decision === 'used') current.usedCount += 1;
+        else {
+          current.rejectedCount += 1;
+          if (usage.rejectionKind === 'stale') current.staleCount += 1;
+          else if (usage.rejectionKind === 'contradicted') current.conflictCount += 1;
+        }
+        feedback.set(key, current);
+      }
+    }
+  }
+
+  for (const direct of readCognitiveUsageFeedback(input.controllerHome, input.scopes)) {
+    const key = memoryAddressKey(direct.address);
+    const current = feedback.get(key) ?? {
+      address: direct.address,
+      usedCount: 0,
+      rejectedCount: 0,
+      conflictCount: 0,
+      staleCount: 0,
+    };
+    current.usedCount += direct.usedCount;
+    current.rejectedCount += direct.rejectedCount;
+    current.conflictCount += direct.conflictCount;
+    current.staleCount += direct.staleCount;
+    feedback.set(key, current);
+  }
+
+  return [...feedback.values()]
+    .sort((left, right) => memoryAddressKey(left.address).localeCompare(memoryAddressKey(right.address)))
+    .slice(0, 256);
+}
+
+/** One bounded advisory resolver used at every meaningful task boundary. */
+export function resolveCognitiveAttention(input: {
+  controllerHome: string;
+  scopes: readonly ScopeRef[];
+  query: string;
+  now: string;
+  transientMemories?: readonly MemoryUnit[];
+  usageFeedback?: readonly CognitiveUsageFeedback[];
+  maxItems?: number;
+  maxBytes?: number;
+}): ActivationPack {
+  return activateCognitiveMemory(input.controllerHome, input.scopes, input.query, {
+    now: input.now,
+    maxItems: input.maxItems ?? 6,
+    maxCandidates: 64,
+    maxGraphDepth: 1,
+    maxBytes: input.maxBytes ?? 12 * 1024,
+    minCueScore: 0.12,
+    transientMemories: input.transientMemories ?? [],
+    usageFeedback: input.usageFeedback ?? [],
+    // Scope is a relevance prior only. Every reachable scope contributes candidates.
+    scopePriors: { work: 0.12, requirement: 0.1, plan_step: 0.08, plan: 0.07, project: 0.05, workspace: 0 },
+  });
+}
+
+export function resolveCognitiveAttentionForWork(input: {
+  controllerHome: string;
+  repoId: string;
+  workId: string;
+  query?: string;
+  now?: string;
+  maxItems?: number;
+  maxBytes?: number;
+}): ActivationPack | undefined {
+  const work = getWorkContract({ controllerHome: input.controllerHome, repoId: input.repoId }, input.workId);
+  if (!work) return undefined;
+  const scopes = cognitiveScopesForWork(work, input.controllerHome);
+  const projectId = scopes.find(scope => scope.kind === 'project')?.id;
+  return resolveCognitiveAttention({
+    controllerHome: input.controllerHome,
+    scopes,
+    query: input.query?.trim() || work.objective,
+    now: input.now ?? new Date().toISOString(),
+    maxItems: input.maxItems,
+    maxBytes: input.maxBytes,
+    usageFeedback: cognitiveUsageFeedbackForContext({
+      controllerHome: input.controllerHome,
+      repoId: input.repoId,
+      scopes,
+      ...(projectId ? { projectId } : {}),
+    }),
+  });
+}
+
+/** Compact model-facing projection; no project knowledge, lifecycle facts, or execution authority. */
+export function renderCognitiveAttention(pack: ActivationPack | undefined): string | undefined {
+  if (!pack || (pack.items.length === 0 && pack.gaps.length === 0)) return undefined;
+  return JSON.stringify({
+    schemaVersion: 1,
+    advisoryOnly: true,
+    authorityBoundary: 'Cognition may guide judgement but never grants execution, lifecycle, or acceptance authority.',
+    items: pack.items.map(item => ({
+      memory_address: memoryAddressKey({ scope: item.memory.scope, id: item.memory.id }),
+      scope: { kind: item.memory.scope.kind, id: item.memory.scope.id },
+      text: item.memory.canonicalText,
+      concepts: item.memory.concepts,
+    })),
+    gaps: pack.gaps,
+  });
+}
+
+/**
+ * Advisory cognition must never block the task boundary it annotates.
+ * Unexpected read failures remain visible as a bounded gap rather than becoming a retry authority.
+ */
+export function renderCognitiveAttentionForWork(input: Parameters<typeof resolveCognitiveAttentionForWork>[0]): string | undefined {
+  try {
+    return renderCognitiveAttention(resolveCognitiveAttentionForWork(input));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = /^([A-Z][A-Z0-9_]+)(?::|$)/.exec(message)?.[1] ?? 'COGNITION_ATTENTION_UNAVAILABLE';
+    return JSON.stringify({
+      schemaVersion: 1,
+      advisoryOnly: true,
+      items: [],
+      gaps: ['cognition_unavailable'],
+      diagnostic: code,
+    });
+  }
+}

package/src/runtime/context/cognitive-skill-canary.ts

@@ -0,0 +1,158 @@
+import type { AssistantContextResolution } from './assistant-context';
+
+export const COGNITIVE_SKILL_CANARY_VERSION = 'forge-cognitive-skill-canary/v1' as const;
+const MIN_PRIMARY_ACTIVATION_SCORE = 1;
+const MIN_PRIMARY_CRITICAL_MATCHES = 2;
+
+export type CognitiveSkillCanaryGate = 'covered' | 'fallback';
+
+export interface CognitiveSkillCanaryProfile {
+  id: string;
+  evaluationGate: CognitiveSkillCanaryGate;
+  semanticSkillIds: readonly string[];
+  criticalConcepts: readonly string[];
+}
+
+export interface CognitiveSkillCanaryClassification {
+  profileId: string;
+  status: CognitiveSkillCanaryGate;
+  evaluationGate: CognitiveSkillCanaryGate;
+  semanticSkillIds: string[];
+  matchedCriticalConcepts: string[];
+  missingCriticalConcepts: string[];
+  primaryMemoryId: string;
+  primaryScore: number;
+}
+
+export const COGNITIVE_SKILL_CANARY_PROFILES: readonly CognitiveSkillCanaryProfile[] = Object.freeze([
+  Object.freeze({
+    id: 'ios-product-self-explaining-interaction',
+    evaluationGate: 'fallback' as const,
+    semanticSkillIds: Object.freeze(['ios-engineering']),
+    criticalConcepts: Object.freeze([
+      'ios.product-design',
+      'product.user-job',
+      'product.interaction.self-explanatory',
+      'product.copy.invisible-rules',
+    ]),
+  }),
+  Object.freeze({
+    id: 'ios-interaction-state-single-owner',
+    evaluationGate: 'covered' as const,
+    semanticSkillIds: Object.freeze(['ios-engineering']),
+    criticalConcepts: Object.freeze([
+      'interaction.state-contract',
+      'state.single-owner',
+      'state.draft-boundary',
+      'external-surface.projection',
+      'single-write-chain',
+    ]),
+  }),
+  Object.freeze({
+    id: 'swiftui-state-ownership-performance',
+    evaluationGate: 'covered' as const,
+    semanticSkillIds: Object.freeze(['ios-engineering', 'swiftui-expert']),
+    criticalConcepts: Object.freeze([
+      'swiftui.state-ownership',
+      'swiftui.data-flow',
+      'swiftui.stable-identity',
+      'async.stale-result',
+    ]),
+  }),
+  Object.freeze({
+    id: 'swiftui-native-accessibility',
+    evaluationGate: 'covered' as const,
+    semanticSkillIds: Object.freeze(['ios-engineering', 'swiftui-expert']),
+    criticalConcepts: Object.freeze([
+      'swiftui.native-controls',
+      'accessibility.semantics',
+      'dynamic-type',
+    ]),
+  }),
+  Object.freeze({
+    id: 'swift-concurrency-isolation',
+    evaluationGate: 'covered' as const,
+    semanticSkillIds: Object.freeze(['swift-concurrency']),
+    criticalConcepts: Object.freeze([
+      'swift.concurrency',
+      'swift.concurrency.isolation',
+      'mainactor.ui-ownership',
+      'structured-concurrency',
+      'sendable.boundary',
+      'task.entry-isolation',
+    ]),
+  }),
+  Object.freeze({
+    id: 'ios-design-system-governance',
+    evaluationGate: 'covered' as const,
+    semanticSkillIds: Object.freeze(['ios-design-system']),
+    criticalConcepts: Object.freeze([
+      'ios.design-system',
+      'design-system.tokens',
+      'design-system.semantic-tokens',
+      'visual.single-source-of-truth',
+      'platform.system-first',
+    ]),
+  }),
+]);
+
+function overlap(concepts: ReadonlySet<string>, required: readonly string[]): string[] {
+  return required.filter((concept) => concepts.has(concept));
+}
+
+export function classifyCognitiveSkillCanary(context: AssistantContextResolution): CognitiveSkillCanaryClassification | undefined {
+  const primary = context.items.find((item) => item.activation);
+  if (!primary?.activation || primary.activation.score < MIN_PRIMARY_ACTIVATION_SCORE) return undefined;
+
+  const primaryConcepts = new Set(primary.activation.concepts);
+  const ranked = COGNITIVE_SKILL_CANARY_PROFILES
+    .map((profile) => {
+      const matched = overlap(primaryConcepts, profile.criticalConcepts);
+      return { profile, matched, ratio: matched.length / profile.criticalConcepts.length };
+    })
+    .filter((candidate) => candidate.matched.length >= MIN_PRIMARY_CRITICAL_MATCHES)
+    .sort((left, right) =>
+      right.ratio - left.ratio
+      || right.matched.length - left.matched.length
+      || left.profile.id.localeCompare(right.profile.id));
+  const selected = ranked[0];
+  if (!selected) return undefined;
+
+  const deliveredConcepts = new Set(context.items.flatMap((item) => item.activation?.concepts ?? []));
+  const matchedCriticalConcepts = overlap(deliveredConcepts, selected.profile.criticalConcepts);
+  const matchedSet = new Set(matchedCriticalConcepts);
+  const missingCriticalConcepts = selected.profile.criticalConcepts.filter((concept) => !matchedSet.has(concept));
+  const status: CognitiveSkillCanaryGate = selected.profile.evaluationGate === 'covered' && missingCriticalConcepts.length === 0
+    ? 'covered'
+    : 'fallback';
+
+  return {
+    profileId: selected.profile.id,
+    status,
+    evaluationGate: selected.profile.evaluationGate,
+    semanticSkillIds: [...selected.profile.semanticSkillIds],
+    matchedCriticalConcepts,
+    missingCriticalConcepts,
+    primaryMemoryId: primary.id,
+    primaryScore: primary.activation.score,
+  };
+}
+
+export function cognitiveSkillCanarySignal(context: AssistantContextResolution): string | undefined {
+  const result = classifyCognitiveSkillCanary(context);
+  if (!result) return undefined;
+  const skills = result.semanticSkillIds.join(',');
+  if (result.status === 'covered') {
+    return `advisory:cognitive_skill_canary:v1:covered:profile=${result.profileId};semantic_skill_read=skip;skills=${skills};procedures=typed_capabilities`;
+  }
+  const reason = result.missingCriticalConcepts.length > 0
+    ? `missing_critical=${result.missingCriticalConcepts.join(',')}`
+    : 'evaluation_gate=not_covered';
+  return `advisory:cognitive_skill_canary:v1:fallback:profile=${result.profileId};semantic_skill_read=retain;skills=${skills};${reason};procedures=typed_capabilities`;
+}
+
+export function applyCognitiveSkillCanary(context: AssistantContextResolution): AssistantContextResolution {
+  const signal = cognitiveSkillCanarySignal(context);
+  if (!signal || context.gaps.includes(signal)) return context;
+  return { ...context, gaps: [...context.gaps, signal] };
+}

package/src/runtime/context/context-closure.ts

@@ -28,8 +28,19 @@ type ContextPackLike = {
   coverage: { relevantTests: string[]; inspectedFiles: string[] };
 };
 
+function canonicalReceiptValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonicalReceiptValue);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>)
+      .filter(([, entry]) => entry !== undefined)
+      .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+      .map(([key, entry]) => [key, canonicalReceiptValue(entry)]),
+  );
+}
+
 function fullReceiptDigest(receipt: ContextClosureReceipt): string {
-  return createHash('sha256').update(JSON.stringify(receipt)).digest('hex');
+  return createHash('sha256').update(JSON.stringify(canonicalReceiptValue(receipt))).digest('hex');
 }
 
 function recordIssuedContextClosure(receipt: ContextClosureReceipt): ContextClosureReceipt {
@@ -123,16 +134,34 @@ function requiredSkillKinds(languages: string[], platforms: string[]): string[]
 
 function resolveSkills(contract: ProjectEngineeringContract | undefined, requiredKinds: string[]) {
   if (requiredKinds.length === 0) return { status: 'not_required' as const, requiredKinds, resolved: [] as ContextClosureSkillResolution[], unresolvedKinds: [] as string[] };
-  const parsed = (contract?.skillRefs ?? []).map(parseSkillRef);
-  const resolved: ContextClosureSkillResolution[] = [];
+  const resolvedByKey = new Map<string, ContextClosureSkillResolution>();
   const covered = new Set<string>();
-  for (const skill of parsed) {
-    const lower = skill.id.toLowerCase();
-    const matchedKinds = requiredKinds.filter((kind) => lower.includes(kind.toLowerCase()));
-    if (matchedKinds.length === 0) continue;
+  const record = (skill: { id: string; version?: string }, matchedKinds: string[]) => {
+    if (matchedKinds.length === 0) return;
     matchedKinds.forEach((kind) => covered.add(kind));
-    resolved.push({ ...skill, source: 'project_contract', matchedKinds });
+    const key = `${skill.id}@${skill.version ?? ''}`;
+    const existing = resolvedByKey.get(key);
+    resolvedByKey.set(key, {
+      ...skill,
+      source: 'project_contract',
+      matchedKinds: [...new Set([...(existing?.matchedKinds ?? []), ...matchedKinds])].sort(),
+    });
+  };
+
+  for (const binding of contract?.skillBindings ?? []) {
+    const declaredKinds = new Set(binding.kinds.map((kind) => kind.toLowerCase()));
+    record(
+      { id: binding.id, ...(binding.version === undefined ? {} : { version: binding.version }) },
+      requiredKinds.filter((kind) => declaredKinds.has(kind.toLowerCase())),
+    );
   }
+
+  for (const skill of (contract?.skillRefs ?? []).map(parseSkillRef)) {
+    const lower = skill.id.toLowerCase();
+    record(skill, requiredKinds.filter((kind) => lower.includes(kind.toLowerCase())));
+  }
+
+  const resolved = [...resolvedByKey.values()];
   const unresolvedKinds = requiredKinds.filter((kind) => !covered.has(kind));
   const status = unresolvedKinds.length === 0 ? 'ready' as const : resolved.length > 0 ? 'degraded' as const : 'unavailable' as const;
   return { status, requiredKinds, resolved, unresolvedKinds };
@@ -144,7 +173,15 @@ function semanticResultProviderIds(results: unknown[]): string[] {
     if (!value || typeof value !== 'object') continue;
     const record = value as Record<string, unknown>;
     const nested = record.result && typeof record.result === 'object' ? record.result as Record<string, unknown> : undefined;
-    const id = typeof record.providerId === 'string' ? record.providerId : typeof nested?.providerId === 'string' ? nested.providerId : undefined;
+    const id = typeof record.provider === 'string'
+      ? record.provider
+      : typeof record.providerId === 'string'
+        ? record.providerId
+        : typeof nested?.provider === 'string'
+          ? nested.provider
+          : typeof nested?.providerId === 'string'
+            ? nested.providerId
+            : undefined;
     if (id) ids.push(id);
   }
   return unique(ids);

package/src/runtime/context/context-pack-process.ts

@@ -0,0 +1,103 @@
+import { existsSync, lstatSync, readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import type { McpPolicy } from '../../../adapters/mcp/types';
+import type {
+  ControllerContextPackOptions,
+  ControllerContextPackProjection,
+} from '../../cli/controller/context/types';
+import { resolveBunExecutable } from '../shared/process-environment';
+import { runBoundedChild } from '../shared/bounded-child-supervisor';
+
+const CONTEXT_PACK_SIDECAR_ENTRYPOINT = 'forge-context-pack' as const;
+const CONTEXT_PACK_TIMEOUT_MS = 60_000;
+const CONTEXT_PACK_MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
+
+interface ContextPackSidecarManifestRecord {
+  contextPackEntrypoint?: unknown;
+  contextPackArtifactIdentity?: unknown;
+}
+
+interface ContextPackSidecarResponse {
+  schemaVersion: 1;
+  pack: ControllerContextPackProjection;
+}
+
+function releaseManifestArgument(argv: readonly string[]): string | undefined {
+  const index = argv.indexOf('--release-manifest');
+  const value = index >= 0 ? argv[index + 1]?.trim() : undefined;
+  return value ? resolve(value) : undefined;
+}
+
+export function resolveContextPackSidecarCommand(
+  argv: readonly string[] = process.argv,
+): { executable: string; args: string[]; cwd?: string } {
+  const manifestPath = releaseManifestArgument(argv);
+  if (manifestPath) {
+    const parsed = JSON.parse(readFileSync(manifestPath, 'utf8')) as ContextPackSidecarManifestRecord;
+    if (parsed.contextPackEntrypoint !== CONTEXT_PACK_SIDECAR_ENTRYPOINT) {
+      throw new Error('CONTEXT_PACK_SIDECAR_MANIFEST_MISSING');
+    }
+    const identity = typeof parsed.contextPackArtifactIdentity === 'string'
+      ? parsed.contextPackArtifactIdentity.trim()
+      : '';
+    if (!/^sha256:[a-f0-9]{64}$/i.test(identity)) {
+      throw new Error('CONTEXT_PACK_SIDECAR_IDENTITY_INVALID');
+    }
+    const executable = join(dirname(manifestPath), CONTEXT_PACK_SIDECAR_ENTRYPOINT);
+    if (!existsSync(executable)) throw new Error('CONTEXT_PACK_SIDECAR_MISSING');
+    const status = lstatSync(executable);
+    if (status.isSymbolicLink() || !status.isFile() || (status.mode & 0o111) === 0) {
+      throw new Error('CONTEXT_PACK_SIDECAR_NOT_EXECUTABLE');
+    }
+    return {
+      executable,
+      args: ['--release-manifest', manifestPath],
+      cwd: dirname(manifestPath),
+    };
+  }
+
+  // Deliberately construct this development path at runtime. A literal new URL()
+  // to a .ts sidecar makes Bun include the sidecar's heavy Context Plane import
+  // graph in the long-lived Runtime bundle.
+  const entry = resolve(process.cwd(), 'adapters', 'mcp', 'runtime-gateway', 'context-pack-sidecar.ts');
+  if (!existsSync(entry)) throw new Error('CONTEXT_PACK_SOURCE_SIDECAR_MISSING');
+  return {
+    executable: resolveBunExecutable(process.execPath, process.env),
+    args: [entry],
+    cwd: process.cwd(),
+  };
+}
+
+export async function buildControllerContextPackInSidecar(input: {
+  repoRoot: string;
+  policy: McpPolicy;
+  options: ControllerContextPackOptions;
+}): Promise<ControllerContextPackProjection> {
+  const command = resolveContextPackSidecarCommand();
+  const envelope = JSON.stringify({
+    schemaVersion: 1,
+    repoRoot: resolve(input.repoRoot),
+    policy: input.policy,
+    options: input.options,
+  });
+  const execution = await runBoundedChild(command.executable, command.args, {
+    cwd: command.cwd ?? input.repoRoot,
+    input: envelope,
+    timeoutMs: CONTEXT_PACK_TIMEOUT_MS,
+    maxOutputBytes: CONTEXT_PACK_MAX_OUTPUT_BYTES,
+  });
+  if (execution.status !== 0 || execution.timedOut || execution.failureCode) {
+    const detail = (execution.stderr || execution.stdout || execution.error || execution.failureCode || 'context-pack sidecar failed').trim();
+    throw new Error(`CONTEXT_PACK_SIDECAR_FAILED: ${detail.slice(0, 2_000)}`);
+  }
+  let response: ContextPackSidecarResponse;
+  try {
+    response = JSON.parse(execution.stdout) as ContextPackSidecarResponse;
+  } catch (error) {
+    throw new Error(`CONTEXT_PACK_SIDECAR_RESPONSE_INVALID: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (response.schemaVersion !== 1 || !response.pack || response.pack.schemaVersion !== 11) {
+    throw new Error('CONTEXT_PACK_SIDECAR_RESPONSE_INVALID: unsupported response');
+  }
+  return response.pack;
+}

package/src/runtime/context/context-plane.ts

@@ -2,7 +2,6 @@ import type { CredentialReference } from '../../../packages/kernel/identity/api/
 import type { ScopeRef } from '../../../packages/kernel/identity/api/index';
 import { listControlPlaneRecords, readControlPlaneRecord, writeControlPlaneRecord, type ControlPlaneRecord } from '../control-plane/persistence/sqlite-store';
 import { assertControlPlaneMetadataPayload } from '../control-plane/persistence/metadata-payload-policy';
-import type { RouteContextHints } from '../control-plane/routing/route-policy';
 
 export const CONTEXT_RECORD_NAMESPACE = 'context_record';
 export const MAX_CONTEXT_RECORDS = 1_000;
@@ -42,7 +41,6 @@ export interface ContextRecord {
 export interface ContextResolution {
   schemaVersion: 1;
   records: Array<{ record: ContextRecord; storeRevision: number; rank: number }>;
-  routeHints: RouteContextHints;
   estimatedTokens: number;
   bytes: number;
   truncated: boolean;
@@ -184,13 +182,7 @@ export function resolveContextPlane(input: {
     estimatedTokens += nextTokens;
   }
 
-  const preference = selected.map((entry) => entry.record.value).find((value) => value.type === 'routing_preference') as Extract<ContextValue, { type: 'routing_preference' }> | undefined;
-  const routeHints: RouteContextHints = preference ? {
-    preferredProviderId: preference.preferredProviderId,
-    ...(preference.allowedProviderIds ? { allowedProviderIds: preference.allowedProviderIds } : {}),
-    ...(preference.forbiddenProviderIds ? { forbiddenProviderIds: preference.forbiddenProviderIds } : {}),
-  } : {};
-  return { schemaVersion: 1, records: selected, routeHints, estimatedTokens, bytes, truncated };
+  return { schemaVersion: 1, records: selected, estimatedTokens, bytes, truncated };
 }
 
 export function renderContextPlane(resolution: ContextResolution): string {