@ran-sh/dsh-crew 0.3.0

package/src/policy.mjs

@@ -0,0 +1,197 @@
+// v0.3 config-authority facade over the frozen v0.2 policy implementation.
+//
+// The v0.2 module remains byte-for-byte available as policy-legacy.mjs. New
+// callers import this facade. For schema-v3 persisted configs, the nested
+// worker/review/execution/legacy snapshot is authoritative; flat Flash/Pro
+// fields are compatibility mirrors only. Legacy files still flow through the
+// old migration exactly as before.
+
+export * from './policy-legacy.mjs';
+import * as legacy from './policy-legacy.mjs';
+import { normalizeAdaptiveRouting } from './adaptive-routing.mjs';
+
+export { normalizeAdaptiveRouting };
+export const CONFIG_SCHEMA_VERSION = 3;
+
+function validObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasCanonicalAuthority(raw) {
+  return Number(raw?.config_schema_version) >= CONFIG_SCHEMA_VERSION
+    && validObject(raw?.worker)
+    && validObject(raw?.review)
+    && validObject(raw?.execution);
+}
+
+function semanticLegacyMode(canonical) {
+  if (canonical.review.auto_review === true && canonical.review.state === 'auto') return 'review-pipeline';
+  if (canonical.worker.state === 'auto' && canonical.review.state === 'disabled'
+      && canonical.worker.model_policy.strategy === 'economy') return 'flash-only';
+  if (canonical.worker.state === 'auto' && canonical.review.state === 'disabled'
+      && canonical.worker.model_policy.strategy === 'quality') return 'pro-only';
+  if (canonical.worker.state === 'auto' && canonical.review.state === 'manual') return 'balanced';
+  return 'custom';
+}
+
+function normalizeLegacySnapshot(raw, canonical) {
+  // A nested v3 legacy snapshot is canonical compatibility metadata. Flat
+  // fields are only a fallback for transitional/pre-v3 inputs.
+  const nested = validObject(raw?.legacy) ? raw.legacy : {};
+  const source = { ...raw, ...nested };
+  const mode = legacy.COLLABORATION_MODES.includes(source.collaboration_mode)
+    ? source.collaboration_mode
+    : semanticLegacyMode(canonical);
+
+  let flash = legacy.TIER_STATES.includes(source.flash_state) ? source.flash_state : undefined;
+  let pro = legacy.TIER_STATES.includes(source.pro_state) ? source.pro_state : undefined;
+  if (mode === 'flash-only') { flash = 'auto'; pro = 'disabled'; }
+  else if (mode === 'pro-only') { flash = 'disabled'; pro = 'auto'; }
+  else if (mode === 'balanced' || mode === 'review-pipeline') { flash = 'auto'; pro = 'auto'; }
+  else {
+    flash ??= canonical.worker.state;
+    // reviewer=manual historically means the Pro tier is available/Auto but
+    // review itself is on-demand. Preserve an explicit nested pro state when
+    // present; otherwise use a conservative compatibility reconstruction.
+    pro ??= canonical.review.state === 'disabled' ? 'disabled' : 'auto';
+  }
+
+  return {
+    collaboration_mode: mode,
+    tier_policy: mode === 'flash-only' ? 'flash-only' : mode === 'pro-only' ? 'pro-only' : 'auto',
+    flash_state: flash,
+    pro_state: pro,
+  };
+}
+
+function modelPolicyWithAdaptive(basePolicy, rawPolicy) {
+  return {
+    ...basePolicy,
+    adaptive: normalizeAdaptiveRouting(rawPolicy?.adaptive),
+  };
+}
+
+function normalizeCanonical(raw) {
+  const base = legacy.getCanonical(raw);
+  const providerMode = legacy.normalizeWorkerProviderMode(base.worker?.provider_mode);
+  const canonical = {
+    ...base,
+    execution: {
+      ...base.execution,
+      // There is one global dispatch permission. `execution.enabled` is a
+      // canonical mirror of the top-level switch, never a second authority.
+      enabled: base.subagents_enabled,
+    },
+    worker: {
+      ...base.worker,
+      provider_mode: providerMode,
+      model_policy: modelPolicyWithAdaptive(base.worker.model_policy, raw?.worker?.model_policy),
+    },
+    review: {
+      ...base.review,
+      // v0.3 still exposes one Worker Provider selector. Until per-role
+      // provider modes become first-class, keep both roles aligned.
+      provider_mode: providerMode,
+      model_policy: modelPolicyWithAdaptive(base.review.model_policy, raw?.review?.model_policy),
+    },
+  };
+  canonical.legacy = normalizeLegacySnapshot(raw, canonical);
+  return canonical;
+}
+
+function proMirror(canonical) {
+  const escalation = canonical.worker.model_policy;
+  const reviewer = canonical.review.model_policy;
+  if (escalation.escalation_priority_configured || escalation.escalation_priority.length > 0) {
+    return {
+      priority: escalation.escalation_priority,
+      configured: escalation.escalation_priority_configured,
+      fallback: escalation.fallback,
+    };
+  }
+  return {
+    priority: reviewer.priority,
+    configured: reviewer.priorityConfigured,
+    fallback: reviewer.fallback,
+  };
+}
+
+function legacyRoutingMirror(canonical) {
+  // Legacy tier/UI behavior has its own canonical compatibility sub-domain.
+  // Never infer this back from flat mirrors: schema-v3 `legacy` owns it.
+  return normalizeLegacySnapshot({ legacy: canonical.legacy }, canonical);
+}
+
+/**
+ * Re-exported normalizer with schema-v3 precedence.
+ *
+ * `legacy.normalizeGlobalConfig` remains the import path for legacy-file
+ * migration. Once schema v3 is present, flat compatibility fields are rebuilt
+ * from the canonical snapshot so a stale/manual mirror cannot override runtime
+ * behavior.
+ */
+export function normalizeGlobalConfig(raw = {}) {
+  const normalized = legacy.normalizeGlobalConfig(raw);
+  if (!hasCanonicalAuthority(raw)) return normalized;
+
+  const canonical = normalizeCanonical(raw);
+  const pro = proMirror(canonical);
+  const routing = legacyRoutingMirror(canonical);
+  return {
+    ...normalized,
+    config_schema_version: CONFIG_SCHEMA_VERSION,
+    subagents_enabled: canonical.subagents_enabled,
+    main_agent_mode: canonical.main_agent_mode,
+    default_effort: canonical.execution.default_effort,
+    default_timeout_seconds: canonical.execution.default_timeout_seconds,
+    mode: canonical.execution.mode,
+    max_parallel: canonical.execution.max_parallel,
+    isolation: canonical.execution.isolation,
+    collaboration_mode: routing.collaboration_mode,
+    tier_policy: routing.tier_policy,
+    flash_state: routing.flash_state,
+    pro_state: routing.pro_state,
+    worker_state: canonical.worker.state,
+    review_state: canonical.review.state,
+    auto_review: canonical.review.auto_review === true,
+    worker_provider_mode: canonical.worker.provider_mode,
+    flash_model_priority: [...canonical.worker.model_policy.priority],
+    flash_model_priority_configured: canonical.worker.model_policy.priorityConfigured,
+    flash_model_fallback: canonical.worker.model_policy.fallback,
+    pro_model_priority: [...pro.priority],
+    pro_model_priority_configured: pro.configured,
+    pro_model_fallback: pro.fallback,
+    escalate_on_failure: canonical.worker.model_policy.escalation.enabled,
+    pro_reviews_flash: canonical.review.auto_review === true,
+    execution: canonical.execution,
+    worker: canonical.worker,
+    review: canonical.review,
+    legacy: canonical.legacy,
+  };
+}
+
+/**
+ * v0.3 model-policy view. The frozen v0.2 resolver remains authoritative for
+ * every existing dimension. This facade only adds the normalized opt-in
+ * adaptive sub-domain, so direct canonical-ish v0.2 callers retain the exact
+ * priority/escalation semantics they had before schema-v3 existed.
+ */
+export function resolveModelPolicy(config = {}, role = 'worker', context = {}) {
+  const base = legacy.resolveModelPolicy(config, role, context);
+  const rawPolicy = role === 'reviewer'
+    ? config?.review?.model_policy
+    : config?.worker?.model_policy;
+  return {
+    ...base,
+    adaptive: normalizeAdaptiveRouting(rawPolicy?.adaptive ?? base.adaptive),
+  };
+}
+
+/** Explicit legacy-import normalizer for the persistence layer. */
+export function normalizeLegacyGlobalConfig(raw = {}) {
+  return legacy.normalizeGlobalConfig(raw);
+}
+
+export function configHasCanonicalAuthority(raw = {}) {
+  return hasCanonicalAuthority(raw);
+}

package/src/readiness-matrix.mjs

@@ -0,0 +1,169 @@
+// Conservative release/environment readiness matrix.
+//
+// A row is PASS only when the caller supplies direct evidence for that row.
+// Missing evidence is NOT_RUN, not an inferred success. Runtime observations
+// (Hub handshake / catalog read) are intentionally separate from execution
+// verification (real worker, reviewer, cancellation, timeout, etc.).
+
+export const READINESS_STATUSES = Object.freeze(['PASS', 'FAIL', 'BLOCKED', 'SKIP', 'NOT_RUN']);
+
+export const READINESS_REASON_CODES = Object.freeze({
+  LIVE_CHECK_PASSED: 'LIVE_CHECK_PASSED',
+  HUB_UNREACHABLE: 'HUB_UNREACHABLE',
+  HUB_INCOMPATIBLE: 'HUB_INCOMPATIBLE',
+  PROVIDER_CATALOG_RESOLVED: 'PROVIDER_CATALOG_RESOLVED',
+  PROVIDER_CATALOG_UNAVAILABLE: 'PROVIDER_CATALOG_UNAVAILABLE',
+  PROVIDER_CATALOG_HEALTH_WARNING: 'PROVIDER_CATALOG_HEALTH_WARNING',
+  PROVIDER_CATALOG_NOT_REQUIRED: 'PROVIDER_CATALOG_NOT_REQUIRED',
+  PROVIDER_MODE_UNKNOWN: 'PROVIDER_MODE_UNKNOWN',
+  NO_CI_EVIDENCE: 'NO_CI_EVIDENCE',
+  NO_EXECUTION_EVIDENCE: 'NO_EXECUTION_EVIDENCE',
+  CREDENTIAL_STATUS_NOT_PROBED: 'CREDENTIAL_STATUS_NOT_PROBED',
+  EVIDENCE_REPORTED: 'EVIDENCE_REPORTED',
+});
+
+const TARGET_ROWS = Object.freeze([
+  ['linux_deterministic', 'ci'],
+  ['windows_regressions', 'ci'],
+  ['macos_smoke', 'ci'],
+  ['hub_compatibility', 'live-runtime'],
+  ['provider_catalog', 'live-runtime'],
+  ['deepseek_flash', 'real-execution'],
+  ['deepseek_pro', 'real-execution'],
+  ['opencode_go_mimo_qwen', 'real-execution'],
+  ['reviewer_pipeline', 'real-execution'],
+  ['cancellation_timeout_escalation', 'real-execution'],
+  ['standalone_official', 'real-execution'],
+]);
+
+function baseRow(id, category, status, reasonCode, evidenceSource = 'none', extra = {}) {
+  return {
+    id,
+    category,
+    status,
+    reason_code: reasonCode,
+    evidence_source: evidenceSource,
+    ...extra,
+  };
+}
+
+function normalizeEvidence(row, evidence) {
+  if (!evidence || typeof evidence !== 'object') return row;
+  if (!READINESS_STATUSES.includes(evidence.status)) return row;
+  const reason = typeof evidence.reason_code === 'string' && evidence.reason_code.trim()
+    ? evidence.reason_code.trim()
+    : READINESS_REASON_CODES.EVIDENCE_REPORTED;
+  const source = typeof evidence.evidence_source === 'string' && evidence.evidence_source.trim()
+    ? evidence.evidence_source.trim()
+    : 'reported-evidence';
+  return {
+    ...row,
+    status: evidence.status,
+    reason_code: reason,
+    evidence_source: source,
+    ...(typeof evidence.evidence_ref === 'string' && evidence.evidence_ref.trim()
+      ? { evidence_ref: evidence.evidence_ref.trim() }
+      : {}),
+  };
+}
+
+function defaultRows() {
+  return Object.fromEntries(TARGET_ROWS.map(([id, category]) => {
+    const reason = category === 'ci'
+      ? READINESS_REASON_CODES.NO_CI_EVIDENCE
+      : id === 'standalone_official'
+        ? READINESS_REASON_CODES.CREDENTIAL_STATUS_NOT_PROBED
+        : READINESS_REASON_CODES.NO_EXECUTION_EVIDENCE;
+    return [id, baseRow(id, category, 'NOT_RUN', reason)];
+  }));
+}
+
+/**
+ * Build a secret-free readiness matrix from direct runtime observations plus
+ * optional trusted evidence supplied by a higher layer.
+ *
+ * `evidence` is deliberately inert metadata: this module never reads files,
+ * credentials, GitHub, provider config, or the network on its own.
+ */
+export function buildReadinessMatrix({
+  platform = process.platform,
+  hubCompatibility = null,
+  workerProviderMode = null,
+  providerCatalogChecked = false,
+  providerCatalogOk = false,
+  evidence = {},
+} = {}) {
+  const rows = defaultRows();
+
+  if (hubCompatibility?.compatible === true) {
+    rows.hub_compatibility = baseRow(
+      'hub_compatibility', 'live-runtime', 'PASS',
+      READINESS_REASON_CODES.LIVE_CHECK_PASSED, 'hub-handshake',
+      {
+        runtime_version: hubCompatibility.runtime_version ?? null,
+        protocol_version: hubCompatibility.protocol_version ?? null,
+      },
+    );
+  } else if (hubCompatibility?.reachable === true) {
+    rows.hub_compatibility = baseRow(
+      'hub_compatibility', 'live-runtime', 'FAIL',
+      READINESS_REASON_CODES.HUB_INCOMPATIBLE, 'hub-handshake',
+      { detail_code: hubCompatibility.code ?? null },
+    );
+  } else {
+    rows.hub_compatibility = baseRow(
+      'hub_compatibility', 'live-runtime', 'BLOCKED',
+      READINESS_REASON_CODES.HUB_UNREACHABLE, 'hub-handshake',
+      { detail_code: hubCompatibility?.code ?? null },
+    );
+  }
+
+  if (workerProviderMode == null) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'NOT_RUN',
+      READINESS_REASON_CODES.PROVIDER_MODE_UNKNOWN, 'none',
+    );
+  } else if (workerProviderMode === 'deepseek-official') {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'SKIP',
+      READINESS_REASON_CODES.PROVIDER_CATALOG_NOT_REQUIRED, 'runtime-policy',
+    );
+  } else if (!hubCompatibility?.compatible) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'BLOCKED',
+      hubCompatibility?.reachable
+        ? READINESS_REASON_CODES.HUB_INCOMPATIBLE
+        : READINESS_REASON_CODES.HUB_UNREACHABLE,
+      'hub-handshake',
+      { detail_code: hubCompatibility?.code ?? null },
+    );
+  } else if (providerCatalogChecked && providerCatalogOk) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'PASS',
+      READINESS_REASON_CODES.PROVIDER_CATALOG_RESOLVED, 'harness-catalog',
+    );
+  } else if (providerCatalogChecked) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'FAIL',
+      READINESS_REASON_CODES.PROVIDER_CATALOG_UNAVAILABLE, 'harness-catalog',
+    );
+  }
+
+  for (const [id] of TARGET_ROWS) {
+    rows[id] = normalizeEvidence(rows[id], evidence?.[id]);
+  }
+
+  const ordered = TARGET_ROWS.map(([id]) => rows[id]);
+  const counts = Object.fromEntries(READINESS_STATUSES.map((status) => [
+    status,
+    ordered.filter((row) => row.status === status).length,
+  ]));
+
+  return {
+    schema_version: 1,
+    platform,
+    conservative: true,
+    summary: counts,
+    rows: ordered,
+  };
+}

package/src/runtime-controls.mjs

@@ -0,0 +1,90 @@
+// Runtime control activation contract.
+//
+// This is deliberately data, not UI prose. MCP diagnostics and the Settings
+// surface consume the same boundary definitions so users are never told two
+// different stories about when a config change takes effect.
+
+export const ACTIVATION_BOUNDARY = Object.freeze({
+  LIVE: 'live',
+  NEXT_WORKFLOW: 'next-workflow',
+  NEXT_SESSION: 'next-session',
+  RESTART_REQUIRED: 'restart-required',
+});
+
+const N = ACTIVATION_BOUNDARY.NEXT_WORKFLOW;
+const S = ACTIVATION_BOUNDARY.NEXT_SESSION;
+const L = ACTIVATION_BOUNDARY.LIVE;
+const R = ACTIVATION_BOUNDARY.RESTART_REQUIRED;
+
+/**
+ * `global` describes a write made through persisted Settings/config.
+ * `session` describes an explicit dsh_worker_config override in the already
+ * running MCP process. `session: null` means the setting is not a session
+ * override surface.
+ */
+export const RUNTIME_SETTING_ACTIVATION = Object.freeze({
+  max_parallel: Object.freeze({ global: L, session: null, note: 'Admission limit refreshes before new workflow starts and when slots release; lowering never cancels active work.' }),
+
+  subagents_enabled: Object.freeze({ global: N, session: N }),
+  collaboration_mode: Object.freeze({ global: N, session: N }),
+  main_agent_mode: Object.freeze({ global: N, session: N }),
+  flash_state: Object.freeze({ global: N, session: N }),
+  pro_state: Object.freeze({ global: N, session: N }),
+  worker_state: Object.freeze({ global: N, session: N }),
+  review_state: Object.freeze({ global: N, session: N }),
+  auto_review: Object.freeze({ global: N, session: N }),
+  pro_reviews_flash: Object.freeze({ global: N, session: N }),
+  worker_provider_mode: Object.freeze({ global: N, session: null }),
+  flash_model_priority: Object.freeze({ global: N, session: null }),
+  flash_model_fallback: Object.freeze({ global: N, session: null }),
+  pro_model_priority: Object.freeze({ global: N, session: null }),
+  pro_model_fallback: Object.freeze({ global: N, session: null }),
+  adaptive_routing: Object.freeze({ global: N, session: null, note: 'Opt-in provider health ordering is read for the next Hub model selection; existing explicit priorities remain authoritative.' }),
+  isolation: Object.freeze({ global: N, session: null }),
+  vision_provider: Object.freeze({ global: N, session: null }),
+  vision_model: Object.freeze({ global: N, session: null }),
+  imagegen_provider: Object.freeze({ global: N, session: null }),
+
+  // These values are copied into the MCP session defaults at process startup.
+  // dsh_worker_config can override them for subsequent workflows in that same
+  // session, but persisted global edits require a new MCP session to inherit.
+  default_tier: Object.freeze({ global: S, session: N }),
+  default_effort: Object.freeze({ global: S, session: N }),
+  mode: Object.freeze({ global: S, session: N }),
+  default_timeout_seconds: Object.freeze({ global: S, session: N }),
+  escalate_on_failure: Object.freeze({ global: S, session: N }),
+  preset_flash: Object.freeze({ global: S, session: N }),
+  preset_pro: Object.freeze({ global: S, session: N }),
+
+  // hub-client freezes its base URL at module initialization. Crew Vision and
+  // Image Generation tool registration is also decided at Hub plugin boot.
+  hub_url: Object.freeze({ global: R, session: null }),
+  vision_enabled: Object.freeze({ global: R, session: null }),
+  imagegen_enabled: Object.freeze({ global: R, session: null }),
+});
+
+export function activationForSetting(key) {
+  const entry = RUNTIME_SETTING_ACTIVATION[key];
+  return entry ? { ...entry } : null;
+}
+
+export function runtimeActivationMetadata() {
+  return Object.fromEntries(
+    Object.entries(RUNTIME_SETTING_ACTIVATION).map(([key, value]) => [key, { ...value }]),
+  );
+}
+
+export function summarizeActivationBoundaries(metadata = RUNTIME_SETTING_ACTIVATION) {
+  const out = {
+    live: [],
+    'next-workflow': [],
+    'next-session': [],
+    'restart-required': [],
+  };
+  for (const [key, entry] of Object.entries(metadata)) {
+    const boundary = entry?.global;
+    if (out[boundary]) out[boundary].push(key);
+  }
+  for (const values of Object.values(out)) values.sort();
+  return out;
+}

package/src/runtime-identity.mjs

@@ -0,0 +1,108 @@
+// Shared runtime identity and Hub compatibility contract.
+//
+// Package/release semver and the wire protocol are intentionally separate:
+// - RUNTIME_VERSION identifies the source/runtime generation for diagnostics.
+// - HUB_PROTOCOL_VERSION changes only when Hub <-> MCP wire semantics become
+//   incompatible.
+//
+// Keep this module pure and dependency-free so Hub, MCP and tests all use the
+// exact same compatibility rules.
+
+export const RUNTIME_VERSION = '0.3.0';
+export const HUB_PROTOCOL_VERSION = 1;
+
+export const HUB_CAPABILITIES = Object.freeze([
+  'jobs',
+  'jobs-wait',
+  'jobs-cancel',
+  'roles',
+  'attempt-index',
+  'model-policy',
+  'model-catalog',
+  'presets',
+  'config',
+]);
+
+// Capabilities the current MCP workflow depends on for full Hub execution.
+// Additional capabilities may be advertised without breaking compatibility.
+export const REQUIRED_HUB_CAPABILITIES = Object.freeze([
+  'jobs',
+  'jobs-wait',
+  'jobs-cancel',
+  'roles',
+  'attempt-index',
+  'model-policy',
+]);
+
+export const HUB_COMPATIBILITY_CODES = Object.freeze({
+  UNREACHABLE: 'HUB_UNREACHABLE',
+  HTTP_ERROR: 'HUB_HTTP_ERROR',
+  SERVICE_MISMATCH: 'HUB_SERVICE_MISMATCH',
+  PROTOCOL_MISSING: 'HUB_PROTOCOL_MISSING',
+  PROTOCOL_MISMATCH: 'HUB_PROTOCOL_MISMATCH',
+  CAPABILITY_MISSING: 'HUB_CAPABILITY_MISSING',
+});
+
+function normalizedCapabilities(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.filter((item) => typeof item === 'string' && item.trim()).map((item) => item.trim()))];
+}
+
+export function getHubRuntimeIdentity() {
+  return {
+    service: 'dsh-crew-hub',
+    runtime_version: RUNTIME_VERSION,
+    protocol_version: HUB_PROTOCOL_VERSION,
+    capabilities: [...HUB_CAPABILITIES],
+  };
+}
+
+/**
+ * Evaluate an already-received Hub ping body.
+ *
+ * This function does no I/O. `reachable` means an HTTP response was received;
+ * `compatible` means the response is from dsh-crew and satisfies the current
+ * protocol + required capability contract.
+ */
+export function evaluateHubHandshake(body, { requiredCapabilities = REQUIRED_HUB_CAPABILITIES } = {}) {
+  const capabilities = normalizedCapabilities(body?.capabilities);
+  const base = {
+    reachable: true,
+    compatible: false,
+    service: typeof body?.service === 'string' ? body.service : null,
+    runtime_version: typeof body?.runtime_version === 'string' ? body.runtime_version : null,
+    protocol_version: Number.isInteger(body?.protocol_version) ? body.protocol_version : null,
+    capabilities,
+    missing_capabilities: [],
+    code: null,
+  };
+
+  if (body?.service !== 'dsh-crew-hub') {
+    return { ...base, code: HUB_COMPATIBILITY_CODES.SERVICE_MISMATCH };
+  }
+
+  if (!Number.isInteger(body?.protocol_version)) {
+    return { ...base, code: HUB_COMPATIBILITY_CODES.PROTOCOL_MISSING };
+  }
+
+  if (body.protocol_version !== HUB_PROTOCOL_VERSION) {
+    return { ...base, code: HUB_COMPATIBILITY_CODES.PROTOCOL_MISMATCH };
+  }
+
+  const required = normalizedCapabilities(requiredCapabilities);
+  const advertised = new Set(capabilities);
+  const missing = required.filter((capability) => !advertised.has(capability));
+  if (missing.length > 0) {
+    return {
+      ...base,
+      missing_capabilities: missing,
+      code: HUB_COMPATIBILITY_CODES.CAPABILITY_MISSING,
+    };
+  }
+
+  return {
+    ...base,
+    compatible: true,
+    code: null,
+  };
+}