@ikon85/agent-workflow-kit 0.33.0 → 0.34.1

package/src/lib/dispatchReceipt.mjs

@@ -0,0 +1,162 @@
+export const DISPATCH_RECEIPT_VERSION = 2;
+
+const ROUTE_FIELDS = [
+  'providerId',
+  'modelId',
+  'effort',
+  'surfaceId',
+  'transportId',
+];
+
+const ENFORCEMENT_METHODS = [
+  'per-spawn',
+  'named-agent',
+  'session-default',
+  'none',
+];
+
+export const DISPATCH_PRECEDENCE = Object.freeze([
+  'explicit-argument',
+  'agent-definition-over-environment',
+  'environment-over-agent-definition',
+  'session-default',
+  'uncontrolled',
+  'unreported',
+]);
+
+function object(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function timestamp(value, field) {
+  string(value, field);
+  if (!Number.isFinite(Date.parse(value))) throw new TypeError(`${field} must be an ISO timestamp`);
+  return value;
+}
+
+function route(input, field) {
+  object(input, field);
+  for (const key of Object.keys(input)) {
+    if (!ROUTE_FIELDS.includes(key)) throw new TypeError(`unknown ${field} field: ${key}`);
+  }
+  return Object.freeze(Object.fromEntries(
+    ROUTE_FIELDS.map((key) => [key, string(input[key], `${field}.${key}`)]),
+  ));
+}
+
+function enforcement(input) {
+  object(input, 'enforcement');
+  const result = {};
+  for (const field of ['model', 'effort']) {
+    if (!ENFORCEMENT_METHODS.includes(input[field])) {
+      throw new TypeError(`${field} enforcement must be one of: ${ENFORCEMENT_METHODS.join(', ')}`);
+    }
+    result[field] = input[field];
+  }
+  return Object.freeze(result);
+}
+
+function precedence(input) {
+  if (input == null) {
+    return Object.freeze({ model: 'unreported', effort: 'unreported' });
+  }
+  object(input, 'precedence');
+  const result = {};
+  for (const field of ['model', 'effort']) {
+    if (!DISPATCH_PRECEDENCE.includes(input[field])) {
+      throw new TypeError(
+        `${field} precedence must be one of: ${DISPATCH_PRECEDENCE.join(', ')}`,
+      );
+    }
+    result[field] = input[field];
+  }
+  return Object.freeze(result);
+}
+
+function revisions(input) {
+  object(input, 'revisions');
+  return Object.freeze({
+    catalog: string(input.catalog, 'revisions.catalog'),
+    accessGraph: string(input.accessGraph, 'revisions.accessGraph'),
+    policy: string(input.policy, 'revisions.policy'),
+  });
+}
+
+function blockedReceipt(input) {
+  const requestedRoute = input.requestedRoute == null
+    ? null
+    : route(input.requestedRoute, 'requestedRoute');
+  const appliedRoute = input.appliedRoute == null
+    ? null
+    : route(input.appliedRoute, 'appliedRoute');
+  if (appliedRoute !== null && requestedRoute === null) {
+    throw new TypeError('blocked applied route requires a requested route');
+  }
+  const appliedEnforcement = input.enforcement == null ? null : enforcement(input.enforcement);
+  const appliedPrecedence = input.precedence == null ? null : precedence(input.precedence);
+  if (appliedRoute !== null && (appliedEnforcement === null || appliedPrecedence === null)) {
+    throw new TypeError('blocked applied route requires enforcement and precedence');
+  }
+  return Object.freeze({
+    schemaVersion: DISPATCH_RECEIPT_VERSION,
+    executionId: string(input.executionId, 'executionId'),
+    status: 'blocked',
+    afk: input.afk === true,
+    requestedRoute,
+    appliedRoute,
+    enforcement: appliedEnforcement,
+    precedence: appliedPrecedence,
+    revisions: revisions(input.revisions),
+    dispatchedAt: timestamp(input.dispatchedAt, 'dispatchedAt'),
+    reason: string(input.reason, 'reason'),
+  });
+}
+
+export function createDispatchReceipt(input) {
+  object(input, 'dispatch receipt');
+  if (input.status === 'blocked') return blockedReceipt(input);
+  if (input.status !== 'dispatched') {
+    throw new TypeError('dispatch receipt status must be dispatched or blocked');
+  }
+  const requestedRoute = route(input.requestedRoute, 'requestedRoute');
+  const appliedRoute = route(input.appliedRoute, 'appliedRoute');
+  for (const field of ROUTE_FIELDS) {
+    if (requestedRoute[field] !== appliedRoute[field]) {
+      throw new Error(`applied route differs from requested route: ${field}`);
+    }
+  }
+  const appliedEnforcement = enforcement(input.enforcement);
+  const appliedPrecedence = precedence(input.precedence);
+  if (input.afk === true
+      && (appliedEnforcement.model === 'none' || appliedEnforcement.effort === 'none')) {
+    throw new Error('AFK dispatch requires enforced model and effort selection');
+  }
+  if (input.afk === true
+      && Object.values(appliedPrecedence).some((value) =>
+        value === 'uncontrolled' || value === 'unreported')) {
+    throw new Error('AFK dispatch requires verified environment precedence');
+  }
+  return Object.freeze({
+    schemaVersion: DISPATCH_RECEIPT_VERSION,
+    executionId: string(input.executionId, 'executionId'),
+    status: 'dispatched',
+    afk: input.afk === true,
+    requestedRoute,
+    appliedRoute,
+    enforcement: appliedEnforcement,
+    precedence: appliedPrecedence,
+    revisions: revisions(input.revisions),
+    dispatchedAt: timestamp(input.dispatchedAt, 'dispatchedAt'),
+    reason: null,
+  });
+}

package/src/lib/frontendWorkloads.mjs

@@ -0,0 +1,170 @@
+import {
+  evidenceWorkloadIdentity,
+  validateEvidenceSelection,
+} from './routingIntent.mjs';
+
+const FRONTEND_DOMAINS = new Set([
+  'general',
+  'reference-design',
+  'marketing',
+  'analytics',
+  'product',
+  'game',
+  'simulation',
+  'editor',
+]);
+
+const QUALITY_AXES = new Set([
+  'visual-preference',
+  'visual-fidelity',
+  'functional',
+  'accessibility',
+  'responsive',
+]);
+
+export const FRONTEND_SOURCE_CLAIMS = Object.freeze({
+  'code-arena-webdev': Object.freeze({
+    workloads: Object.freeze(['frontend-greenfield']),
+    axes: Object.freeze(['visual-preference']),
+    decisive: true,
+  }),
+  'openhands-frontend': Object.freeze({
+    workloads: Object.freeze(['frontend-repository-repair']),
+    axes: Object.freeze(['functional']),
+    decisive: true,
+  }),
+  vision2web: Object.freeze({
+    workloads: Object.freeze(['frontend-greenfield']),
+    axes: Object.freeze(['visual-fidelity', 'functional', 'responsive']),
+    decisive: false,
+  }),
+  design2code: Object.freeze({
+    workloads: Object.freeze(['frontend-greenfield']),
+    axes: Object.freeze(['visual-fidelity']),
+    decisive: false,
+  }),
+});
+
+function nonEmptyString(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function plainObject(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+export function classifyFrontendWorkload(input) {
+  plainObject(input, 'frontend workload');
+  const lifecycle = nonEmptyString(input.lifecycle, 'frontend workload lifecycle');
+  const repositoryContext = nonEmptyString(
+    input.repositoryContext,
+    'frontend workload repositoryContext',
+  );
+  if (!Array.isArray(input.qualityAxes) || input.qualityAxes.length === 0) {
+    throw new TypeError('frontend workload qualityAxes must be a non-empty array');
+  }
+  if (new Set(input.qualityAxes).size !== input.qualityAxes.length) {
+    throw new TypeError('frontend workload qualityAxes must be unique');
+  }
+  for (const axis of input.qualityAxes) {
+    if (!QUALITY_AXES.has(axis)) throw new TypeError(`unknown frontend quality axis: ${axis}`);
+  }
+
+  let workload;
+  let supportedAxes;
+  if (lifecycle === 'greenfield' && repositoryContext === 'isolated') {
+    workload = 'frontend-greenfield';
+    supportedAxes = FRONTEND_SOURCE_CLAIMS['code-arena-webdev'].axes;
+  } else if (
+    ['edit', 'repair'].includes(lifecycle)
+    && repositoryContext === 'existing-repository'
+  ) {
+    workload = 'frontend-repository-repair';
+    supportedAxes = FRONTEND_SOURCE_CLAIMS['openhands-frontend'].axes;
+  } else {
+    throw new TypeError(
+      `unsupported frontend workload mapping: ${lifecycle}/${repositoryContext}`,
+    );
+  }
+
+  const frontendDomain = input.frontendDomain ?? 'general';
+  if (!FRONTEND_DOMAINS.has(frontendDomain)) {
+    throw new TypeError(`unknown frontend domain: ${frontendDomain}`);
+  }
+  const evidenceAxes = input.qualityAxes.filter((axis) => supportedAxes.includes(axis));
+  const unsupportedAxes = input.qualityAxes.filter((axis) => !supportedAxes.includes(axis));
+  return Object.freeze({
+    evidenceSelection: validateEvidenceSelection({
+      workload,
+      domain: frontendDomain,
+      axes: evidenceAxes,
+    }),
+    repositoryContext,
+    unsupportedAxes: Object.freeze(unsupportedAxes),
+  });
+}
+
+export function frontendEvidenceWorkload({ workload, frontendDomain = 'general', axis }) {
+  if (!['frontend-greenfield', 'frontend-repository-repair'].includes(workload)) {
+    throw new TypeError(`unknown frontend evidence workload: ${workload}`);
+  }
+  if (!FRONTEND_DOMAINS.has(frontendDomain)) {
+    throw new TypeError(`unknown frontend domain: ${frontendDomain}`);
+  }
+  if (!QUALITY_AXES.has(axis)) throw new TypeError(`unknown frontend quality axis: ${axis}`);
+  return evidenceWorkloadIdentity({
+    workload,
+    domain: frontendDomain,
+    axes: [axis],
+  });
+}
+
+export function createFrontendRouteReason(observation) {
+  plainObject(observation, 'frontend observation');
+  const [workload, frontendDomain, axis, ...rest] =
+    nonEmptyString(observation.workload, 'frontend observation workload').split(':');
+  if (rest.length > 0 || !workload || !frontendDomain || !axis) {
+    throw new TypeError('frontend observation workload must name workload, domain, and axis');
+  }
+  const sourceId = nonEmptyString(
+    observation.source?.benchmark,
+    'frontend observation source benchmark',
+  );
+  return `${workload} (${frontendDomain}) is supported on ${axis} by ${sourceId}`;
+}
+
+export function evaluateVision2WebReadiness(input) {
+  plainObject(input, 'Vision2Web leaderboard');
+  const season = nonEmptyString(input.season, 'Vision2Web season');
+  const benchmarkVersion = nonEmptyString(
+    input.benchmarkVersion,
+    'Vision2Web benchmarkVersion',
+  );
+  if (!Array.isArray(input.results)) {
+    throw new TypeError('Vision2Web results must be an array');
+  }
+  if (input.results.length === 0) {
+    return Object.freeze({
+      sourceId: 'vision2web',
+      status: 'candidate',
+      season,
+      benchmarkVersion,
+      observations: Object.freeze([]),
+      reason: 'current-season-leaderboard-empty',
+    });
+  }
+  return Object.freeze({
+    sourceId: 'vision2web',
+    status: 'awaiting-owner-adapter-validation',
+    season,
+    benchmarkVersion,
+    observations: Object.freeze([]),
+    reason: 'results-require-owner-adapter',
+  });
+}

package/src/lib/routeDispatcher.mjs

@@ -0,0 +1,158 @@
+import { createDispatchReceipt } from './dispatchReceipt.mjs';
+import { resolveRoute } from './routingResolver.mjs';
+import {
+  assertRoutingProfileUnchanged,
+  captureRoutingProfileSnapshot,
+} from './routingEvidenceCache.mjs';
+
+const RECEIPT_ROUTE_FIELDS = [
+  'providerId',
+  'modelId',
+  'effort',
+  'surfaceId',
+  'transportId',
+];
+
+function receiptRoute(route) {
+  return Object.fromEntries(RECEIPT_ROUTE_FIELDS.map((field) => [field, route[field]]));
+}
+
+function receiptRevisions(decision) {
+  return Object.fromEntries(
+    ['catalog', 'accessGraph', 'policy'].map((field) => [
+      field,
+      decision.revisions[field] ?? 'missing',
+    ]),
+  );
+}
+
+function blockedReceipt(input, decision, reason, details = {}) {
+  return createDispatchReceipt({
+    executionId: input.executionId,
+    status: 'blocked',
+    afk: input.afk,
+    requestedRoute: details.requestedRoute ?? null,
+    appliedRoute: details.appliedRoute ?? null,
+    enforcement: details.enforcement ?? null,
+    precedence: details.precedence ?? null,
+    revisions: receiptRevisions(decision),
+    dispatchedAt: input.dispatchedAt,
+    reason,
+  });
+}
+
+function decisionReason(decision) {
+  const blockers = decision.blockers.length > 0 ? `:${decision.blockers.join(',')}` : '';
+  return `${decision.status}:${decision.reason}${blockers}`;
+}
+
+function safeFailureReason(error) {
+  const message = error instanceof Error ? error.message : '';
+  const safeReasons = [
+    ['Claude route capability is not attested', 'Claude route capability is not attested'],
+    ['route identity is incomplete', 'route identity is incomplete'],
+    ['transport is not detected', 'transport is not detected'],
+    ['transport is not callable', 'transport is not callable'],
+    ['transport is not permitted', 'transport is not permitted'],
+    ['model control is not enforced', 'model control is not enforced'],
+    ['effort control is not enforced', 'effort control is not enforced'],
+    ['model environment precedence is unverified', 'model environment precedence is unverified'],
+    ['effort environment precedence is unverified', 'effort environment precedence is unverified'],
+    ['model applied value is unverified', 'model applied value is unverified'],
+    ['effort applied value is unverified', 'effort applied value is unverified'],
+    ['transport has no approved dispatcher', 'transport has no approved dispatcher'],
+    ['environment precedence mismatch: model', 'environment precedence mismatch: model'],
+    ['environment precedence mismatch: effort', 'environment precedence mismatch: effort'],
+    ['applied route mismatch', 'applied route mismatch'],
+    ['spawn guard received no callable dispatcher', 'spawn guard received no callable dispatcher'],
+    ['applied route differs from requested route', 'applied route differs from requested route'],
+    ['applied enforcement differs from attested access path', 'applied enforcement differs from attested access path'],
+    ['AFK dispatch requires enforced model and effort selection', 'AFK dispatch requires enforced model and effort selection'],
+    ['AFK dispatch requires verified environment precedence', 'AFK dispatch requires verified environment precedence'],
+    ['concurrent routing profile mutation', 'concurrent routing profile mutation'],
+    ['concurrent evidence catalog mutation', 'concurrent evidence catalog mutation'],
+  ];
+  return safeReasons.find(([prefix]) => message.startsWith(prefix))?.[1]
+    ?? 'dispatch adapter rejected route';
+}
+
+function safeDispatchResult(result) {
+  if (!result || typeof result !== 'object' || Array.isArray(result)) return null;
+  const taskId = typeof result.taskId === 'string' && result.taskId !== ''
+    ? result.taskId
+    : null;
+  return taskId === null ? null : Object.freeze({ taskId });
+}
+
+function assertAppliedEnforcement(decision, applied) {
+  for (const field of ['model', 'effort']) {
+    if (decision.bestExecutable.enforcement[field] !== applied[field]) {
+      throw new Error(`applied enforcement differs from attested access path: ${field}`);
+    }
+  }
+}
+
+export async function dispatchResolvedRoute(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('dispatch input must be an object');
+  }
+  if (!input.adapter || typeof input.adapter.prepare !== 'function') {
+    throw new TypeError('dispatch adapter must expose prepare');
+  }
+  const decision = resolveRoute(input.resolverInput);
+  if (decision.status !== 'ready') {
+    return Object.freeze({
+      decision,
+      receipt: blockedReceipt(input, decision, decisionReason(decision)),
+      dispatchResult: null,
+    });
+  }
+  const profileSnapshot = captureRoutingProfileSnapshot(input.resolverInput);
+  const catalogRevision = input.resolverInput.catalog.revision;
+
+  const requestedRoute = receiptRoute(decision.bestExecutable);
+  try {
+    const prepared = await input.adapter.prepare(requestedRoute);
+    assertRoutingProfileUnchanged(profileSnapshot, input.resolverInput);
+    if (catalogRevision !== input.resolverInput.catalog?.revision) {
+      throw new Error('concurrent evidence catalog mutation');
+    }
+    assertAppliedEnforcement(decision, prepared.enforcement);
+    if (prepared.mismatchReason) {
+      return Object.freeze({
+        decision,
+        receipt: blockedReceipt(input, decision, safeFailureReason(
+          new Error(prepared.mismatchReason),
+        ), {
+          requestedRoute,
+          appliedRoute: receiptRoute(prepared.appliedRoute),
+          enforcement: prepared.enforcement,
+          precedence: prepared.precedence,
+        }),
+        dispatchResult: null,
+      });
+    }
+    const receipt = createDispatchReceipt({
+      executionId: input.executionId,
+      status: 'dispatched',
+      afk: input.afk,
+      requestedRoute,
+      appliedRoute: receiptRoute(prepared.appliedRoute),
+      enforcement: prepared.enforcement,
+      precedence: prepared.precedence,
+      revisions: receiptRevisions(decision),
+      dispatchedAt: input.dispatchedAt,
+    });
+    if (typeof prepared.dispatch !== 'function') {
+      throw new Error('spawn guard received no callable dispatcher');
+    }
+    const dispatchResult = safeDispatchResult(await prepared.dispatch());
+    return Object.freeze({ decision, receipt, dispatchResult });
+  } catch (error) {
+    return Object.freeze({
+      decision,
+      receipt: blockedReceipt(input, decision, safeFailureReason(error), { requestedRoute }),
+      dispatchResult: null,
+    });
+  }
+}

package/src/lib/routingAccessGraph.mjs

@@ -0,0 +1,105 @@
+export const ACCESS_GRAPH_VERSION = 1;
+
+export const ROUTE_AVAILABILITY = Object.freeze([
+  'available',
+  'unavailable',
+  'unknown',
+]);
+
+export const ENFORCEMENT_METHODS = Object.freeze([
+  'per-spawn',
+  'named-agent',
+  'session-default',
+  'none',
+]);
+
+const PATH_FIELDS = new Set([
+  'id',
+  'surfaceId',
+  'providerId',
+  'modelId',
+  'transportId',
+  'availability',
+  'enforcement',
+  'capabilityEvidence',
+]);
+
+function object(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function oneOf(value, values, field) {
+  if (!values.includes(value)) throw new TypeError(`${field} must be one of: ${values.join(', ')}`);
+  return value;
+}
+
+function timestamp(value, field) {
+  string(value, field);
+  if (!Number.isFinite(Date.parse(value))) throw new TypeError(`${field} must be an ISO timestamp`);
+  return value;
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value)) deepFreeze(child);
+  return value;
+}
+
+function validatePath(path, index) {
+  const field = `paths[${index}]`;
+  object(path, field);
+  for (const key of Object.keys(path)) {
+    if (!PATH_FIELDS.has(key)) throw new TypeError(`unknown access path field: ${key}`);
+  }
+  const enforcement = object(path.enforcement, `${field}.enforcement`);
+  const evidence = object(path.capabilityEvidence, `${field}.capabilityEvidence`);
+  const observedAt = timestamp(evidence.observedAt, `${field}.capabilityEvidence.observedAt`);
+  const expiresAt = timestamp(evidence.expiresAt, `${field}.capabilityEvidence.expiresAt`);
+  if (Date.parse(expiresAt) <= Date.parse(observedAt)) {
+    throw new TypeError(`${field}.capabilityEvidence.expiresAt must follow observedAt`);
+  }
+  return {
+    id: string(path.id, `${field}.id`),
+    surfaceId: string(path.surfaceId, `${field}.surfaceId`),
+    providerId: string(path.providerId, `${field}.providerId`),
+    modelId: string(path.modelId, `${field}.modelId`),
+    transportId: string(path.transportId, `${field}.transportId`),
+    availability: oneOf(path.availability, ROUTE_AVAILABILITY, `${field}.availability`),
+    enforcement: {
+      model: oneOf(enforcement.model, ENFORCEMENT_METHODS, `${field}.enforcement.model`),
+      effort: oneOf(enforcement.effort, ENFORCEMENT_METHODS, `${field}.enforcement.effort`),
+    },
+    capabilityEvidence: {
+      revision: string(evidence.revision, `${field}.capabilityEvidence.revision`),
+      observedAt,
+      expiresAt,
+    },
+  };
+}
+
+export function validateAccessGraph(input) {
+  object(input, 'access graph');
+  if (input.schemaVersion !== ACCESS_GRAPH_VERSION) {
+    throw new TypeError(`access graph schemaVersion must be ${ACCESS_GRAPH_VERSION}`);
+  }
+  const revision = string(input.revision, 'access graph revision');
+  if (!Array.isArray(input.paths)) throw new TypeError('access graph paths must be an array');
+  const paths = input.paths.map(validatePath);
+  const ids = new Set();
+  for (const path of paths) {
+    if (ids.has(path.id)) throw new TypeError(`duplicate access path: ${path.id}`);
+    ids.add(path.id);
+  }
+  return deepFreeze({ schemaVersion: ACCESS_GRAPH_VERSION, revision, paths });
+}

package/src/lib/routingAdapters/claude.mjs

@@ -0,0 +1,62 @@
+import { adaptClaudeRoutingInventory } from '../capabilityMatrix.mjs';
+
+function matchesRoute(path, route) {
+  return ['surfaceId', 'providerId', 'modelId', 'transportId']
+    .every((field) => path[field] === route[field]);
+}
+
+function appliedRoute(path, requestedRoute) {
+  return Object.freeze({
+    ...requestedRoute,
+    modelId: path.model.applied,
+    effort: path.effort.applied,
+  });
+}
+
+function mismatchReason(path, requested, applied) {
+  for (const field of ['modelId', 'effort']) {
+    if (requested[field] === applied[field]) continue;
+    const control = field === 'modelId' ? path.model : path.effort;
+    if (control.precedence === 'environment-over-agent-definition') {
+      return `environment precedence mismatch: ${field === 'modelId' ? 'model' : field}`;
+    }
+    return `applied route mismatch: ${field}`;
+  }
+  return null;
+}
+
+export function createClaudeRoutingAdapter({ inventory, dispatchers = {} }) {
+  const capabilities = adaptClaudeRoutingInventory(inventory);
+  return Object.freeze({
+    async prepare(requestedRoute) {
+      const path = capabilities.paths.find((candidate) => matchesRoute(candidate, requestedRoute));
+      if (!path) throw new Error('Claude route capability is not attested');
+      if (!path.verified) throw new Error(path.verificationFailures.join('; '));
+      const invoke = dispatchers[path.transportId];
+      if (typeof invoke !== 'function') {
+        throw new Error(`transport has no approved dispatcher: ${path.transportId}`);
+      }
+      const applied = appliedRoute(path, requestedRoute);
+      const mismatch = mismatchReason(path, requestedRoute, applied);
+      return Object.freeze({
+        appliedRoute: applied,
+        enforcement: Object.freeze({
+          model: path.model.method,
+          effort: path.effort.method,
+        }),
+        precedence: Object.freeze({
+          model: path.model.precedence,
+          effort: path.effort.precedence,
+        }),
+        mismatchReason: mismatch,
+        dispatch: () => invoke(Object.freeze({
+          route: applied,
+          enforcement: Object.freeze({
+            model: path.model.method,
+            effort: path.effort.method,
+          }),
+        })),
+      });
+    },
+  });
+}