@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.5

package/src/registry/{index.ts → index.js}

@@ -5,7 +5,7 @@
 // Registry loader and validator.  Registry files are plain JSON (core/registry/*.json).
 const fs = require('node:fs');
 const path = require('node:path');
-const { validatePathsSection } = require('../helper/harness-paths.ts');
+const { validatePathsSection } = require('../helper/harness-paths.js');
 
 const REGISTRY_FILES = Object.freeze({
   harnesses: 'harnesses.json',
@@ -42,9 +42,9 @@ const MCP_NAME = /^[A-Za-z0-9_.-]+$/;
  * artifact that can lag the source (`index`). Required on every provider (068). */
 const PROVIDER_SOURCE_MODES = Object.freeze(['live', 'index']);
 
-function issue(errors: string[], location: string, message: string): void { errors.push(`${location}: ${message}`); }
-function object(value: any): boolean { return value !== null && typeof value === 'object' && !Array.isArray(value); }
-function idsUnique(items: any, label: string, errors: string[]): void {
+function issue(errors          , location        , message        )       { errors.push(`${location}: ${message}`); }
+function object(value     )          { return value !== null && typeof value === 'object' && !Array.isArray(value); }
+function idsUnique(items     , label        , errors          )       {
   const seen = new Set();
   for (const item of items || []) {
     if (!object(item) || typeof item.id !== 'string' || !item.id) continue;
@@ -53,22 +53,22 @@ function idsUnique(items: any, label: string, errors: string[]): void {
   }
 }
 
-function parseRegistryFile(file: string, fsImpl: any = fs): any {
+function parseRegistryFile(file        , fsImpl      = fs)      {
   let text;
-  try { text = fsImpl.readFileSync(file, 'utf8'); } catch (error: any) {
+  try { text = fsImpl.readFileSync(file, 'utf8'); } catch (error     ) {
     throw new Error(`Could not read registry file '${file}': ${error.message}`);
   }
-  try { return JSON.parse(text); } catch (error: any) {
+  try { return JSON.parse(text); } catch (error     ) {
     throw new Error(`Registry file '${file}' is not valid JSON: ${error.message}`);
   }
 }
 
-function registryDir(repoRoot: string): string { return path.join(path.resolve(repoRoot), 'core', 'registry'); }
+function registryDir(repoRoot        )         { return path.join(path.resolve(repoRoot), 'core', 'registry'); }
 
-function loadRegistry({ repoRoot, dir, fsImpl = fs }: { repoRoot?: string, dir?: string, fsImpl?: any } = {}): any {
+function loadRegistry({ repoRoot, dir, fsImpl = fs }                                                    = {})      {
   if (!repoRoot && !dir) throw new Error('loadRegistry requires repoRoot or dir');
-  const base = dir ? path.resolve(dir) : registryDir(repoRoot as string);
-  const loaded: any = {};
+  const base = dir ? path.resolve(dir) : registryDir(repoRoot          );
+  const loaded      = {};
   for (const [name, fileName] of Object.entries(REGISTRY_FILES)) {
     loaded[name] = parseRegistryFile(path.join(base, fileName), fsImpl);
   }
@@ -83,6 +83,7 @@ function loadRegistry({ repoRoot, dir, fsImpl = fs }: { repoRoot?: string, dir?:
     assets: loaded.assets.assets,
     mcp: loaded.mcp.servers,
     lifecycle: loaded.lifecycle.policies,
+    coverage: loaded.lifecycle.coverage ?? null,
     contracts: loaded.contracts.contracts,
     externalTools: loaded.externalTools.tools,
     modelProviders: loaded.models.providers,
@@ -90,11 +91,11 @@ function loadRegistry({ repoRoot, dir, fsImpl = fs }: { repoRoot?: string, dir?:
     retrievalSlots: Array.isArray(loaded.models.slots) ? loaded.models.slots : [],
     dispatchTiers: loaded.models.dispatchTiers,
     capabilities,
-    versions: Object.fromEntries((Object.entries(loaded) as [string, any][]).map(([name, value]) => [name, value.version])),
+    versions: Object.fromEntries((Object.entries(loaded)                   ).map(([name, value]) => [name, value.version])),
   };
   const validation = validateRegistry(registry, { repoRoot: registry.repoRoot, fsImpl });
   if (!validation.ok) {
-    const error: any = new Error(`Invalid DoFlow registry:\n- ${validation.errors.join('\n- ')}`);
+    const error      = new Error(`Invalid DoFlow registry:\n- ${validation.errors.join('\n- ')}`);
     error.validation = validation;
     throw error;
   }
@@ -109,7 +110,7 @@ const CONTRACT_COMPLETENESS = new Set(['verified', 'lower-bound']);
  *
  * `evidence` is required for the same reason capabilities require it: a contract claim with no
  * citation is folklore, and these lists are copied from vendor documentation that moves. */
-function validateContract(value: any, location: string, errors: string[], harnessIds: any): void {
+function validateContract(value     , location        , errors          , harnessIds     )       {
   if (!object(value)) { issue(errors, location, 'must be an object'); return; }
   if (typeof value.harness !== 'string' || !harnessIds.has(value.harness)) {
     issue(errors, location, `harness must be one of: ${[...harnessIds].join(', ')}`);
@@ -132,11 +133,10 @@ function validateContract(value: any, location: string, errors: string[], harnes
     if (new Set(list).size !== list.length) issue(errors, `${location}.${field}`, 'must not contain duplicates');
   }
   // An empty hookEvents used to be rejected outright, which assumed every harness wires at least one
-  // hook. OpenCode and Pi break that: both implement lifecycle handlers as JS/TS code modules, so
-  // DoFlow's shell hooks have nothing to attach to and it wires none. Forcing a non-empty list there
-  // would mean declaring a hook DoFlow does not install — an inert claim of exactly the kind these
-  // guards exist to remove. Empty is therefore allowed, but only with a note, so the distinction
-  // between "wires nothing, deliberately" and "nobody filled this in" stays visible.
+  // hook. OpenCode has no DoFlow hook projection; Pi uses a code extension only for tool_call.
+  // Forcing a non-empty list for an unsupported event would declare a hook DoFlow does not install —
+  // an inert claim of exactly the kind these guards exist to remove. Empty is therefore allowed, but
+  // only with a note, so deliberate gaps stay distinct from missing registry data.
   const events = value.hookEvents;
   const noted = typeof value.note === 'string' && value.note.trim().length > 0;
   if (!Array.isArray(events) || events.some((item) => typeof item !== 'string' || !item)) {
@@ -147,28 +147,28 @@ function validateContract(value: any, location: string, errors: string[], harnes
     issue(errors, `${location}.hookEvents`, 'must not contain duplicates');
   }
   if (!Array.isArray(value.evidence) || value.evidence.length === 0
-    || value.evidence.some((url: any) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
+    || value.evidence.some((url     ) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
     issue(errors, location, 'must include one or more HTTPS evidence URLs');
   }
 }
 
 /** A harness MCP tool-name template: contains {server} and {tool}, and no other brace text. */
-function validToolNameTemplate(value: any): boolean {
+function validToolNameTemplate(value     )          {
   return typeof value === 'string' && value.includes('{server}') && value.includes('{tool}')
     && !value.replace(/\{server\}|\{tool\}/g, '').match(/[{}]/);
 }
 
-function validateCapability(value: any, location: string, errors: string[]): void {
+function validateCapability(value     , location        , errors          )       {
   if (!object(value)) { issue(errors, location, 'must be an object'); return; }
   if (!CAPABILITY_STATUS.has(value.status)) issue(errors, location, 'status must be supported, different, or unavailable');
-  if (!Array.isArray(value.evidence) || value.evidence.length === 0 || value.evidence.some((url: any) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
+  if (!Array.isArray(value.evidence) || value.evidence.length === 0 || value.evidence.some((url     ) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
     issue(errors, location, 'must include one or more HTTPS evidence URLs');
   }
   if (typeof value.verification !== 'string' || !value.verification.trim()) issue(errors, location, 'requires a verification instruction');
   if (value.toolName !== undefined && !validToolNameTemplate(value.toolName)) {
     issue(errors, location, 'toolName must be a string with exactly the placeholders {server} and {tool} and no other braces');
   }
-  if (value.prerequisites !== undefined && (!Array.isArray(value.prerequisites) || value.prerequisites.some((item: any) => typeof item !== 'string' || !item))) {
+  if (value.prerequisites !== undefined && (!Array.isArray(value.prerequisites) || value.prerequisites.some((item     ) => typeof item !== 'string' || !item))) {
     issue(errors, location, 'prerequisites must be an array of non-empty strings');
   }
   // Optional per-event detail, reusing the same three-value status vocabulary. Additive on
@@ -178,7 +178,7 @@ function validateCapability(value: any, location: string, errors: string[]): voi
     if (!object(value.events) || Object.keys(value.events).length === 0) {
       issue(errors, `${location}.events`, 'must be a non-empty object when present');
     } else {
-      for (const [event, detail] of Object.entries(value.events) as [string, any][]) {
+      for (const [event, detail] of Object.entries(value.events)                   ) {
         if (!/^[A-Z][A-Za-z]*$/.test(event)) issue(errors, `${location}.events`, `invalid event name '${event}'`);
         if (!object(detail) || !CAPABILITY_STATUS.has(detail.status)) {
           issue(errors, `${location}.events.${event}`, 'status must be supported, different, or unavailable');
@@ -191,7 +191,7 @@ function validateCapability(value: any, location: string, errors: string[]): voi
   }
 }
 
-function validateSource(repoRoot: any, source: any, location: string, errors: string[], fsImpl: any, expected: string = 'any'): void {
+function validateSource(repoRoot     , source     , location        , errors          , fsImpl     , expected         = 'any')       {
   if (typeof source !== 'string' || !source.trim()) { issue(errors, location, 'requires a repository-relative source'); return; }
   const root = path.resolve(repoRoot);
   const resolved = path.resolve(root, source);
@@ -200,7 +200,7 @@ function validateSource(repoRoot: any, source: any, location: string, errors: st
   if (expected === 'directory' && !fsImpl.statSync(resolved).isDirectory()) issue(errors, location, `source must be a directory: ${source}`);
 }
 
-function validateNativeProjection(projection: any, harness: any, { repoRoot, fsImpl }: { repoRoot: any, fsImpl: any }, errors: string[]): void {
+function validateNativeProjection(projection     , harness     , { repoRoot, fsImpl }                                , errors          )       {
   const at = `harness '${harness.id}' nativeProjection`;
   if (!object(projection)) { issue(errors, at, 'must be an object'); return; }
   const config = projection.config;
@@ -228,14 +228,14 @@ function validateNativeProjection(projection: any, harness: any, { repoRoot, fsI
   }
 }
 
-function validateCommand(command: any, location: string, errors: string[]): void {
+function validateCommand(command     , location        , errors          )       {
   if (!Array.isArray(command) || command.length === 0
     || command.some((argument) => typeof argument !== 'string' || !argument.trim())) {
     issue(errors, location, 'command must be a non-empty array of non-empty strings');
   }
 }
 
-function validateExternalTool(value: any, location: string, errors: string[]): void {
+function validateExternalTool(value     , location        , errors          )       {
   if (!object(value)) { issue(errors, location, 'must be an object'); return; }
   const allowed = new Set(['id', 'displayName', 'officialEvidence', 'status', 'install', 'update', 'uninstall', 'prerequisites']);
   for (const key of Object.keys(value)) {
@@ -246,11 +246,11 @@ function validateExternalTool(value: any, location: string, errors: string[]): v
   }
   if (typeof value.displayName !== 'string' || !value.displayName.trim()) issue(errors, location, 'requires displayName');
   if (!Array.isArray(value.officialEvidence) || value.officialEvidence.length === 0
-    || value.officialEvidence.some((url: any) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
+    || value.officialEvidence.some((url     ) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
     issue(errors, location, 'must include one or more HTTPS officialEvidence URLs');
   }
   if (value.prerequisites !== undefined && (!Array.isArray(value.prerequisites)
-    || value.prerequisites.some((item: any) => typeof item !== 'string' || !item.trim())
+    || value.prerequisites.some((item     ) => typeof item !== 'string' || !item.trim())
     || new Set(value.prerequisites).size !== value.prerequisites.length)) {
     issue(errors, location, 'prerequisites must be an array of unique non-empty strings when present');
   }
@@ -261,7 +261,7 @@ function validateExternalTool(value: any, location: string, errors: string[]): v
     for (const key of Object.keys(value.status)) {
       if (!allowedStatus.has(key)) issue(errors, `${location}.status`, `unsupported field '${key}'`);
     }
-    value.status.commands.forEach((command: any, index: number) => validateCommand(command, `${location}.status.commands[${index}]`, errors));
+    value.status.commands.forEach((command     , index        ) => validateCommand(command, `${location}.status.commands[${index}]`, errors));
   }
   for (const action of EXTERNAL_TOOL_ACTIONS) {
     if (value[action] === undefined) continue;
@@ -277,18 +277,18 @@ function validateExternalTool(value: any, location: string, errors: string[]): v
  * router will consume. Shell scope: providers are declared with identity, kind, and
  * evidence (a capability claim without a citation is folklore); roles name routing preferences
  * without binding to concrete model IDs, which stay runtime/user choices resolved at run time. */
-function validateModelProvider(value: any, location: string, errors: string[]): void {
+function validateModelProvider(value     , location        , errors          )       {
   if (!object(value)) { issue(errors, location, 'must be an object'); return; }
   if (typeof value.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(value.id)) issue(errors, location, 'id must be a lowercase identifier');
   if (typeof value.displayName !== 'string' || !value.displayName.trim()) issue(errors, location, 'requires displayName');
   if (!MODEL_KINDS.has(value.kind)) issue(errors, location, `kind must be one of: ${[...MODEL_KINDS].join(', ')}`);
   if (!Array.isArray(value.evidence) || value.evidence.length === 0
-    || value.evidence.some((url: any) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
+    || value.evidence.some((url     ) => typeof url !== 'string' || !/^https:\/\//.test(url))) {
     issue(errors, location, 'must include one or more HTTPS evidence URLs');
   }
 }
 
-function validateModelRole(value: any, location: string, errors: string[]): void {
+function validateModelRole(value     , location        , errors          )       {
   if (!object(value)) { issue(errors, location, 'must be an object'); return; }
   if (typeof value.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(value.id)) issue(errors, location, 'id must be a lowercase identifier');
   for (const field of ['prefer', 'fallback', 'require']) {
@@ -304,7 +304,7 @@ function validateModelRole(value: any, location: string, errors: string[]): void
  * must fail the load loudly, because a typo reading as "no dense provider" would silently skip
  * the feature instead of surfacing it. `enabled` is therefore required rather than defaulted:
  * a misspelled flag defaulting to off is the same PASS-over-no-evidence defect in miniature. */
-function validateModelSlot(value: any, location: string, errors: string[], providerIds: any): void {
+function validateModelSlot(value     , location        , errors          , providerIds     )       {
   if (!object(value)) { issue(errors, location, 'must be an object'); return; }
   const allowed = new Set(['id', 'provider', 'model', 'enabled', 'evidence']);
   for (const key of Object.keys(value)) {
@@ -316,20 +316,20 @@ function validateModelSlot(value: any, location: string, errors: string[], provi
   if (typeof value.model !== 'string' || !value.model.trim()) issue(errors, location, 'requires model');
   if (typeof value.enabled !== 'boolean') issue(errors, location, 'enabled must be a boolean');
   if (value.evidence !== undefined && (!Array.isArray(value.evidence) || value.evidence.length === 0
-    || value.evidence.some((url: any) => typeof url !== 'string' || !/^https:\/\//.test(url)))) {
+    || value.evidence.some((url     ) => typeof url !== 'string' || !/^https:\/\//.test(url)))) {
     issue(errors, location, 'must include one or more HTTPS evidence URLs when evidence is present');
   }
 }
 
 /** `trigger` and `steps` on an MCP server (062): when a stage should reach for the server, and
  * which skill files name it. Registry-only; adapters pick fields and never render these keys. */
-function validateMcpStageUse(server: any, at: string, errors: string[]): void {
+function validateMcpStageUse(server     , at        , errors          )       {
   if (typeof server.trigger !== 'string' || server.trigger.length < 20 || server.trigger.length > 300 || /[\r\n]/.test(server.trigger)) {
     issue(errors, at, 'trigger must be one line of 20 to 300 characters');
   }
   if (!Array.isArray(server.steps)) { issue(errors, at, 'steps must be an array'); return; }
   const seen = new Set();
-  server.steps.forEach((step: any, index: number) => {
+  server.steps.forEach((step     , index        ) => {
     const where = `steps[${index}]`;
     if (!object(step)) { issue(errors, at, `${where} must be an object`); return; }
     for (const key of Object.keys(step)) if (!MCP_STEP_KEYS.has(key)) issue(errors, at, `${where} has unknown key '${key}'`);
@@ -345,10 +345,10 @@ function validateMcpStageUse(server: any, at: string, errors: string[]): void {
 }
 
 /** Provider checks for capabilities.json: required `sourceMode` (068) and optional `mcp: {server, tool}` (062). */
-function validateCapabilityProviders(capabilities: any, errors: string[]): void {
+function validateCapabilityProviders(capabilities     , errors          )       {
   if (capabilities === undefined) return;
   if (!object(capabilities)) { issue(errors, 'capabilities', 'must be an object'); return; }
-  for (const [capabilityId, capability] of Object.entries(capabilities) as [string, any][]) {
+  for (const [capabilityId, capability] of Object.entries(capabilities)                   ) {
     for (const provider of object(capability) && Array.isArray(capability.providers) ? capability.providers : []) {
       if (!object(provider)) continue;
       const at = `capability '${capabilityId}' provider '${provider.id ?? '?'}'`;
@@ -365,11 +365,11 @@ function validateCapabilityProviders(capabilities: any, errors: string[]): void
 }
 
 /** `dispatchTiers` in models.json (062): the tier vocabulary and the per-owner default a brief names. */
-function validateDispatchTiers(value: any, errors: string[]): void {
+function validateDispatchTiers(value     , errors          )       {
   if (value === undefined) return;
   const at = 'models.dispatchTiers';
   if (!object(value)) { issue(errors, at, 'must be an object'); return; }
-  const tiers = Array.isArray(value.tiers) && value.tiers.length > 0 && value.tiers.every((tier: any) => typeof tier === 'string' && tier) ? value.tiers : null;
+  const tiers = Array.isArray(value.tiers) && value.tiers.length > 0 && value.tiers.every((tier     ) => typeof tier === 'string' && tier) ? value.tiers : null;
   if (!tiers) { issue(errors, at, 'tiers must be a non-empty array of strings'); return; }
   if (new Set(tiers).size !== tiers.length) issue(errors, at, 'tiers must be unique');
   if (!tiers.includes(value.default)) issue(errors, at, `default must be one of: ${tiers.join(', ')}`);
@@ -382,7 +382,7 @@ function validateDispatchTiers(value: any, errors: string[]): void {
 /** Validates one harness's `orchestration` block (074 IC-026): the five subagent primitives a
  * harness exposes (spawn, wait, status, cancel, resume), each with evidence and a re-check
  * instruction. It reads no other harness and no model name; a value is declared, never inferred. */
-function validateOrchestration(value: any, location: string, errors: string[]): void {
+function validateOrchestration(value     , location        , errors          )       {
   if (!object(value)) { issue(errors, location, 'orchestration block is required and must be an object'); return; }
   for (const op of ORCHESTRATION_OPS) {
     if (!Object.hasOwn(value, op)) issue(errors, location, `orchestration is missing operation '${op}'`);
@@ -396,7 +396,7 @@ function validateOrchestration(value: any, location: string, errors: string[]):
     const entry = value[op];
     if (!object(entry)) { issue(errors, at, 'must be an object'); continue; }
     if (!ORCHESTRATION_STATUS.has(entry.status)) issue(errors, at, 'status must be supported, unsupported, or unknown');
-    if (!Array.isArray(entry.evidence) || entry.evidence.some((item: any) => typeof item !== 'string')) {
+    if (!Array.isArray(entry.evidence) || entry.evidence.some((item     ) => typeof item !== 'string')) {
       issue(errors, at, 'evidence must be an array of strings');
     } else if (entry.evidence.length === 0 && (entry.status === 'supported' || entry.status === 'unsupported')) {
       issue(errors, at, `evidence must not be empty when status is ${entry.status}`);
@@ -412,8 +412,96 @@ function validateOrchestration(value: any, location: string, errors: string[]):
   }
 }
 
-function validateRegistry(registry: any, { repoRoot, fsImpl = fs }: { repoRoot?: string, fsImpl?: any } = {}): { ok: boolean, errors: string[] } {
-  const errors: string[] = [];
+const CONTEXT_PROFILE_FIELDS = Object.freeze([
+  'capacityTokens',
+  'reserveTokens',
+  'tokenTelemetry',
+  'toolResultLimitBytes',
+  'retention',
+]);
+
+/** Validates one harness's `contextProfile` block (075 IC-013): capacity, reserve, telemetry,
+ * toolResultLimitBytes and retention. Each is a Fact<T> with {value, source, verifiedOn} or
+ * {unverified, verifiedOn}. */
+function validateContextProfile(value     , location        , errors          )       {
+  if (!object(value)) {
+    issue(errors, location, 'contextProfile block is required and must be an object');
+    return;
+  }
+  for (const field of CONTEXT_PROFILE_FIELDS) {
+    if (!Object.hasOwn(value, field)) {
+      issue(errors, location, `contextProfile is missing field '${field}'`);
+    }
+  }
+  for (const key of Object.keys(value)) {
+    if (!CONTEXT_PROFILE_FIELDS.includes(key)) {
+      issue(errors, location, `contextProfile has unknown key '${key}'`);
+    }
+  }
+  for (const field of CONTEXT_PROFILE_FIELDS) {
+    if (!Object.hasOwn(value, field)) continue;
+    const at = `${location} contextProfile '${field}'`;
+    const fact = value[field];
+    if (!object(fact)) {
+      issue(errors, at, 'must be a Fact object');
+      continue;
+    }
+    const hasUnverified = Object.hasOwn(fact, 'unverified');
+    const hasValue = Object.hasOwn(fact, 'value');
+
+    if (hasUnverified) {
+      if (typeof fact.unverified !== 'string' || !fact.unverified.trim()) {
+        issue(errors, at, 'unverified must be a non-empty string');
+      }
+      if (hasValue) {
+        issue(errors, at, 'cannot declare both value and unverified');
+      }
+    } else if (hasValue) {
+      if (typeof fact.source !== 'string' || !fact.source.trim()) {
+        issue(errors, at, 'a declared value requires a non-empty source');
+      }
+    } else {
+      issue(errors, at, 'requires either value with source or a non-empty unverified');
+    }
+
+    if (
+      typeof fact.verifiedOn !== 'string' ||
+      !/^\d{4}-\d{2}-\d{2}$/.test(fact.verifiedOn) ||
+      Number.isNaN(Date.parse(fact.verifiedOn)) ||
+      new Date(fact.verifiedOn).toISOString().slice(0, 10) !== fact.verifiedOn
+    ) {
+      issue(errors, at, 'requires verifiedOn as an ISO date (YYYY-MM-DD)');
+    }
+
+    if (hasValue && fact.value !== undefined) {
+      const val = fact.value;
+      if (field === 'capacityTokens') {
+        if (typeof val !== 'number' || !Number.isInteger(val) || val <= 0) {
+          issue(errors, at, 'value must be a positive integer');
+        }
+      } else if (field === 'reserveTokens') {
+        if (typeof val !== 'number' || !Number.isInteger(val) || val < 0) {
+          issue(errors, at, 'value must be a non-negative integer');
+        }
+      } else if (field === 'tokenTelemetry') {
+        if (val !== 'harness-reported' && val !== 'none') {
+          issue(errors, at, "value must be 'harness-reported' or 'none'");
+        }
+      } else if (field === 'toolResultLimitBytes') {
+        if (typeof val !== 'number' || !Number.isInteger(val) || val <= 0) {
+          issue(errors, at, 'value must be a positive integer');
+        }
+      } else if (field === 'retention') {
+        if (val !== 'supported' && val !== 'unsupported') {
+          issue(errors, at, "value must be 'supported' or 'unsupported'");
+        }
+      }
+    }
+  }
+}
+
+function validateRegistry(registry     , { repoRoot, fsImpl = fs }                                      = {})                                    {
+  const errors           = [];
   const harnesses = Array.isArray(registry?.harnesses) ? registry.harnesses : null;
   const assets = Array.isArray(registry?.assets) ? registry.assets : null;
   const mcp = Array.isArray(registry?.mcp) ? registry.mcp : null;
@@ -430,14 +518,14 @@ function validateRegistry(registry: any, { repoRoot, fsImpl = fs }: { repoRoot?:
   idsUnique(mcp, 'mcp', errors); idsUnique(lifecycle, 'lifecycle', errors);
   idsUnique(externalTools, 'externalTools', errors);
 
-  const harnessIds = new Set((harnesses || []).filter(object).map((item: any) => item.id));
+  const harnessIds = new Set        ((harnesses || []).filter(object).map((item     ) => item.id          ));
   for (const harness of harnesses || []) {
     const at = `harness '${harness?.id ?? '?'}'`;
     if (!object(harness)) { issue(errors, 'harnesses', 'entries must be objects'); continue; }
     if (typeof harness.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(harness.id)) issue(errors, at, 'id must be a lowercase identifier');
     if (typeof harness.displayName !== 'string' || !harness.displayName.trim()) issue(errors, at, 'requires displayName');
     if (typeof harness.adapter !== 'string' || !harness.adapter.trim()) issue(errors, at, 'requires adapter');
-    if (!Array.isArray(harness.scopes) || harness.scopes.length === 0 || harness.scopes.some((scope: any) => !SCOPES.has(scope))) issue(errors, at, 'scopes must contain project and/or user');
+    if (!Array.isArray(harness.scopes) || harness.scopes.length === 0 || harness.scopes.some((scope     ) => !SCOPES.has(scope))) issue(errors, at, 'scopes must contain project and/or user');
     if (!object(harness.nativeTargets)) issue(errors, at, 'nativeTargets must be an object');
     // Declared native paths (Stage 3): every surface a harness declares must parse into the
     // minimal {base, segments} shape — unknown keys or malformed rules fail the load loudly so a
@@ -451,6 +539,7 @@ function validateRegistry(registry: any, { repoRoot, fsImpl = fs }: { repoRoot?:
       validateCapability(declaration, `${at} capability '${capability}'`, errors);
     }
     validateOrchestration(harness.orchestration, at, errors);
+    validateContextProfile(harness.contextProfile, at, errors);
     if (harness.id === 'codex') validateNativeProjection(harness.nativeProjection, harness, { repoRoot, fsImpl }, errors);
   }
 
@@ -484,7 +573,7 @@ function validateRegistry(registry: any, { repoRoot, fsImpl = fs }: { repoRoot?:
       if (!object(projection) || typeof projection.renderer !== 'string' || !projection.renderer.trim() || typeof projection.capability !== 'string' || !projection.capability.trim()) {
         issue(errors, at, `requires renderer and capability projection for '${harnessId}'`); continue;
       }
-      const harness = (harnesses || []).find((item: any) => item?.id === harnessId);
+      const harness = (harnesses || []).find((item     ) => item?.id === harnessId);
       const capability = harness?.capabilities?.[projection.capability];
       if (!capability) issue(errors, at, `projection '${harnessId}' references unknown capability '${projection.capability}'`);
       else if (capability.status === 'unavailable') issue(errors, at, `projection '${harnessId}' cannot render unavailable capability '${projection.capability}'`);
@@ -497,7 +586,7 @@ function validateRegistry(registry: any, { repoRoot, fsImpl = fs }: { repoRoot?:
     if (typeof server.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(server.id)) issue(errors, at, 'id must be a lowercase identifier');
     if (!MCP_TRANSPORTS.has(server.transport)) issue(errors, at, 'transport must be stdio, http, or sse');
     if (server.transport === 'stdio' && (typeof server.command !== 'string' || !server.command.trim())) issue(errors, at, 'stdio transport requires command');
-    if (server.args !== undefined && (!Array.isArray(server.args) || server.args.some((arg: any) => typeof arg !== 'string'))) issue(errors, at, 'args must be an array of strings');
+    if (server.args !== undefined && (!Array.isArray(server.args) || server.args.some((arg     ) => typeof arg !== 'string'))) issue(errors, at, 'args must be an array of strings');
     if (!['optional', 'required'].includes(server.selection)) issue(errors, at, 'selection must be optional or required');
     validateMcpStageUse(server, at, errors);
   }
@@ -511,15 +600,17 @@ function validateRegistry(registry: any, { repoRoot, fsImpl = fs }: { repoRoot?:
     if (typeof policy.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(policy.id)) issue(errors, at, 'id must be a lowercase identifier');
     if (typeof policy.intent !== 'string' || !policy.intent.trim()) issue(errors, at, 'requires intent');
     if (policy.tier !== undefined && !POLICY_TIERS.has(policy.tier)) issue(errors, at, `tier must be one of ${[...POLICY_TIERS].join(', ')}`);
-    if (!Array.isArray(policy.requires) || policy.requires.some((capability: any) => typeof capability !== 'string')) issue(errors, at, 'requires must be an array of capability names');
+    if (!Array.isArray(policy.requires) || policy.requires.some((capability     ) => typeof capability !== 'string')) issue(errors, at, 'requires must be an array of capability names');
     if (!object(policy.mappings)) { issue(errors, at, 'mappings must be an object'); continue; }
-    for (const [harnessId, mapping] of Object.entries(policy.mappings) as [string, any][]) {
+    for (const [harnessId, mapping] of Object.entries(policy.mappings)                   ) {
       if (!harnessIds.has(harnessId)) { issue(errors, at, `mapping references unknown harness '${harnessId}'`); continue; }
       if (!object(mapping) || !CAPABILITY_STATUS.has(mapping.status)) { issue(errors, at, `mapping '${harnessId}' needs a valid status`); continue; }
       if (mapping.status !== 'unavailable' && (typeof mapping.event !== 'string' || !mapping.event.trim())) issue(errors, at, `mapping '${harnessId}' requires event for a renderable status`);
       if (mapping.status === 'unavailable' && typeof mapping.fallback !== 'string') issue(errors, at, `unavailable mapping '${harnessId}' requires fallback guidance`);
     }
   }
+
+  validateCoverage(registry?.coverage, registry?.lifecycle, harnessIds, errors);
   for (const tool of externalTools || []) validateExternalTool(tool, `external tool '${tool?.id ?? '?'}'`, errors);
 
   const modelProviders = Array.isArray(registry?.modelProviders) ? registry.modelProviders : null;
@@ -539,21 +630,59 @@ function validateRegistry(registry: any, { repoRoot, fsImpl = fs }: { repoRoot?:
     issue(errors, 'models.slots', 'must be an array when present');
   } else {
     idsUnique(modelSlots, 'models.slots', errors);
-    const providerIds = new Set((modelProviders || []).filter(object).map((item: any) => item.id));
+    const providerIds = new Set((modelProviders || []).filter(object).map((item     ) => item.id));
     for (const slot of modelSlots) validateModelSlot(slot, `model slot '${slot?.id ?? '?'}'`, errors, providerIds);
   }
   return { ok: errors.length === 0, errors };
 }
 
-function harnessFor(registry: any, id: string): any {
-  const harness = registry.harnesses.find((item: any) => item.id === id);
+const COVERAGE_CLASSES = new Set(['blocking', 'observation', 'advisory', 'unsupported', 'unknown']);
+const COVERAGE_TIMINGS = new Set(['pre-tool', 'post-tool', 'session', 'prompt', 'stop', 'compact', 'subagent']);
+const COVERAGE_PROFILES = new Set(['any', 'user-interactive', 'user-headless', 'project-interactive', 'project-headless', 'cli-extension', 'no-extensions', 'ide', 'cli-v3', 'cli-v3-agent', 'cli-2x-agent']);
+const COVERAGE_KINDS = new Set(['doc', 'types', 'fixture', 'live']);
+
+function validateCoverage(value     , lifecycle       , harnessIds             , errors          )       {
+  if (value === undefined || value === null) return;
+  const at = 'lifecycle.coverage';
+  if (!object(value)) { issue(errors, at, 'must be an object'); return; }
+  if (value.schemaVersion !== 1) issue(errors, `${at}.schemaVersion`, 'must be 1');
+  if (!Number.isInteger(value.revision) || value.revision < 1) issue(errors, `${at}.revision`, 'must be a positive integer');
+  if (typeof value.rowsDigest !== 'string' || !/^sha256:[a-f0-9]{64}$/.test(value.rowsDigest)) issue(errors, `${at}.rowsDigest`, 'must be sha256 followed by 64 lowercase hex characters');
+  if (!object(value.refresh) || typeof value.refresh.trigger !== 'string' || !value.refresh.trigger.trim() || typeof value.refresh.owner !== 'string' || !value.refresh.owner.trim()) issue(errors, `${at}.refresh`, 'requires non-empty trigger and owner');
+  if (!object(value.profiles) || [...COVERAGE_PROFILES].some((profile) => typeof value.profiles?.[profile] !== 'string' || !value.profiles[profile].trim())) issue(errors, `${at}.profiles`, 'must define every supported profile with a non-empty meaning');
+  if (!Array.isArray(value.rows)) { issue(errors, `${at}.rows`, 'must be an array'); return; }
+  const keys = new Set        ();
+  for (const [index, row] of value.rows.entries()) {
+    const rowAt = `${at}.rows[${index}]`;
+    if (!object(row)) { issue(errors, rowAt, 'must be an object'); continue; }
+    for (const field of ['policy', 'harness', 'event']) if (typeof row[field] !== 'string' || !row[field]) issue(errors, `${rowAt}.${field}`, 'must be a non-empty string');
+    if (row.policy !== '*' && !(lifecycle || []).some((policy     ) => policy.id === row.policy)) issue(errors, `${rowAt}.policy`, 'must name a lifecycle policy or *');
+    if (!harnessIds.has(row.harness)) issue(errors, `${rowAt}.harness`, 'must name a registry harness');
+    if (!COVERAGE_TIMINGS.has(row.timing)) issue(errors, `${rowAt}.timing`, 'has an invalid timing');
+    if (!COVERAGE_PROFILES.has(row.profile)) issue(errors, `${rowAt}.profile`, 'has an invalid profile');
+    if (typeof row.wired !== 'boolean') issue(errors, `${rowAt}.wired`, 'must be a boolean');
+    if (row.configSource !== null && (typeof row.configSource !== 'string' || !row.configSource)) issue(errors, `${rowAt}.configSource`, 'must be a path:line or null');
+    if (row.wired && typeof row.configSource !== 'string') issue(errors, `${rowAt}.configSource`, 'is required when wired');
+    if (!object(row.harnessVersion) || typeof row.harnessVersion.tested !== 'string' || !row.harnessVersion.tested || (row.harnessVersion.range !== undefined && typeof row.harnessVersion.range !== 'string')) issue(errors, `${rowAt}.harnessVersion`, 'requires tested and optional range strings');
+    if (!COVERAGE_CLASSES.has(row.class)) issue(errors, `${rowAt}.class`, 'has an invalid class');
+    if (!['verified', 'unverified'].includes(row.verification)) issue(errors, `${rowAt}.verification`, 'must be verified or unverified');
+    for (const field of ['prerequisites', 'covers', 'doesNotCover', 'caveats']) if (!Array.isArray(row[field]) || row[field].some((item     ) => typeof item !== 'string')) issue(errors, `${rowAt}.${field}`, 'must be an array of strings');
+    if (!Array.isArray(row.provenance) || row.provenance.some((item     ) => !object(item) || !COVERAGE_KINDS.has(item.kind) || typeof item.locator !== 'string' || !item.locator || (['doc', 'types', 'live'].includes(item.kind) && (typeof item.date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(item.date))))) issue(errors, `${rowAt}.provenance`, 'contains malformed provenance');
+    const key = JSON.stringify([row.policy, row.harness, row.event, row.profile]);
+    if (keys.has(key)) issue(errors, rowAt, 'duplicates a policy/harness/event/profile tuple');
+    keys.add(key);
+  }
+}
+
+function harnessFor(registry     , id        )      {
+  const harness = registry.harnesses.find((item     ) => item.id === id);
   if (!harness) throw new Error(`Unknown registry harness '${id}'`);
   return harness;
 }
 
-function selectAssets(registry: any, { harness, capability, kind }: { harness?: string, capability?: string, kind?: string } = {}): any[] {
+function selectAssets(registry     , { harness, capability, kind }                                                           = {})        {
   const declaration = harness ? harnessFor(registry, harness) : null;
-  return registry.assets.filter((asset: any) => {
+  return registry.assets.filter((asset     ) => {
     if (kind && asset.kind !== kind) return false;
     if (!harness) return true;
     if (!asset.appliesTo.includes(harness)) return false;
@@ -562,18 +691,18 @@ function selectAssets(registry: any, { harness, capability, kind }: { harness?:
   });
 }
 
-function selectMcpServers(registry: any, ids?: string[] | null): any[] {
+function selectMcpServers(registry     , ids                  )        {
   if (ids === undefined || ids === null) return [...registry.mcp];
   if (!Array.isArray(ids)) throw new Error('MCP selection must be an array of server ids');
   const wanted = new Set(ids);
-  const unknown = [...wanted].filter((id) => !registry.mcp.some((server: any) => server.id === id));
+  const unknown = [...wanted].filter((id) => !registry.mcp.some((server     ) => server.id === id));
   if (unknown.length) throw new Error(`Unknown registry MCP server(s): ${unknown.join(', ')}`);
-  return registry.mcp.filter((server: any) => wanted.has(server.id));
+  return registry.mcp.filter((server     ) => wanted.has(server.id));
 }
 
 /** True when the harness takes servers from the shared MCP catalog; the lifecycle and the selection
  * resolver read this one predicate. */
-function mcpCapable(registry: any, harnessId: string): boolean {
+function mcpCapable(registry     , harnessId        )          {
   return harnessFor(registry, harnessId).capabilities.mcp?.status === 'supported';
 }
 
@@ -581,7 +710,7 @@ function mcpCapable(registry: any, harnessId: string): boolean {
  * harness's native MCP reconciliation (Codex's config.toml writer, Claude's ~/.claude.json/
  * .mcp.json writer) expects — the one place this transform is derived, reused rather than
  * re-implemented per consumer. */
-function nativeMcpCatalog(servers: any[] = []): { allServers: string[], serverDefs: any } {
+function nativeMcpCatalog(servers        = [])                                            {
   const allServers = servers.map((server) => server.id);
   const serverDefs = Object.fromEntries(servers.map((server) => [server.id, {
     command: server.command,
@@ -591,8 +720,8 @@ function nativeMcpCatalog(servers: any[] = []): { allServers: string[], serverDe
   return { allServers, serverDefs };
 }
 
-function capabilityMapData(registry: any): any[] {
-  return registry.harnesses.flatMap((harness: any) => (Object.entries(harness.capabilities) as [string, any][]).map(([capability, declaration]) => ({
+function capabilityMapData(registry     )        {
+  return registry.harnesses.flatMap((harness     ) => (Object.entries(harness.capabilities)                   ).map(([capability, declaration]) => ({
     harness: harness.id,
     displayName: harness.displayName,
     capability,
@@ -605,7 +734,7 @@ function capabilityMapData(registry: any): any[] {
 }
 
 module.exports = {
-  REGISTRY_FILES, CAPABILITY_STATUS, ORCHESTRATION_STATUS, ORCHESTRATION_OPS, validateOrchestration, PROVIDER_SOURCE_MODES, validateCapabilityProviders, EXTERNAL_TOOL_IDS, EXTERNAL_TOOL_ACTIONS,
+  REGISTRY_FILES, CAPABILITY_STATUS, ORCHESTRATION_STATUS, ORCHESTRATION_OPS, validateOrchestration, CONTEXT_PROFILE_FIELDS, validateContextProfile, PROVIDER_SOURCE_MODES, validateCapabilityProviders, EXTERNAL_TOOL_IDS, EXTERNAL_TOOL_ACTIONS, validateCoverage,
   parseRegistryFile, registryDir, loadRegistry, validateRegistry,
   harnessFor, selectAssets, selectMcpServers, mcpCapable, nativeMcpCatalog, capabilityMapData,
 };