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

package/src/registry/index.js

@@ -83,6 +83,7 @@ function loadRegistry({ repoRoot, dir, fsImpl = fs }
     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,
@@ -132,11 +133,10 @@ function validateContract(value     , location        , errors          , 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)) {
@@ -412,6 +412,94 @@ function validateOrchestration(value     , location        , errors          )
   }
 }
 
+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;
@@ -430,7 +518,7 @@ function validateRegistry(registry     , { repoRoot, fsImpl = fs }
   idsUnique(mcp, 'mcp', errors); idsUnique(lifecycle, 'lifecycle', errors);
   idsUnique(externalTools, 'externalTools', errors);
 
-  const harnessIds = new Set((harnesses || []).filter(object).map((item     ) => 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; }
@@ -451,6 +539,7 @@ function validateRegistry(registry     , { repoRoot, fsImpl = fs }
       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);
   }
 
@@ -520,6 +609,8 @@ function validateRegistry(registry     , { repoRoot, fsImpl = fs }
       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;
@@ -545,6 +636,44 @@ function validateRegistry(registry     , { repoRoot, fsImpl = fs }
   return { ok: errors.length === 0, errors };
 }
 
+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}'`);
@@ -605,7 +734,7 @@ function capabilityMapData(registry     )        {
 }
 
 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,
 };