avorelo 0.1.0

package/scripts/lib/skills-operating-layer.js

@@ -0,0 +1,580 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { buildSkillRegistry, GENERATED_SKILL_REGISTRY_REL_PATH } = require("./avorelo-skill-registry");
+const { appendProductLearningEvent } = require("./product-learning-events");
+const { ensureCcoDirs, nowIso, safeReadJson, safeWriteJson } = require("./fsx");
+
+const SKILLS_CONTRACT = "avorelo.skillsOperatingLayer.v1";
+const SKILLS_SCHEMA_VERSION = 1;
+const LATEST_SOURCE_ADOPTION_RECEIPT_REL_PATH = ".claude/cco/skills/latest-source-adoption.json";
+const LATEST_SKILL_ROUTE_RECEIPT_REL_PATH = ".claude/cco/skills/latest-route.json";
+const LATEST_ADAPTER_SYNC_RECEIPT_REL_PATH = ".claude/cco/skills/latest-adapter-sync.json";
+const LATEST_SKILL_HYGIENE_RECEIPT_REL_PATH = ".claude/cco/skills/latest-hygiene.json";
+const LATEST_SKILL_INTAKE_CHECK_REL_PATH = ".claude/cco/skills/latest-intake-check.json";
+
+function unique(values) {
+  return [...new Set((values || []).filter(Boolean))];
+}
+
+function receiptPath(cwd, relPath) {
+  return path.join(cwd, relPath);
+}
+
+function topWarningCodes(registry) {
+  const counts = new Map();
+  (registry.skills || []).forEach((skill) => {
+    (skill.warnings || []).forEach((warning) => {
+      counts.set(warning.code, (counts.get(warning.code) || 0) + 1);
+    });
+  });
+  return Array.from(counts.entries())
+    .sort((left, right) => right[1] - left[1])
+    .slice(0, 5)
+    .map(([code]) => code);
+}
+
+function sourceCountsFromRegistry(registry) {
+  const summary = registry?.summary || {};
+  return {
+    reviewedSourceIds: unique(summary.reviewedSourceIds || []),
+    deferredSourceIds: unique(summary.deferredSourceIds || []),
+    blockedSourceIds: unique(summary.blockedSourceIds || []),
+  };
+}
+
+function writeReceipt(cwd, relPath, payload) {
+  ensureCcoDirs(cwd);
+  safeWriteJson(cwd, relPath, payload);
+  return relPath;
+}
+
+function buildSourceAdoptionReceipt(cwd, registry) {
+  const counts = sourceCountsFromRegistry(registry);
+  const payload = {
+    schemaVersion: SKILLS_SCHEMA_VERSION,
+    contract: SKILLS_CONTRACT,
+    receiptType: "source_adoption",
+    createdAt: nowIso(),
+    registryPath: GENERATED_SKILL_REGISTRY_REL_PATH,
+    reviewedSources: counts.reviewedSourceIds,
+    deferredSources: counts.deferredSourceIds,
+    blockedSources: counts.blockedSourceIds,
+    importedSkillIds: (registry.skills || []).filter((skill) => skill.packId !== "avorelo").map((skill) => skill.id),
+    parsedSkills: registry.summary?.totalSkills || 0,
+    warnings: registry.warnings || [],
+    topWarningCodes: topWarningCodes(registry),
+    redacted: true,
+  };
+  return {
+    path: writeReceipt(cwd, LATEST_SOURCE_ADOPTION_RECEIPT_REL_PATH, payload),
+    receipt: payload,
+  };
+}
+
+function buildSkillRouteReceipt(cwd, routeResult) {
+  const payload = {
+    schemaVersion: SKILLS_SCHEMA_VERSION,
+    contract: SKILLS_CONTRACT,
+    receiptType: "skill_route",
+    createdAt: nowIso(),
+    task: routeResult.task,
+    primarySkillId: routeResult.primarySkill?.id || null,
+    supportingSkillIds: (routeResult.supportingSkills || []).map((skill) => skill.id),
+    selectedCapabilities: routeResult.selectedCapabilities || [],
+    deferredSources: routeResult.deferredSources || [],
+    skippedSkills: (routeResult.skippedSkills || []).slice(0, 10),
+    evidenceRequirements: routeResult.evidenceRequirements || [],
+    verificationRequirements: routeResult.verificationRequirements || [],
+    skillContextWarnings: routeResult.skillContextWarnings || [],
+    contextWeight: routeResult.contextWeight || null,
+    nextAction: routeResult.nextAction || "",
+    redacted: true,
+  };
+  return {
+    path: writeReceipt(cwd, LATEST_SKILL_ROUTE_RECEIPT_REL_PATH, payload),
+    receipt: payload,
+  };
+}
+
+function buildAdapterSyncReceipt(cwd, result, registry) {
+  const counts = sourceCountsFromRegistry(registry);
+  const payload = {
+    schemaVersion: SKILLS_SCHEMA_VERSION,
+    contract: SKILLS_CONTRACT,
+    receiptType: "adapter_sync",
+    createdAt: nowIso(),
+    generatedFiles: result.generatedFiles || [],
+    skippedFiles: result.skippedFiles || result.skipped || [],
+    parsedSkills: registry.summary?.totalSkills || 0,
+    reviewedSources: counts.reviewedSourceIds.length,
+    deferredSources: counts.deferredSourceIds.length,
+    provenanceLineIncluded: true,
+    redacted: true,
+  };
+  return {
+    path: writeReceipt(cwd, LATEST_ADAPTER_SYNC_RECEIPT_REL_PATH, payload),
+    receipt: payload,
+  };
+}
+
+function appendSourceAdoptionEvents(cwd, registry, receiptPathValue) {
+  const counts = sourceCountsFromRegistry(registry);
+  counts.reviewedSourceIds.forEach((sourceId) => {
+    appendProductLearningEvent(cwd, {
+      eventName: "source_reviewed",
+      category: "skills_reference_adoption",
+      surface: "avorelo_skills_cli",
+      status: "pass",
+      payload: { sourceId },
+    });
+  });
+  counts.deferredSourceIds.forEach((sourceId) => {
+    appendProductLearningEvent(cwd, {
+      eventName: "source_deferred",
+      category: "skills_reference_adoption",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { sourceId },
+    });
+  });
+  counts.blockedSourceIds.forEach((sourceId) => {
+    appendProductLearningEvent(cwd, {
+      eventName: "source_blocked",
+      category: "skills_reference_adoption",
+      surface: "avorelo_skills_cli",
+      status: "block",
+      payload: { sourceId },
+    });
+  });
+  (registry.skills || []).forEach((skill) => {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_parsed",
+      category: "skills_reference_adoption",
+      surface: "avorelo_skills_cli",
+      status: skill.warnings?.length ? "warn" : "pass",
+      payload: {
+        skillId: skill.id,
+        packId: skill.packId,
+        warningCount: skill.warnings?.length || 0,
+      },
+    });
+    if (skill.warnings?.length) {
+      appendProductLearningEvent(cwd, {
+        eventName: "skill_parse_warning",
+        category: "skills_reference_adoption",
+        surface: "avorelo_skills_cli",
+        status: "warn",
+        payload: {
+          skillId: skill.id,
+          warningCodes: (skill.warnings || []).map((warning) => warning.code).slice(0, 5),
+        },
+      });
+    }
+    if ((skill.capabilityBindingSuggestions || []).length) {
+      appendProductLearningEvent(cwd, {
+        eventName: "skill_bound",
+        category: "skills_reference_adoption",
+        surface: "avorelo_skills_cli",
+        status: "pass",
+        payload: {
+          skillId: skill.id,
+          capabilityCount: skill.capabilityBindingSuggestions.length,
+        },
+      });
+    }
+  });
+  appendProductLearningEvent(cwd, {
+    eventName: "source_adoption_receipt_written",
+    category: "skills_reference_adoption",
+    surface: "avorelo_skills_cli",
+    status: "pass",
+    payload: {
+      receiptPath: receiptPathValue,
+      parsedSkills: registry.summary?.totalSkills || 0,
+      reviewedSources: counts.reviewedSourceIds.length,
+      deferredSources: counts.deferredSourceIds.length,
+    },
+  });
+}
+
+function appendRouteEvents(cwd, routeResult, receiptPathValue) {
+  if (routeResult.primarySkill) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_router_hit",
+      category: "skills_reference_adoption",
+      surface: "avorelo_skills_cli",
+      status: "pass",
+      payload: {
+        skillId: routeResult.primarySkill.id,
+        supportingSkillCount: (routeResult.supportingSkills || []).length,
+        contextWeight: routeResult.contextWeight?.label || "low",
+      },
+    });
+  } else {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_router_skipped",
+      category: "skills_reference_adoption",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: {
+        reason: "no_match",
+        deferredSourceCount: (routeResult.deferredSources || []).length,
+      },
+    });
+  }
+  appendProductLearningEvent(cwd, {
+    eventName: "source_adoption_receipt_written",
+    category: "skills_reference_adoption",
+    surface: "avorelo_skills_cli",
+    status: "pass",
+    payload: {
+      receiptPath: receiptPathValue,
+      receiptType: "skill_route",
+    },
+  });
+}
+
+function appendAdapterEvents(cwd, result, receiptPathValue) {
+  if ((result.generatedFiles || []).length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "adapter_generated",
+      category: "skills_reference_adoption",
+      surface: "adapter_sync",
+      status: "pass",
+      payload: {
+        fileCount: result.generatedFiles.length,
+      },
+    });
+  }
+  if ((result.skippedFiles || result.skipped || []).length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "adapter_generation_skipped",
+      category: "skills_reference_adoption",
+      surface: "adapter_sync",
+      status: "warn",
+      payload: {
+        fileCount: (result.skippedFiles || result.skipped || []).length,
+      },
+    });
+  }
+  appendProductLearningEvent(cwd, {
+    eventName: "source_adoption_receipt_written",
+    category: "skills_reference_adoption",
+    surface: "adapter_sync",
+    status: "pass",
+    payload: {
+      receiptPath: receiptPathValue,
+      receiptType: "adapter_sync",
+    },
+  });
+}
+
+function buildSkillHygieneReceipt(cwd, hygiene) {
+  const payload = {
+    schemaVersion: SKILLS_SCHEMA_VERSION,
+    contract: hygiene.contract || "avorelo.skillHygiene.v1",
+    receiptType: "skill_hygiene",
+    createdAt: nowIso(),
+    hygieneStatus: hygiene.hygieneStatus,
+    summary: hygiene.summary || {},
+    duplicateGroupCount: (hygiene.duplicateGroups || []).length,
+    conflictGroupCount: (hygiene.conflictGroups || []).length,
+    shadowCandidateCount: (hygiene.shadowCandidates || []).length,
+    acceptedContributionCount: hygiene.summary?.acceptedContributions || 0,
+    rejectedContributionCount: hygiene.summary?.rejectedContributions || 0,
+    contextHeavySkillCount: (hygiene.contextHeavySkills || []).length,
+    unsafeSkillCount: (hygiene.unsafeSkills || []).length,
+    topReasonCodes: hygiene.topReasonCodes || [],
+    nextAction: hygiene.nextAction || "",
+    redacted: true,
+  };
+  return {
+    path: writeReceipt(cwd, LATEST_SKILL_HYGIENE_RECEIPT_REL_PATH, payload),
+    receipt: payload,
+  };
+}
+
+function buildSkillIntakeCheckReceipt(cwd, check) {
+  const payload = {
+    schemaVersion: SKILLS_SCHEMA_VERSION,
+    contract: check.contract || "avorelo.skillIntakeCheck.v1",
+    receiptType: "skill_intake_check",
+    createdAt: nowIso(),
+    candidatePath: check.candidatePath,
+    candidateSkillId: check.candidateSkillId || null,
+    decision: check.decision,
+    reasonCodes: check.reasonCodes || [],
+    duplicateMatchCount: (check.duplicateMatches || []).length,
+    conflictMatchCount: (check.conflictMatches || []).length,
+    securityFlagCount: (check.securityFlags || []).length,
+    redacted: true,
+  };
+  return {
+    path: writeReceipt(cwd, LATEST_SKILL_INTAKE_CHECK_REL_PATH, payload),
+    receipt: payload,
+  };
+}
+
+function appendHygieneEvents(cwd, hygiene, receiptPath) {
+  const { appendProductLearningEvent } = require("./product-learning-events");
+  appendProductLearningEvent(cwd, {
+    eventName: "skill_hygiene_completed",
+    category: "skills_hygiene",
+    surface: "avorelo_skills_cli",
+    status: hygiene.hygieneStatus === "clean" ? "pass" : hygiene.hygieneStatus === "action_needed" ? "warn" : "pass",
+    payload: {
+      hygieneStatus: hygiene.hygieneStatus,
+      duplicateGroups: hygiene.summary?.duplicateGroups || 0,
+      conflictGroups: hygiene.summary?.conflictGroups || 0,
+      shadowCandidates: hygiene.summary?.shadowCandidates || 0,
+      acceptedContributions: hygiene.summary?.acceptedContributions || 0,
+      contextHeavySkills: hygiene.summary?.contextHeavySkills || 0,
+      unsafeSkills: hygiene.summary?.unsafeSkills || 0,
+      topReasonCodes: (hygiene.topReasonCodes || []).slice(0, 5),
+    },
+  });
+  if ((hygiene.duplicateGroups || []).length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_duplicate_group_detected",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { count: hygiene.duplicateGroups.length },
+    });
+  }
+  if ((hygiene.shadowCandidates || []).length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_shadow_candidate_detected",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { count: hygiene.shadowCandidates.length },
+    });
+  }
+  if (hygiene.summary?.acceptedContributions > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_bounded_contribution_accepted",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "pass",
+      payload: { count: hygiene.summary.acceptedContributions },
+    });
+  }
+  if (hygiene.summary?.rejectedContributions > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_bounded_contribution_rejected",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { count: hygiene.summary.rejectedContributions },
+    });
+  }
+  if ((hygiene.conflictGroups || []).length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_conflict_detected",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { count: hygiene.conflictGroups.length },
+    });
+  }
+  if ((hygiene.contextHeavySkills || []).length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_context_heavy_detected",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { count: hygiene.contextHeavySkills.length },
+    });
+  }
+  if ((hygiene.unsafeSkills || []).length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_security_hygiene_detected",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { count: hygiene.unsafeSkills.length },
+    });
+  }
+}
+
+function appendSkillIntakeEvents(cwd, check, receiptPath) {
+  const { appendProductLearningEvent } = require("./product-learning-events");
+  appendProductLearningEvent(cwd, {
+    eventName: "skill_intake_checked",
+    category: "skills_hygiene",
+    surface: "avorelo_skills_cli",
+    status: check.decision === "allow" ? "pass" : check.decision === "block" ? "block" : "warn",
+    payload: {
+      decision: check.decision,
+      reasonCodes: (check.reasonCodes || []).slice(0, 5),
+      duplicateMatchCount: (check.duplicateMatches || []).length,
+      conflictMatchCount: (check.conflictMatches || []).length,
+    },
+  });
+  if (check.decision === "block") {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_intake_blocked",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "block",
+      payload: { reasonCodes: (check.reasonCodes || []).slice(0, 5) },
+    });
+  }
+  if (check.decision === "merge_recommended") {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_intake_merge_recommended",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "warn",
+      payload: { duplicateMatchCount: (check.duplicateMatches || []).length },
+    });
+  }
+}
+
+function appendRouteHygieneEvents(cwd, hygieneResult) {
+  const { appendProductLearningEvent } = require("./product-learning-events");
+  if (hygieneResult.suppressedDuplicateSkills?.length > 0) {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_route_deduped",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "pass",
+      payload: {
+        primarySkill: hygieneResult.primarySkill,
+        suppressedCount: hygieneResult.suppressedDuplicateSkills.length,
+        reasonCodes: (hygieneResult.reasonCodes || []).slice(0, 5),
+      },
+    });
+  }
+  if (hygieneResult.hygieneDecision === "blocked_from_auto_route") {
+    appendProductLearningEvent(cwd, {
+      eventName: "skill_route_blocked_by_hygiene",
+      category: "skills_hygiene",
+      surface: "avorelo_skills_cli",
+      status: "block",
+      payload: {
+        primarySkill: hygieneResult.primarySkill,
+        reasonCodes: (hygieneResult.reasonCodes || []).slice(0, 5),
+      },
+    });
+  }
+}
+
+function readLatestSkillHygieneReceipt(cwd) {
+  return safeReadJson(cwd, LATEST_SKILL_HYGIENE_RECEIPT_REL_PATH, null);
+}
+
+function readLatestSkillIntakeCheckReceipt(cwd) {
+  return safeReadJson(cwd, LATEST_SKILL_INTAKE_CHECK_REL_PATH, null);
+}
+
+function readLatestSourceAdoptionReceipt(cwd) {
+  return safeReadJson(cwd, LATEST_SOURCE_ADOPTION_RECEIPT_REL_PATH, null);
+}
+
+function readLatestSkillRouteReceipt(cwd) {
+  return safeReadJson(cwd, LATEST_SKILL_ROUTE_RECEIPT_REL_PATH, null);
+}
+
+function readLatestAdapterSyncReceipt(cwd) {
+  return safeReadJson(cwd, LATEST_ADAPTER_SYNC_RECEIPT_REL_PATH, null);
+}
+
+function registryForSurface(cwd) {
+  const existing = safeReadJson(cwd, GENERATED_SKILL_REGISTRY_REL_PATH, null);
+  if (existing && Array.isArray(existing.skills)) return existing;
+  return buildSkillRegistry(cwd);
+}
+
+function buildSkillsOperatingLayerSurface(cwd) {
+  const registry = registryForSurface(cwd);
+  const counts = sourceCountsFromRegistry(registry);
+  const latestSourceReceipt = readLatestSourceAdoptionReceipt(cwd);
+  const latestRouteReceipt = readLatestSkillRouteReceipt(cwd);
+  const latestAdapterReceipt = readLatestAdapterSyncReceipt(cwd);
+  const latestHygieneReceipt = readLatestSkillHygieneReceipt(cwd);
+  const latestIntakeCheckReceipt = readLatestSkillIntakeCheckReceipt(cwd);
+  const reviewedSources = counts.reviewedSourceIds.length;
+  const deferredSources = counts.deferredSourceIds.length;
+  const blockedSources = counts.blockedSourceIds.length;
+  const parsedSkills = registry.summary?.totalSkills || 0;
+  const skillsWithWarnings = registry.summary?.skillsWithWarnings || 0;
+  const capabilityBoundSkills = registry.summary?.capabilityBoundSkills || 0;
+  const status = parsedSkills > 0 ? "foundation" : "partial";
+  const nextAction = deferredSources > 0
+    ? "Review deferred sources before enabling broader source-backed routing."
+    : "Use `avorelo skills route --task \"<task>\"` to select a reviewed skill path before broad work.";
+
+  const hygieneStatus = latestHygieneReceipt?.hygieneStatus || null;
+  const hygieneSummary = latestHygieneReceipt?.summary || null;
+  const hygieneStatusLine = hygieneStatus
+    ? `Skills Hygiene: ${hygieneStatus.toUpperCase()} · deduped=${hygieneSummary?.duplicateGroups || 0} · shadow=${hygieneSummary?.shadowCandidates || 0} · contributions=${hygieneSummary?.acceptedContributions || 0} · conflicts=${hygieneSummary?.conflictGroups || 0}`
+    : null;
+  const hygieneNextAction = latestHygieneReceipt?.nextAction || null;
+
+  return {
+    status,
+    reviewedSources,
+    deferredSources,
+    blockedSources,
+    parsedSkills,
+    skillsWithWarnings,
+    capabilityBoundSkills,
+    reviewedSkillSources: reviewedSources,
+    deferredSkillSources: deferredSources,
+    blockedSkillSources: blockedSources,
+    latestSourceAdoptionReceiptPath: latestSourceReceipt ? LATEST_SOURCE_ADOPTION_RECEIPT_REL_PATH : null,
+    latestSkillRouteReceiptPath: latestRouteReceipt ? LATEST_SKILL_ROUTE_RECEIPT_REL_PATH : null,
+    latestAdapterSyncReceiptPath: latestAdapterReceipt ? LATEST_ADAPTER_SYNC_RECEIPT_REL_PATH : null,
+    latestRouteReceiptPath: latestRouteReceipt ? LATEST_SKILL_ROUTE_RECEIPT_REL_PATH : null,
+    latestAdapterReceiptPath: latestAdapterReceipt ? LATEST_ADAPTER_SYNC_RECEIPT_REL_PATH : null,
+    latestSkillHygieneReceiptPath: latestHygieneReceipt ? LATEST_SKILL_HYGIENE_RECEIPT_REL_PATH : null,
+    latestSkillIntakeCheckReceiptPath: latestIntakeCheckReceipt ? LATEST_SKILL_INTAKE_CHECK_REL_PATH : null,
+    topWarningCodes: topWarningCodes(registry),
+    hygieneStatus,
+    duplicateGroups: hygieneSummary?.duplicateGroups ?? null,
+    conflictGroups: hygieneSummary?.conflictGroups ?? null,
+    shadowCandidates: hygieneSummary?.shadowCandidates ?? null,
+    acceptedContributions: hygieneSummary?.acceptedContributions ?? null,
+    rejectedContributions: hygieneSummary?.rejectedContributions ?? null,
+    contextHeavySkills: hygieneSummary?.contextHeavySkills ?? null,
+    unsafeSkills: hygieneSummary?.unsafeSkills ?? null,
+    topHygieneReasonCodes: latestHygieneReceipt?.topReasonCodes || null,
+    hygieneNextAction,
+    nextAction,
+    showInStatus: true,
+    showInDashboard: true,
+    statusLine: `Skills / Reference Adoption: ${status.toUpperCase()} · reviewed=${reviewedSources} · deferred=${deferredSources} · blocked=${blockedSources} · parsed=${parsedSkills} · bound=${capabilityBoundSkills}`,
+    hygieneStatusLine,
+  };
+}
+
+module.exports = {
+  SKILLS_CONTRACT,
+  SKILLS_SCHEMA_VERSION,
+  LATEST_SOURCE_ADOPTION_RECEIPT_REL_PATH,
+  LATEST_SKILL_ROUTE_RECEIPT_REL_PATH,
+  LATEST_ADAPTER_SYNC_RECEIPT_REL_PATH,
+  LATEST_SKILL_HYGIENE_RECEIPT_REL_PATH,
+  LATEST_SKILL_INTAKE_CHECK_REL_PATH,
+  buildSourceAdoptionReceipt,
+  buildSkillRouteReceipt,
+  buildAdapterSyncReceipt,
+  buildSkillHygieneReceipt,
+  buildSkillIntakeCheckReceipt,
+  appendSourceAdoptionEvents,
+  appendRouteEvents,
+  appendAdapterEvents,
+  appendHygieneEvents,
+  appendSkillIntakeEvents,
+  appendRouteHygieneEvents,
+  readLatestSourceAdoptionReceipt,
+  readLatestSkillRouteReceipt,
+  readLatestAdapterSyncReceipt,
+  readLatestSkillHygieneReceipt,
+  readLatestSkillIntakeCheckReceipt,
+  buildSkillsOperatingLayerSurface,
+};