@ran-sh/dsh-crew 0.3.0

package/src/model-catalog.mjs

@@ -0,0 +1,173 @@
+// Read-only adapter from the DSH LLM registry to a credential-free Settings
+// payload. Provider/model discovery stays owned by Harness; Crew only reads
+// its registered routes and advertised catalog.
+
+export const MODEL_CATALOG_UNAVAILABLE = 'MODEL_CATALOG_UNAVAILABLE';
+
+export const CATALOG_HEALTH_CODES = Object.freeze({
+  EMPTY_CATALOG: 'EMPTY_CATALOG',
+  EMPTY_PROVIDER_MODELS: 'EMPTY_PROVIDER_MODELS',
+  PROVIDER_MODEL_LIST_FAILED: 'PROVIDER_MODEL_LIST_FAILED',
+  HARNESS_DEFAULT_PROVIDER_MISSING: 'HARNESS_DEFAULT_PROVIDER_MISSING',
+  HARNESS_DEFAULT_MODEL_UNADVERTISED: 'HARNESS_DEFAULT_MODEL_UNADVERTISED',
+  CATALOG_CONSTRAINED: 'CATALOG_CONSTRAINED',
+});
+
+function catalogError() {
+  return Object.assign(new Error('Unable to read Harness model catalog.'), { code: MODEL_CATALOG_UNAVAILABLE });
+}
+
+function normalizeProvider(raw) {
+  if (!raw || typeof raw.id !== 'string' || raw.id.trim() === '') return null;
+  const id = raw.id.trim();
+  return { id, name: typeof raw.name === 'string' && raw.name.trim() ? raw.name.trim() : id };
+}
+
+function normalizeModels(raw, provider) {
+  if (!Array.isArray(raw)) return [];
+  const seen = new Set();
+  const result = [];
+  for (const item of raw) {
+    if (!item || typeof item.id !== 'string' || item.id.trim() === '') continue;
+    const id = item.id.trim();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    result.push({
+      id,
+      name: typeof item.name === 'string' && item.name.trim() ? item.name.trim() : id,
+      ...(typeof item.description === 'string' && item.description.trim() ? { description: item.description.trim() } : {}),
+      ...(Array.isArray(item.inputModalities) ? { inputModalities: item.inputModalities.filter((v) => v === 'text' || v === 'image') } : {}),
+    });
+  }
+  return result;
+}
+
+function safeDefault(getCurrentSelection) {
+  try {
+    const raw = typeof getCurrentSelection === 'function' ? getCurrentSelection() : undefined;
+    if (!raw || typeof raw.provider !== 'string' || typeof raw.model !== 'string') return null;
+    return {
+      provider: raw.provider,
+      model: raw.model,
+      ...(typeof raw.reasoningEffort === 'string' ? { reasoningEffort: raw.reasoningEffort } : {}),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function healthHint(code, level, { provider, model, signal } = {}) {
+  return {
+    code,
+    level,
+    ...(typeof provider === 'string' && provider ? { provider } : {}),
+    ...(typeof model === 'string' && model ? { model } : {}),
+    ...(typeof signal === 'string' && signal ? { signal } : {}),
+  };
+}
+
+/**
+ * Analyze only the effective, already-sanitized Harness catalog.
+ *
+ * This intentionally does not know an "expected" third-party catalog. A
+ * narrow advertised list is therefore informational only: it can point a user
+ * toward upstream/provider configuration, but it is never proof of a bad
+ * override and never changes routing eligibility.
+ */
+export function analyzeCatalogHealth({ providers = [], harnessDefault = null } = {}) {
+  const safeProviders = Array.isArray(providers) ? providers : [];
+  const hints = [];
+
+  if (safeProviders.length === 0) {
+    hints.push(healthHint(CATALOG_HEALTH_CODES.EMPTY_CATALOG, 'warning'));
+  }
+
+  for (const provider of safeProviders) {
+    const providerId = typeof provider?.id === 'string' ? provider.id : null;
+    const models = Array.isArray(provider?.models) ? provider.models : [];
+    if (provider?.error === 'MODEL_LIST_FAILED') {
+      hints.push(healthHint(CATALOG_HEALTH_CODES.PROVIDER_MODEL_LIST_FAILED, 'warning', { provider: providerId }));
+      continue;
+    }
+    if (models.length === 0) {
+      // Some providers intentionally accept exact model ids without advertising
+      // them. Keep this informational rather than turning it into a failure.
+      hints.push(healthHint(CATALOG_HEALTH_CODES.EMPTY_PROVIDER_MODELS, 'info', { provider: providerId }));
+    }
+  }
+
+  if (harnessDefault && typeof harnessDefault.provider === 'string' && typeof harnessDefault.model === 'string') {
+    const defaultProvider = safeProviders.find((provider) => provider?.id === harnessDefault.provider);
+    if (!defaultProvider) {
+      hints.push(healthHint(CATALOG_HEALTH_CODES.HARNESS_DEFAULT_PROVIDER_MISSING, 'warning', {
+        provider: harnessDefault.provider,
+        model: harnessDefault.model,
+      }));
+    } else if (defaultProvider.error !== 'MODEL_LIST_FAILED' && Array.isArray(defaultProvider.models) && defaultProvider.models.length > 0) {
+      const advertised = defaultProvider.models.some((model) => model?.id === harnessDefault.model);
+      if (!advertised) {
+        hints.push(healthHint(CATALOG_HEALTH_CODES.HARNESS_DEFAULT_MODEL_UNADVERTISED, 'info', {
+          provider: harnessDefault.provider,
+          model: harnessDefault.model,
+        }));
+      }
+    }
+  }
+
+  // A single provider advertising only one or two explicit models is a useful
+  // signal because local/provider overrides can produce this shape. It is only
+  // an INFO heuristic: legitimate providers can also have intentionally small
+  // catalogs, so Crew must not claim an override or route around it.
+  const healthyProviders = safeProviders.filter((provider) => provider?.error !== 'MODEL_LIST_FAILED');
+  const totalAdvertised = healthyProviders.reduce(
+    (sum, provider) => sum + (Array.isArray(provider?.models) ? provider.models.length : 0),
+    0,
+  );
+  if (healthyProviders.length === 1 && totalAdvertised > 0 && totalAdvertised <= 2) {
+    hints.push(healthHint(CATALOG_HEALTH_CODES.CATALOG_CONSTRAINED, 'info', {
+      provider: healthyProviders[0].id,
+      signal: 'single-provider-small-explicit-catalog',
+    }));
+  }
+
+  const warningCount = hints.filter((hint) => hint.level === 'warning').length;
+  const infoCount = hints.filter((hint) => hint.level === 'info').length;
+  return {
+    schema_version: 1,
+    warning_count: warningCount,
+    info_count: infoCount,
+    attention: warningCount > 0,
+    hints,
+  };
+}
+
+export async function readHarnessModelCatalog({ llm, getCurrentSelection, now = () => new Date().toISOString() } = {}) {
+  if (!llm || typeof llm.listProviders !== 'function' || typeof llm.listModels !== 'function') throw catalogError();
+  let rawProviders;
+  try {
+    rawProviders = llm.listProviders();
+  } catch {
+    throw catalogError();
+  }
+  if (!Array.isArray(rawProviders)) throw catalogError();
+  const providers = rawProviders.map(normalizeProvider).filter(Boolean);
+  let failed = 0;
+  const hydrated = await Promise.all(providers.map(async (provider) => {
+    try {
+      return { ...provider, models: normalizeModels(await llm.listModels(provider.id), provider.id) };
+    } catch {
+      failed += 1;
+      return { ...provider, models: [], error: 'MODEL_LIST_FAILED' };
+    }
+  }));
+  const harnessDefault = safeDefault(getCurrentSelection);
+  return {
+    providers: hydrated,
+    provider_count: hydrated.length,
+    model_count: hydrated.reduce((sum, provider) => sum + provider.models.length, 0),
+    harness_default: harnessDefault,
+    refreshed_at: now(),
+    partial: failed > 0,
+    health: analyzeCatalogHealth({ providers: hydrated, harnessDefault }),
+  };
+}

package/src/model-routing.mjs

@@ -0,0 +1,391 @@
+// Pure Harness-backed worker model selection. A worker tier describes a role,
+// not a fixed model: explicit provider/model priorities win, fresh configs may
+// use a tier-specific preferred model id, and Harness Default is the final
+// fallback. Catalog membership is advisory; provider registration is the
+// routing boundary.
+
+import { rankAdaptiveCandidates } from './adaptive-routing.mjs';
+
+export const DEFAULT_TIER_MODEL_PREFERENCES = Object.freeze({
+  flash: 'deepseek-v4-flash',
+  pro: 'deepseek-v4-pro',
+});
+
+// v0.2 role → default preferred model class. A role describes who does the
+// work; the model class is only the fresh-config recommendation until a
+// priority list or Harness Default takes over.
+export const DEFAULT_ROLE_MODEL_PREFERENCES = Object.freeze({
+  worker: 'deepseek-v4-flash',
+  reviewer: 'deepseek-v4-pro',
+});
+
+export const MODEL_FALLBACKS = ['harness-default'];
+export const NO_WORKER_MODEL_AVAILABLE = 'NO_WORKER_MODEL_AVAILABLE';
+export const MODEL_SELECTION_TRACE_VERSION = 1;
+export const MODEL_SELECTION_REASON_CODES = Object.freeze({
+  PROVIDER_UNAVAILABLE: 'PROVIDER_UNAVAILABLE',
+  PREFERRED_MODEL_UNAVAILABLE: 'PREFERRED_MODEL_UNAVAILABLE',
+  PREFERRED_MODEL_AMBIGUOUS: 'PREFERRED_MODEL_AMBIGUOUS',
+  ADAPTIVE_DEPRIORITIZED: 'ADAPTIVE_DEPRIORITIZED',
+  HARNESS_DEFAULT_INVALID: 'HARNESS_DEFAULT_INVALID',
+  HARNESS_DEFAULT_PROVIDER_UNAVAILABLE: 'HARNESS_DEFAULT_PROVIDER_UNAVAILABLE',
+  PRIMARY_CANDIDATES_EXHAUSTED: 'PRIMARY_CANDIDATES_EXHAUSTED',
+  ESCALATION_CANDIDATES_EXHAUSTED: 'ESCALATION_CANDIDATES_EXHAUSTED',
+  NO_AVAILABLE_MODEL: 'NO_AVAILABLE_MODEL',
+});
+
+export function normalizeModelRef(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const provider = typeof raw.provider === 'string' ? raw.provider.trim() : '';
+  const model = typeof raw.model === 'string' ? raw.model.trim() : '';
+  return provider && model ? { provider, model } : null;
+}
+
+export function modelRefKey(raw) {
+  const ref = normalizeModelRef(raw);
+  return ref ? `${ref.provider}\0${ref.model}` : '';
+}
+
+export function normalizeModelPriority(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = new Set();
+  const result = [];
+  for (const value of raw) {
+    const ref = normalizeModelRef(value);
+    if (!ref) continue;
+    const key = modelRefKey(ref);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(ref);
+  }
+  return result;
+}
+
+function providerMap(catalog) {
+  const map = new Map();
+  for (const raw of catalog?.providers ?? []) {
+    if (!raw || typeof raw.id !== 'string' || raw.id === '') continue;
+    map.set(raw.id, raw);
+  }
+  return map;
+}
+
+function normalizeAttempt(value) {
+  return Number.isInteger(value) && value >= 0 ? value : 0;
+}
+
+function normalizeModelClassHint(value) {
+  return value === 'flash' || value === 'pro' ? value : null;
+}
+
+function traceBase({
+  role = 'worker',
+  logicalAttempt = 0,
+  modelClassHint = null,
+  strategy = 'legacy-tier',
+  candidateSet = 'primary',
+  escalationReason = null,
+} = {}) {
+  return {
+    version: MODEL_SELECTION_TRACE_VERSION,
+    role: role === 'reviewer' ? 'reviewer' : 'worker',
+    logical_attempt: normalizeAttempt(logicalAttempt),
+    model_class_hint: normalizeModelClassHint(modelClassHint),
+    strategy: typeof strategy === 'string' && strategy ? strategy : 'legacy-tier',
+    candidate_set: typeof candidateSet === 'string' && candidateSet ? candidateSet : 'primary',
+    ordered_candidates: [],
+    selected: null,
+    selection_source: null,
+    fallback_reason: null,
+    escalation_reason: typeof escalationReason === 'string' && escalationReason ? escalationReason : null,
+  };
+}
+
+function candidateDecision(ref, source, status, { reasonCode, advertised } = {}) {
+  return {
+    provider: ref?.provider ?? null,
+    model: ref?.model ?? null,
+    source,
+    status,
+    ...(reasonCode ? { reason_code: reasonCode } : {}),
+    ...(advertised === false ? { advertised: false } : {}),
+  };
+}
+
+function selectTrace(trace, ref, source, { advertised, fallbackReason } = {}) {
+  trace.ordered_candidates.push(candidateDecision(ref, source, 'selected', { advertised }));
+  trace.selected = { provider: ref.provider, model: ref.model, source };
+  trace.selection_source = source;
+  trace.fallback_reason = fallbackReason ?? null;
+  return trace;
+}
+
+function rankForTrace(trace, candidates, {
+  adaptive,
+  adaptiveHealth,
+  explicitPriority = false,
+} = {}) {
+  const ranked = rankAdaptiveCandidates(candidates, {
+    config: adaptive,
+    healthStore: adaptiveHealth,
+    role: trace.role,
+    explicitPriority,
+  });
+  if (ranked.trace.enabled) trace.adaptive = ranked.trace;
+  return ranked;
+}
+
+/**
+ * Build a one-candidate trace for transports that intentionally bypass the
+ * Harness catalog (DeepSeek Official strict mode / standalone legacy mode).
+ */
+export function buildDirectSelectionTrace({
+  role = 'worker',
+  logicalAttempt = 0,
+  modelClassHint = null,
+  strategy = 'legacy-strict',
+  candidateSet = 'primary',
+  provider,
+  model,
+  source = 'legacy-strict',
+  escalationReason = null,
+} = {}) {
+  const trace = traceBase({ role, logicalAttempt, modelClassHint, strategy, candidateSet, escalationReason });
+  const ref = normalizeModelRef({ provider, model });
+  if (!ref) {
+    trace.fallback_reason = MODEL_SELECTION_REASON_CODES.NO_AVAILABLE_MODEL;
+    return trace;
+  }
+  return selectTrace(trace, ref, source);
+}
+
+/**
+ * Add workflow-only context after a transport has resolved the model. This is
+ * intentionally metadata-only: it never changes provider/model selection.
+ */
+export function enrichSelectionTrace(trace, {
+  role,
+  logicalAttempt,
+  modelClassHint,
+  escalationReason,
+} = {}) {
+  const base = trace && typeof trace === 'object'
+    ? {
+        ...trace,
+        ordered_candidates: Array.isArray(trace.ordered_candidates)
+          ? trace.ordered_candidates.map((item) => ({ ...item }))
+          : [],
+        selected: trace.selected && typeof trace.selected === 'object' ? { ...trace.selected } : null,
+        ...(trace.adaptive && typeof trace.adaptive === 'object'
+          ? {
+              adaptive: {
+                ...trace.adaptive,
+                candidates: Array.isArray(trace.adaptive.candidates)
+                  ? trace.adaptive.candidates.map((item) => ({ ...item }))
+                  : [],
+              },
+            }
+          : {}),
+      }
+    : traceBase({ role, logicalAttempt, modelClassHint, escalationReason });
+  if (role === 'worker' || role === 'reviewer') base.role = role;
+  if (Number.isInteger(logicalAttempt) && logicalAttempt >= 0) base.logical_attempt = logicalAttempt;
+  if (modelClassHint === 'flash' || modelClassHint === 'pro' || modelClassHint === null) {
+    base.model_class_hint = modelClassHint;
+  }
+  if (typeof escalationReason === 'string' && escalationReason) base.escalation_reason = escalationReason;
+  else if (logicalAttempt === 0) base.escalation_reason = null;
+  return base;
+}
+
+export function resolveWorkerModel({
+  tier,
+  priority,
+  priorityConfigured = false,
+  catalog,
+  harnessDefault,
+  fallback = 'harness-default',
+  preferredModelId = DEFAULT_TIER_MODEL_PREFERENCES[tier],
+  traceContext = {},
+  adaptive,
+  adaptiveHealth,
+} = {}) {
+  const providers = providerMap(catalog);
+  const normalizedPriority = normalizeModelPriority(priority);
+  const prioritySource = typeof traceContext.prioritySource === 'string' && traceContext.prioritySource
+    ? traceContext.prioritySource
+    : 'priority';
+  const trace = traceBase({
+    role: traceContext.role ?? 'worker',
+    logicalAttempt: traceContext.logicalAttempt ?? 0,
+    modelClassHint: traceContext.modelClassHint ?? null,
+    strategy: traceContext.strategy ?? 'legacy-tier',
+    candidateSet: traceContext.candidateSet ?? 'primary',
+    escalationReason: traceContext.escalationReason ?? null,
+  });
+
+  // Explicit priority — including an intentionally empty configured list — is
+  // authoritative. Adaptive mode records that bypass but never reorders it.
+  if (priorityConfigured || normalizedPriority.length > 0) {
+    rankForTrace(trace, normalizedPriority, { adaptive, adaptiveHealth, explicitPriority: true });
+  }
+
+  for (let index = 0; index < normalizedPriority.length; index++) {
+    const ref = normalizedPriority[index];
+    const provider = providers.get(ref.provider);
+    if (!provider) {
+      trace.ordered_candidates.push(candidateDecision(ref, prioritySource, 'skipped', {
+        reasonCode: MODEL_SELECTION_REASON_CODES.PROVIDER_UNAVAILABLE,
+      }));
+      continue;
+    }
+    const advertised = (provider.models ?? []).some((model) => model?.id === ref.model);
+    selectTrace(trace, ref, prioritySource, { advertised });
+    return {
+      ok: true,
+      ...ref,
+      source: 'priority',
+      matchedPriorityIndex: index,
+      ...(advertised ? {} : { advertised: false }),
+      selection_trace: trace,
+    };
+  }
+
+  // A manually managed list, including an intentionally empty list, replaces
+  // the fresh-config recommendation rather than silently re-inserting it.
+  if (!priorityConfigured && normalizedPriority.length === 0 && typeof preferredModelId === 'string') {
+    const matches = [];
+    for (const provider of providers.values()) {
+      if ((provider.models ?? []).some((model) => model?.id === preferredModelId)) {
+        matches.push({ provider: provider.id, model: preferredModelId });
+      }
+    }
+    if (matches.length === 1) {
+      rankForTrace(trace, matches, { adaptive, adaptiveHealth });
+      selectTrace(trace, matches[0], 'preferred-default');
+      return { ok: true, ...matches[0], source: 'preferred-default', selection_trace: trace };
+    }
+    if (matches.length > 1) {
+      const preferredProvider = normalizeModelRef(harnessDefault)?.provider;
+      const deterministicMatch = matches.find((candidate) => candidate.provider === preferredProvider) ?? null;
+      const baseline = deterministicMatch
+        ? [deterministicMatch, ...matches.filter((candidate) => candidate.provider !== deterministicMatch.provider)]
+        : matches;
+      const ranked = rankForTrace(trace, baseline, { adaptive, adaptiveHealth });
+      const adaptiveChoice = ranked.trace.decision_supported ? ranked.candidates[0] : null;
+      const match = adaptiveChoice ?? deterministicMatch;
+      if (match) {
+        const decisionOrder = adaptiveChoice ? ranked.candidates : matches;
+        for (const candidate of decisionOrder) {
+          if (candidate.provider === match.provider && candidate.model === match.model) continue;
+          trace.ordered_candidates.push(candidateDecision(candidate, 'preferred-default', 'skipped', {
+            reasonCode: adaptiveChoice
+              ? MODEL_SELECTION_REASON_CODES.ADAPTIVE_DEPRIORITIZED
+              : MODEL_SELECTION_REASON_CODES.PREFERRED_MODEL_AMBIGUOUS,
+          }));
+        }
+        selectTrace(trace, match, 'preferred-default');
+        return { ok: true, ...match, source: 'preferred-default', selection_trace: trace };
+      }
+      for (const candidate of matches) {
+        trace.ordered_candidates.push(candidateDecision(candidate, 'preferred-default', 'skipped', {
+          reasonCode: MODEL_SELECTION_REASON_CODES.PREFERRED_MODEL_AMBIGUOUS,
+        }));
+      }
+    } else {
+      rankForTrace(trace, [], { adaptive, adaptiveHealth });
+      trace.ordered_candidates.push(candidateDecision(
+        { provider: null, model: preferredModelId },
+        'preferred-default',
+        'skipped',
+        { reasonCode: MODEL_SELECTION_REASON_CODES.PREFERRED_MODEL_UNAVAILABLE },
+      ));
+    }
+  }
+
+  if (adaptive?.enabled === true && trace.adaptive === undefined) {
+    rankForTrace(trace, [], { adaptive, adaptiveHealth });
+  }
+
+  if (fallback === 'harness-default') {
+    const defaultRef = normalizeModelRef(harnessDefault);
+    if (!defaultRef) {
+      trace.ordered_candidates.push(candidateDecision(null, 'harness-default', 'skipped', {
+        reasonCode: MODEL_SELECTION_REASON_CODES.HARNESS_DEFAULT_INVALID,
+      }));
+    } else if (!providers.has(defaultRef.provider)) {
+      trace.ordered_candidates.push(candidateDecision(defaultRef, 'harness-default', 'skipped', {
+        reasonCode: MODEL_SELECTION_REASON_CODES.HARNESS_DEFAULT_PROVIDER_UNAVAILABLE,
+      }));
+    } else {
+      const fallbackReason = traceContext.candidateSet === 'escalation'
+        ? MODEL_SELECTION_REASON_CODES.ESCALATION_CANDIDATES_EXHAUSTED
+        : MODEL_SELECTION_REASON_CODES.PRIMARY_CANDIDATES_EXHAUSTED;
+      selectTrace(trace, defaultRef, 'harness-default', { fallbackReason });
+      return {
+        ok: true,
+        ...defaultRef,
+        source: 'harness-default',
+        ...(typeof harnessDefault.reasoningEffort === 'string' && harnessDefault.reasoningEffort
+          ? { reasoningEffort: harnessDefault.reasoningEffort }
+          : {}),
+        selection_trace: trace,
+      };
+    }
+  }
+  trace.fallback_reason = MODEL_SELECTION_REASON_CODES.NO_AVAILABLE_MODEL;
+  return {
+    ok: false,
+    code: NO_WORKER_MODEL_AVAILABLE,
+    message: `No Harness model is available for the ${tier ?? 'requested'} worker.`,
+    selection_trace: trace,
+  };
+}
+
+/**
+ * v0.2 role-based model selection. Turns a role's model policy (from
+ * policy.resolveModelPolicy) into an ordered selection:
+ *   attempt 0      → policy.priority (primary / cheap candidates)
+ *   attempt >= 1   → policy.escalation_priority (strong / escalation candidates)
+ *   otherwise      → Harness Default fallback
+ * The output shape matches resolveWorkerModel (provider/model/source/...) plus
+ * role + attempt so selection provenance lands in job metadata.
+ */
+export function resolveModel({
+  role = 'worker',
+  attempt = 0,
+  policy,
+  catalog,
+  harnessDefault,
+  adaptiveHealth,
+} = {}) {
+  const p = policy && typeof policy === 'object' ? policy : {};
+  const escalated = Number.isInteger(attempt) && attempt > 0;
+  const candidates = escalated ? p.escalation_priority : p.priority;
+  const configured = escalated
+    ? p.escalation_priority_configured === true || (Array.isArray(candidates) && candidates.length > 0)
+    : p.priorityConfigured === true || (Array.isArray(candidates) && candidates.length > 0);
+  // Escalation never re-picks the fresh "preferred" role default: an empty
+  // escalation pool falls through to Harness Default instead.
+  const preferredModelId = escalated ? undefined : DEFAULT_ROLE_MODEL_PREFERENCES[role] ?? undefined;
+  const result = resolveWorkerModel({
+    tier: role,
+    priority: candidates,
+    priorityConfigured: configured,
+    catalog,
+    harnessDefault,
+    fallback: p.fallback === 'harness-default' ? 'harness-default' : 'harness-default',
+    preferredModelId,
+    adaptive: p.adaptive,
+    adaptiveHealth,
+    traceContext: {
+      role,
+      logicalAttempt: attempt,
+      strategy: p.strategy ?? (role === 'reviewer' ? 'strong' : 'balanced'),
+      candidateSet: escalated ? 'escalation' : 'primary',
+      prioritySource: escalated ? 'escalation-priority' : 'priority',
+    },
+  });
+  if (!result.ok) return { ...result, role, attempt };
+  return { ...result, role, attempt };
+}