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

package/src/lifecycle/{mcp-index.ts → mcp-index.js}

@@ -15,7 +15,7 @@
 //
 // Only SELECTED servers are imported, so the cost is proportional to what is installed: a
 // one-server install pays for one doc, and an install with none produces no file at all.
-function renderMcpIndex(selectedServers: any[] | null | undefined): string | null {
+function renderMcpIndex(selectedServers                          )                {
   if (!selectedServers || selectedServers.length === 0) return null;
   const lines = ['# MCP short flags — this install'];
   for (const server of selectedServers) {

package/src/lifecycle/{policies.ts → policies.js}

@@ -5,30 +5,30 @@
 // Registry lifecycle policies are logical intent. This projection reports what a
 // harness may render and any human prerequisite; native event serialization stays
 // in the owning harness adapter.
-const { harnessFor } = require('../registry/index.ts');
+const { harnessFor } = require('../registry/index.js');
 
 const POLICY_STATUSES = new Set(['supported', 'different', 'unavailable', 'prerequisite']);
 
-function unique(values: any[]): any[] { return [...new Set(values.filter(Boolean))]; }
+function unique(values       )        { return [...new Set(values.filter(Boolean))]; }
 
-function policyFor(registry: any, id: string): any {
-  const policy = registry?.lifecycle?.find((item: any) => item.id === id);
+function policyFor(registry     , id        )      {
+  const policy = registry?.lifecycle?.find((item     ) => item.id === id);
   if (!policy) throw new Error(`Unknown lifecycle policy '${id}'`);
   return policy;
 }
 
-function renderPolicy(policy: any, harness: any): any {
+function renderPolicy(policy     , harness     )      {
   const mapping = policy?.mappings?.[harness.id];
   if (!mapping) throw new Error(`Lifecycle policy '${policy.id}' has no mapping for '${harness.id}'`);
-  const requiredCapabilities = (policy.requires || []).map((capability: string): [string, any] => {
+  const requiredCapabilities = (policy.requires || []).map((capability        )                => {
     const declaration = harness.capabilities?.[capability];
     if (!declaration) throw new Error(`Lifecycle policy '${policy.id}' requires unknown '${harness.id}' capability '${capability}'`);
     return [capability, declaration];
   });
-  const unavailableCapability = requiredCapabilities.find(([, declaration]: [string, any]) => declaration.status === 'unavailable');
+  const unavailableCapability = requiredCapabilities.find(([, declaration]               ) => declaration.status === 'unavailable');
   const prerequisites = unique([
     ...(mapping.prerequisites || []),
-    ...requiredCapabilities.flatMap(([, declaration]: [string, any]) => declaration.prerequisites || []),
+    ...requiredCapabilities.flatMap(([, declaration]               ) => declaration.prerequisites || []),
   ]);
   const capabilityStatus = unavailableCapability ? 'unavailable' : mapping.status;
   const unavailable = capabilityStatus === 'unavailable';
@@ -60,14 +60,14 @@ function renderPolicy(policy: any, harness: any): any {
 }
 
 /** Render policy status data for one harness without calling an adapter or writing state. */
-function renderPolicies(registry: any, { harness: harnessId, policyIds }: { harness?: string, policyIds?: string[] | null } = {}): any {
+function renderPolicies(registry     , { harness: harnessId, policyIds }                                                    = {})      {
   if (!harnessId) throw new Error('A harness id is required to render lifecycle policies');
   const harness = harnessFor(registry, harnessId);
   const policies = policyIds === undefined || policyIds === null
     ? registry.lifecycle
-    : policyIds.map((id: string) => policyFor(registry, id));
+    : policyIds.map((id        ) => policyFor(registry, id));
   if (!Array.isArray(policies)) throw new Error('Lifecycle policies must be an array');
-  return Object.freeze(policies.map((policy: any) => renderPolicy(policy, harness)));
+  return Object.freeze(policies.map((policy     ) => renderPolicy(policy, harness)));
 }
 
 module.exports = { POLICY_STATUSES, policyFor, renderPolicy, renderPolicies };

package/src/lifecycle/{view.ts → view.js}

@@ -8,21 +8,21 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { parseToml } = require('../helper/toml.ts');
-const { createAdapterRegistry } = require('../adapters/index.ts');
-const { declaredHarnessPaths } = require('../helper/harness-paths.ts');
-const claudeAdapter = require('../adapters/claude/index.ts');
-const codexAdapter = require('../adapters/codex/index.ts');
-const { createGeminiAdapter } = require('../adapters/gemini/index.ts');
-const { createOpenCodeAdapter } = require('../adapters/opencode/index.ts');
-const { createPiAdapter } = require('../adapters/pi/index.ts');
-const { createCopilotAdapter } = require('../adapters/copilot/index.ts');
-const { createKiroAdapter } = require('../adapters/kiro/index.ts');
-const { createAntigravityAdapter } = require('../adapters/antigravity/index.ts');
-const { planLifecycle } = require('./index.ts');
-const { stateRoot, readLedger, defaultLedger } = require('../state/index.ts');
-const { selectAssets } = require('../registry/index.ts');
-const { defaultLock, readLock, writeLock, diffLocks, removeLock, pinnedSelections } = require('../state/lockfile.ts');
+const { parseToml } = require('../helper/toml.js');
+const { createAdapterRegistry } = require('../adapters/index.js');
+const { declaredHarnessPaths } = require('../helper/harness-paths.js');
+const claudeAdapter = require('../adapters/claude/index.js');
+const codexAdapter = require('../adapters/codex/index.js');
+const { createGeminiAdapter } = require('../adapters/gemini/index.js');
+const { createOpenCodeAdapter } = require('../adapters/opencode/index.js');
+const { createPiAdapter } = require('../adapters/pi/index.js');
+const { createCopilotAdapter } = require('../adapters/copilot/index.js');
+const { createKiroAdapter } = require('../adapters/kiro/index.js');
+const { createAntigravityAdapter } = require('../adapters/antigravity/index.js');
+const { planLifecycle } = require('./index.js');
+const { stateRoot, readLedger, defaultLedger } = require('../state/index.js');
+const { selectAssets } = require('../registry/index.js');
+const { defaultLock, readLock, writeLock, diffLocks, removeLock, pinnedSelections } = require('../state/lockfile.js');
 // Tolerant because the projected runtime under `.doflow/runtime/` ships bin/, src/ and
 // core/registry/ but no package.json — see the `runtime.*` assets in core/registry/assets.json.
 // A hard require here would make every Node-backed verb fail in an install, which is the exact
@@ -32,9 +32,9 @@ function loadPkg() {
 }
 const pkg = loadPkg();
 
-function codexScope(scope: any) { return scope.global ? 'global' : 'project'; }
+function codexScope(scope     ) { return scope.global ? 'global' : 'project'; }
 
-function codexConfigResources(repoRoot: any, fsImpl: any) {
+function codexConfigResources(repoRoot     , fsImpl     ) {
   const configSrc = path.join(repoRoot, 'core', 'harnesses', 'codex', 'config', 'config.toml');
   const parsed = parseToml(fsImpl.readFileSync(configSrc, 'utf8'));
   return [...parsed.entries.entries()].map(([identity, entry]) => ({
@@ -48,7 +48,7 @@ function codexConfigResources(repoRoot: any, fsImpl: any) {
  * mutation path until every native adapter has CLI-level parity.
  * `registry` is loaded once per command (by the caller) and threaded through here rather than
  * reloaded — the same registry also resolves every harness's MCP selection for that command. */
-function registryLifecycleView({ registry, scope, targets, mcpSelections = {}, mcpAdoptable = {}, retainedMcpIds = [], operation, repoRoot, force = false, adopt = false, permissions = false, statusline = false, fsImpl = fs }: any) {
+function registryLifecycleView({ registry, scope, targets, mcpSelections = {}, mcpAdoptable = {}, retainedMcpIds = [], operation, repoRoot, force = false, adopt = false, permissions = false, statusline = false, fsImpl = fs }     ) {
   const lifecycleScope = codexScope(scope);
   const scopeRoot = scope.global ? os.homedir() : path.resolve(scope.projectRoot);
   const neutralStateRoot = stateRoot({ scope: lifecycleScope, projectRoot: scopeRoot, homeDir: scopeRoot });
@@ -79,11 +79,11 @@ function registryLifecycleView({ registry, scope, targets, mcpSelections = {}, m
   return { registry, stateRoot: neutralStateRoot, ledger, plan, adapters };
 }
 
-function printRegistryLifecycle(view: any, prefix = '[PLAN]') {
+function printRegistryLifecycle(view     , prefix = '[PLAN]') {
   console.log(`${prefix} Registry lifecycle: ${view.plan.changes.length} native change(s), ${view.plan.conflicts.length} conflict(s), ${view.plan.prerequisites.length} prerequisite(s)`);
   for (const target of view.plan.targets) {
     console.log(`${prefix}   ${target.harness}: ${target.changes.length} change(s)${target.conflicts.length ? `; conflicts: ${target.conflicts.join('; ')}` : ''}`);
-    const hookChange = target.changes.find((change: any) => change.nativeComponent === 'hooks');
+    const hookChange = target.changes.find((change     ) => change.nativeComponent === 'hooks');
     if (hookChange?.nativePlan?.trust?.required) {
       console.log(`${prefix}   ${target.harness} hooks trust: ${hookChange.nativePlan.trust.status} (review required in ${target.harness})`);
     }
@@ -94,7 +94,7 @@ function printRegistryLifecycle(view: any, prefix = '[PLAN]') {
 
 /** Prints the plan's notices after a real run. Independent of whether anything changed: a no-op
  * reinstall of a harness that has a gap must still say so. */
-function printPlanNotices(view: any) {
+function printPlanNotices(view     ) {
   for (const { harness, notice } of view.plan.notices) console.log(`[INFO] ${harness}: ${notice}`);
 }
 
@@ -103,7 +103,7 @@ function printPlanNotices(view: any) {
  * src/targets.js — so a future non-lifecycle target doesn't silently gain lifecycle behavior. */
 const LIFECYCLE_HARNESSES = ['claude', 'codex', 'gemini', 'opencode', 'pi', 'copilot', 'kiro', 'antigravity'];
 
-function assertSafeRegistryPlan(view: any) {
+function assertSafeRegistryPlan(view     ) {
   if (view.plan.safe) return;
   for (const conflict of view.plan.conflicts) console.error(`[ERROR] ${conflict.harness} lifecycle refused: ${conflict.reason}`);
   for (const prerequisite of view.plan.prerequisites) console.error(`[ERROR] ${prerequisite.harness} lifecycle prerequisite: ${prerequisite.prerequisite}`);
@@ -119,9 +119,9 @@ function assertSafeRegistryPlan(view: any) {
  * selections carry over for pinned harnesses and are replaced by the rows this run resolved, `[]`
  * included. Assets are recomputed from the registry for every pinned harness. `null` when no harness
  * stays pinned. */
-function lockDocument({ registry, scope, scopeRoot, previous = null, ledger, plannedTargets = [], mcpSelections = {}, sourceVersion = pkg.version, now = new Date() }: any) {
-  const held = new Set((ledger?.resources ?? []).map((resource: any) => resource?.harness));
-  const pinned = [...new Set([...(previous?.targets ?? []).map((entry: any) => entry.harness), ...plannedTargets])]
+function lockDocument({ registry, scope, scopeRoot, previous = null, ledger, plannedTargets = [], mcpSelections = {}, sourceVersion = pkg.version, now = new Date() }     ) {
+  const held = new Set((ledger?.resources ?? []).map((resource     ) => resource?.harness));
+  const pinned = [...new Set([...(previous?.targets ?? []).map((entry     ) => entry.harness), ...plannedTargets])]
     .filter((harness) => held.has(harness)).sort();
   if (!pinned.length) return null;
   const assets = [];
@@ -145,13 +145,13 @@ function lockDocument({ registry, scope, scopeRoot, previous = null, ledger, pla
 /** Describe the reviewable delta between the pinned lock and the next one: "created" for a first
  * pin, "unchanged" when nothing pinned differs, "cleared" when nothing remains pinned, else a count
  * of the changed rows. */
-function lockDelta(previous: any, next: any) {
+function lockDelta(previous     , next     ) {
   if (!next) return previous ? { changed: true, summary: 'cleared' } : { changed: false, summary: 'unchanged' };
   if (!previous) return { changed: true, summary: 'created' };
   const diff = diffLocks(previous, next);
   if (diff.clean) return { changed: false, summary: 'unchanged' };
   const count = ['targets', 'assets']
-    .flatMap((section) => Object.values<any>(diff[section]).map((list: any) => list.length))
+    .flatMap((section) => Object.values     (diff[section]).map((list     ) => list.length))
     .reduce((sum, n) => sum + n, 0)
     + diff.mcpSelections.changed.length + (diff.meta.sourceVersion ? 1 : 0);
   return { changed: true, summary: `${count} change(s)` };
@@ -160,7 +160,7 @@ function lockDelta(previous: any, next: any) {
 /** Persist the lock for a completed command and return its delta against what was pinned before.
  * An unchanged lock is left byte for byte, so routine re-runs neither rewrite the file nor
  * manufacture noise; a `null` lock removes the file. */
-function recordLock(scopeArgs: any, next: any, { fsImpl = fs }: any = {}) {
+function recordLock(scopeArgs     , next     , { fsImpl = fs }      = {}) {
   const delta = lockDelta(readLock(scopeArgs, { fsImpl }), next);
   if (delta.changed) {
     if (next) writeLock(scopeArgs, next, { fsImpl });

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);
   }
@@ -90,11 +90,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 +109,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(', ')}`);
@@ -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,8 @@ 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[] = [];
+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 +430,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
@@ -484,7 +484,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 +497,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,9 +511,9 @@ 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`);
@@ -539,21 +539,21 @@ 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);
+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 +562,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 +581,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 +591,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,