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

package/src/runtime/{freshness.ts → freshness.js}

@@ -6,11 +6,11 @@ const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
 const { execFileSync } = require('node:child_process');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 // Freshness is measured against the bytes observed, not whether the file was clean at HEAD.
 // Git identity remains provenance and a conservative fallback for older records without hashes.
-function fileHash(root: string, locator: any): string | null {
+function fileHash(root        , locator     )                {
   if (!locator?.file) return null;
   try {
     const absolute = path.resolve(root, locator.file);
@@ -19,26 +19,26 @@ function fileHash(root: string, locator: any): string | null {
   } catch { return null; }
 }
 
-function measureFreshness(root: string, locator: any, gitCommit: any): any {
+function measureFreshness(root        , locator     , gitCommit     )      {
   return { gitCommit, fileHash: fileHash(root, locator), observedAt: new Date().toISOString(), status: 'FRESH' };
 }
 
 class FreshnessValidator {
-  repoRoot: string;
-  gitRunner: (args: string[], cwd?: string) => string | null;
-  declare diffCache?: Map<string, Set<string>>;
+  repoRoot        ;
+  gitRunner                                                 ;
+                                               
 
   /**
    * @param {Object} [options]
    * @param {string} [options.repoRoot]
    * @param {Function} [options.gitRunner]
    */
-  constructor(options: any = {}) {
+  constructor(options      = {}) {
     this.repoRoot = options.repoRoot || REPO_ROOT;
     this.gitRunner = options.gitRunner || this.defaultGitRunner.bind(this);
   }
 
-  defaultGitRunner(args: string[], cwd: string = this.repoRoot): string | null {
+  defaultGitRunner(args          , cwd         = this.repoRoot)                {
     try {
       return execFileSync('git', args, {
         cwd,
@@ -55,7 +55,7 @@ class FreshnessValidator {
    * Retrieves the current HEAD commit hash.
    * @returns {string|null}
    */
-  getCurrentHead(): string | null {
+  getCurrentHead()                {
     return this.gitRunner(['rev-parse', 'HEAD']);
   }
 
@@ -63,11 +63,11 @@ class FreshnessValidator {
    * Retrieves all modified/unstaged/staged files in the repository.
    * @returns {Set<string>}
    */
-  getDirtyFiles(): Set<string> {
+  getDirtyFiles()              {
     const output = this.gitRunner(['status', '--porcelain']);
     if (!output) return new Set();
 
-    const dirty = new Set<string>();
+    const dirty = new Set        ();
     const lines = output.split('\n');
     for (const line of lines) {
       if (line.length > 3) {
@@ -83,14 +83,14 @@ class FreshnessValidator {
    * @param {string} [refCommit]
    * @returns {Set<string>}
    */
-  getModifiedFilesSince(refCommit?: string): Set<string> {
+  getModifiedFilesSince(refCommit         )              {
     // `checkEvidenceFreshness` calls this once per evidence item, and a batch of evidence shares
     // one recorded commit — so without a memo a task with ninety items ran ninety `git diff`s to
     // answer the same question. Keyed on the commit because that is the axis the work collapses
     // on. Instance-scoped, so it lives exactly as long as one invocation.
     if (!this.diffCache) this.diffCache = new Map();
     const key = refCommit || '';
-    if (this.diffCache.has(key)) return this.diffCache.get(key) as Set<string>;
+    if (this.diffCache.has(key)) return this.diffCache.get(key)               ;
 
     const dirty = this.getDirtyFiles();
     if (!refCommit) {
@@ -113,7 +113,7 @@ class FreshnessValidator {
    * @param {Object} item - Evidence item
    * @returns {{ status: 'FRESH'|'STALE', reason?: string }}
    */
-  checkEvidenceFreshness(item: any): { status: 'FRESH' | 'STALE'; reason?: string } {
+  checkEvidenceFreshness(item     )                                                 {
     if (!item) return { status: 'STALE', reason: 'Evidence item is missing' };
     
     // If explicitly marked stale
@@ -152,7 +152,7 @@ class FreshnessValidator {
    * @param {Object} ledger - EvidenceLedger instance
    * @returns {number} count of newly invalidated items
    */
-  validateLedgerFreshness(ledger: any): number {
+  validateLedgerFreshness(ledger     )         {
     if (!ledger || typeof ledger.getAllEvidence !== 'function') return 0;
     
     let count = 0;

package/src/runtime/{health.ts → health.js}

@@ -21,12 +21,12 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { CapabilityRouter } = require('./capability-router.ts');
-const { loadRegistry } = require('../registry/index.ts');
-const { evaluateReach } = require('./reach.ts');
-const { mcpReach } = require('./mcp-reach.ts');
-const { OUTCOME_LABELS } = require('./mcp-consultations.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { CapabilityRouter } = require('./capability-router.js');
+const { loadRegistry } = require('../registry/index.js');
+const { evaluateReach } = require('./reach.js');
+const { mcpReach } = require('./mcp-reach.js');
+const { OUTCOME_LABELS } = require('./mcp-consultations.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 /** Answered a probe. */
 const HEALTHY = 'HEALTHY';
@@ -49,15 +49,15 @@ const BANNER_MAX = 80;
  * them exists the result is UNKNOWN naming the paths searched, because a provider that owns its
  * own cache layout must not have a freshness verdict invented for it.
  */
-const PROVIDER_ARTIFACTS: Record<string, any> = Object.freeze({
+const PROVIDER_ARTIFACTS                      = Object.freeze({
   'graphify.query': {
     label: 'code graph',
-    candidates: (root: any) => [path.join(root, 'graphify-out', 'graph.json')],
+    candidates: (root     ) => [path.join(root, 'graphify-out', 'graph.json')],
     refresh: 'graphify update .',
   },
   'semble.search': {
     label: 'semantic index',
-    candidates: (root: any, home: any) => [
+    candidates: (root     , home     ) => [
       path.join(root, '.semble', 'index.json'),
       path.join(root, '.semble'),
       path.join(home, '.cache', 'semble', 'index'),
@@ -84,7 +84,7 @@ const SCAN_FILE_LIMIT = 4000;
  * @param {number} [options.timeoutMs=PROBE_TIMEOUT_MS]
  * @returns {{ok: boolean, output: string, durationMs: number, timedOut: boolean, error: string|null}}
  */
-function runProbe(command: any, { execFileImpl = execFileSync, timeoutMs = PROBE_TIMEOUT_MS }: any = {}) {
+function runProbe(command     , { execFileImpl = execFileSync, timeoutMs = PROBE_TIMEOUT_MS }      = {}) {
   const [bin, ...args] = command;
   const started = Number(process.hrtime.bigint() / 1000000n);
   try {
@@ -100,7 +100,7 @@ function runProbe(command: any, { execFileImpl = execFileSync, timeoutMs = PROBE
       timedOut: false,
       error: null,
     };
-  } catch (error: any) {
+  } catch (error     ) {
     // A killed process and a non-zero exit are both "did not answer", but they are different
     // repairs — a timeout usually means a first-run index build, a non-zero exit usually means a
     // broken install — so they are reported apart rather than as one failure string.
@@ -117,7 +117,7 @@ function runProbe(command: any, { execFileImpl = execFileSync, timeoutMs = PROBE
 
 /** First line of probe output, trimmed to a banner. Control characters are stripped so a provider
  * cannot rewrite the doctor report with an escape sequence. */
-function banner(output: any) {
+function banner(output     ) {
   if (!output) return null;
   // Control characters are removed by code point rather than by a literal class, so this source
   // file stays free of the escape sequences it is defending against.
@@ -137,7 +137,7 @@ function banner(output: any) {
  * @param {number} [options.limit=SCAN_FILE_LIMIT]
  * @returns {{mtimeMs: number|null, filesScanned: number, truncated: boolean}}
  */
-function newestSourceMtime(root: any, { fsImpl = fs, limit = SCAN_FILE_LIMIT }: any = {}) {
+function newestSourceMtime(root     , { fsImpl = fs, limit = SCAN_FILE_LIMIT }      = {}) {
   let mtimeMs = null;
   let filesScanned = 0;
   let truncated = false;
@@ -180,7 +180,7 @@ function newestSourceMtime(root: any, { fsImpl = fs, limit = SCAN_FILE_LIMIT }:
  * @param {Object} [options.fsImpl=fs]
  * @returns {Object|null} null when the provider is not index-backed
  */
-function probeFreshness(providerId: any, { root = process.cwd(), homeDir = os.homedir(), fsImpl = fs }: any = {}) {
+function probeFreshness(providerId     , { root = process.cwd(), homeDir = os.homedir(), fsImpl = fs }      = {}) {
   const spec = PROVIDER_ARTIFACTS[providerId];
   if (!spec) return null;
 
@@ -253,11 +253,11 @@ function probeFreshness(providerId: any, { root = process.cwd(), homeDir = os.ho
  * @param {Object} [options.fsImpl]
  * @returns {Object} probe result
  */
-function probeProvider(provider: any, { router, projectRoot = process.cwd(), execFileImpl, fsImpl = fs }: any = {}) {
+function probeProvider(provider     , { router, projectRoot = process.cwd(), execFileImpl, fsImpl = fs }      = {}) {
   if (!provider || !provider.id) {
     return { id: null, status: UNVERIFIED, detail: 'no provider declared' };
   }
-  const result: any = {
+  const result      = {
     id: provider.id,
     name: provider.name || provider.id,
     binary: provider.binary || null,
@@ -326,11 +326,11 @@ function probeProvider(provider: any, { router, projectRoot = process.cwd(), exe
  * @param {CapabilityRouter} [options.router]
  * @returns {Object} map of provider id -> probe result
  */
-function probeProviders({ repoRoot, projectRoot = process.cwd(), ids = null, router, execFileImpl, fsImpl = fs }: any = {}) {
+function probeProviders({ repoRoot, projectRoot = process.cwd(), ids = null, router, execFileImpl, fsImpl = fs }      = {}) {
   const activeRouter = router || new CapabilityRouter({ repoRoot: repoRoot || REPO_ROOT, projectRoot });
   const wanted = ids ? new Set(ids) : null;
-  const results: Record<string, any> = {};
-  for (const capability of Object.values<any>(activeRouter.capabilities || {})) {
+  const results                      = {};
+  for (const capability of Object.values     (activeRouter.capabilities || {})) {
     for (const provider of capability.providers || []) {
       if (!provider || !provider.id) continue;
       if (wanted && !wanted.has(provider.id)) continue;
@@ -355,18 +355,18 @@ function probeProviders({ repoRoot, projectRoot = process.cwd(), ids = null, rou
  * @param {Function} [options.detector] injection seam; defaults to the C.2 module when present
  * @returns {{status: string, build: Object|null, test: Object|null, reason?: string}}
  */
-function detectProjectCommands({ projectRoot = process.cwd(), detector }: any = {}) {
+function detectProjectCommands({ projectRoot = process.cwd(), detector }      = {}) {
   let detect = detector;
   if (!detect) {
     let mod = null;
     try {
-      mod = require('./command-detect.ts');
+      mod = require('./command-detect.js');
     } catch {
       return {
         status: 'UNKNOWN',
         build: null,
         test: null,
-        reason: 'src/runtime/command-detect.ts is not present in this build; DoFlow reports detected commands but does not detect them itself, and will not guess',
+        reason: 'src/runtime/command-detect.js is not present in this build; DoFlow reports detected commands but does not detect them itself, and will not guess',
       };
     }
     detect = typeof mod.detectCommands === 'function' ? mod.detectCommands : null;
@@ -375,7 +375,7 @@ function detectProjectCommands({ projectRoot = process.cwd(), detector }: any =
         status: 'UNKNOWN',
         build: null,
         test: null,
-        reason: `src/runtime/command-detect.ts exports no detectCommands() (found: ${Object.keys(mod).join(', ') || 'nothing'})`,
+        reason: `src/runtime/command-detect.js exports no detectCommands() (found: ${Object.keys(mod).join(', ') || 'nothing'})`,
       };
     }
   }
@@ -383,7 +383,7 @@ function detectProjectCommands({ projectRoot = process.cwd(), detector }: any =
   let detected;
   try {
     detected = detect({ projectRoot }) || {};
-  } catch (error: any) {
+  } catch (error     ) {
     return { status: 'UNKNOWN', build: null, test: null, reason: `command detection failed: ${error.message}` };
   }
 
@@ -414,15 +414,15 @@ function detectProjectCommands({ projectRoot = process.cwd(), detector }: any =
 }
 
 /** Roll a capability's provider probes up into one status. */
-function capabilityStatus(probes: any) {
+function capabilityStatus(probes     ) {
   if (!probes.length) return { status: 'UNAVAILABLE', activeProvider: null };
-  const firstHealthy = probes.findIndex((probe: any) => probe.status === HEALTHY);
+  const firstHealthy = probes.findIndex((probe     ) => probe.status === HEALTHY);
   if (firstHealthy === 0) return { status: HEALTHY, activeProvider: probes[0].id };
   if (firstHealthy > 0) return { status: 'FALLBACK', activeProvider: probes[firstHealthy].id };
   // Nothing answered. "Installed but broken" and "not installed" are different problems: the first
   // is actionable now, the second is the graceful degradation NFR-002 requires.
-  if (probes.some((probe: any) => probe.status === UNHEALTHY)) return { status: 'DEGRADED', activeProvider: null };
-  if (probes.every((probe: any) => probe.status === ABSENT)) return { status: 'UNAVAILABLE', activeProvider: null };
+  if (probes.some((probe     ) => probe.status === UNHEALTHY)) return { status: 'DEGRADED', activeProvider: null };
+  if (probes.every((probe     ) => probe.status === ABSENT)) return { status: 'UNAVAILABLE', activeProvider: null };
   return { status: UNVERIFIED, activeProvider: null };
 }
 
@@ -434,7 +434,7 @@ function capabilityStatus(probes: any) {
  * @returns {Object} report model
  */
 /** The installed DoFlow source's own version, read from its package.json; null when unreadable. */
-function installVersion(root: any, fsImpl = fs) {
+function installVersion(root     , fsImpl = fs) {
   try {
     return JSON.parse(fsImpl.readFileSync(path.join(root, 'package.json'), 'utf8')).version || null;
   } catch {
@@ -443,8 +443,8 @@ function installVersion(root: any, fsImpl = fs) {
 }
 
 /** The project's git identity — short commit and branch — or null outside a repository. */
-function projectGitIdentity(projectRoot: any) {
-  const git = (args: any) => {
+function projectGitIdentity(projectRoot     ) {
+  const git = (args     ) => {
     try {
       return execFileSync('git', ['-C', projectRoot, ...args], {
         encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
@@ -468,19 +468,19 @@ const NO_OUTCOME_SHOWN = 3;
  * it and the command that adds it where it is missing. Read-only; starts no server (NFR-001).
  * Server ids come from the registry, never from this file.
  */
-function mcpServersView({ registry, projectRoot, fsImpl, adapters }: any) {
-  const named = registry.mcp.filter((server: any) => (server.steps || []).length);
+function mcpServersView({ registry, projectRoot, fsImpl, adapters }     ) {
+  const named = registry.mcp.filter((server     ) => (server.steps || []).length);
   if (!named.length) return [];
   if (!adapters) throw new Error('no adapter registry was given');
   const reach = mcpReach({ registry, projectRoot, fsImpl, adapters });
-  const unreadableFile = (harness: any) => reach.unreadable.find((item: any) => item.harness === harness.id && item.scope === harness.scope);
-  return named.map((server: any) => ({
+  const unreadableFile = (harness     ) => reach.unreadable.find((item     ) => item.harness === harness.id && item.scope === harness.scope);
+  return named.map((server     ) => ({
     id: server.id,
     selection: server.selection,
-    namedBy: [...new Set(server.steps.map((step: any) => (step.expectedWhen === 'research-request' ? `${step.skill} (research request)` : step.skill)))],
-    harnesses: reach.harnesses.map((harness: any) => {
+    namedBy: [...new Set(server.steps.map((step     ) => (step.expectedWhen === 'research-request' ? `${step.skill} (research request)` : step.skill)))],
+    harnesses: reach.harnesses.map((harness     ) => {
       const state = harness.servers[server.id];
-      const row: any = { id: harness.id, scope: harness.scope, state };
+      const row      = { id: harness.id, scope: harness.scope, state };
       const unreadable = state === 'unknown' ? unreadableFile(harness) : null;
       // An unreadable config is fixed before anything is added to it (IC-014).
       if (unreadable) row.fix = unreadable.file || `${harness.id}'s MCP config`;
@@ -490,7 +490,7 @@ function mcpServersView({ registry, projectRoot, fsImpl, adapters }: any) {
   }));
 }
 
-const byText = (a: any, b: any) => (a < b ? -1 : a > b ? 1 : 0);
+const byText = (a     , b     ) => (a < b ? -1 : a > b ? 1 : 0);
 
 /**
  * The `[MCP Consultations]` data (IC-015): the recorded `consultations` of the project's run
@@ -498,10 +498,10 @@ const byText = (a: any, b: any) => (a < b ? -1 : a > b ? 1 : 0);
  * `at`, counted per server. An entry without `consultations` predates the feature and is never
  * counted (NFR-005); "no outcome" is `named` minus the servers with an outcome, never stored.
  */
-function mcpConsultationsView({ projectRoot, fsImpl }: any) {
+function mcpConsultationsView({ projectRoot, fsImpl }     ) {
   const dir = path.join(projectRoot, '.doflow', 'state', 'orchestration');
   let files = [];
-  try { files = fsImpl.readdirSync(dir).filter((name: any) => name.endsWith('.json')).sort(); } catch { files = []; }
+  try { files = fsImpl.readdirSync(dir).filter((name     ) => name.endsWith('.json')).sort(); } catch { files = []; }
   let unreadableRuns = 0;
   const bySkill = new Map();
   for (const name of files) {
@@ -517,14 +517,14 @@ function mcpConsultationsView({ projectRoot, fsImpl }: any) {
   }
   const stages = [...bySkill.keys()].sort(byText).map((skill) => {
     const kept = bySkill.get(skill)
-      .sort((a: any, b: any) => byText(b.at, a.at) || byText(a.taskId, b.taskId) || byText(String(a.node), String(b.node)))
+      .sort((a     , b     ) => byText(b.at, a.at) || byText(a.taskId, b.taskId) || byText(String(a.node), String(b.node)))
       .slice(0, CONSULTATION_WINDOW);
     const counts = new Map();
-    const row = (server: any) => {
+    const row = (server     ) => {
       if (!counts.has(server)) counts.set(server, { server, used: 0, nothingUsable: 0, skipped: 0, unavailable: 0, noOutcome: 0 });
       return counts.get(server);
     };
-    const key: Record<string, any> = { 'consulted-used': 'used', 'consulted-nothing-usable': 'nothingUsable', skipped: 'skipped', unavailable: 'unavailable' };
+    const key                      = { 'consulted-used': 'used', 'consulted-nothing-usable': 'nothingUsable', skipped: 'skipped', unavailable: 'unavailable' };
     const noOutcome = [];
     const shown = new Map();
     for (const { taskId, node, at, record } of kept) {
@@ -533,7 +533,7 @@ function mcpConsultationsView({ projectRoot, fsImpl }: any) {
         if (outcome && typeof outcome.server === 'string' && key[outcome.state]) outcomes.set(outcome.server, key[outcome.state]);
       }
       for (const [server, field] of outcomes) row(server)[field] += 1;
-      for (const server of (Array.isArray(record.named) ? record.named : []).filter((id: any) => typeof id === 'string').sort(byText)) {
+      for (const server of (Array.isArray(record.named) ? record.named : []).filter((id     ) => typeof id === 'string').sort(byText)) {
         if (outcomes.has(server)) continue;
         row(server).noOutcome += 1;
         // `kept` is newest first, so the first entries per server are its latest.
@@ -548,14 +548,14 @@ function mcpConsultationsView({ projectRoot, fsImpl }: any) {
 
 /** The doctor's `mcp` block. A servers view that cannot be built degrades to a one-line note; the
  * sections never enter findings or change the exit code (FR-011, FR-012). */
-function mcpView({ registry, projectRoot, fsImpl, adapters }: any) {
+function mcpView({ registry, projectRoot, fsImpl, adapters }     ) {
   let servers = [];
   let serversNote;
-  try { servers = mcpServersView({ registry, projectRoot, fsImpl, adapters }); } catch (error: any) { serversNote = `MCP server view unavailable: ${error.message}`; }
+  try { servers = mcpServersView({ registry, projectRoot, fsImpl, adapters }); } catch (error     ) { serversNote = `MCP server view unavailable: ${error.message}`; }
   return { servers, ...(serversNote ? { serversNote } : {}), consultations: mcpConsultationsView({ projectRoot, fsImpl }) };
 }
 
-const MCP_STATE_MARK: Record<string, any> = Object.freeze({
+const MCP_STATE_MARK                      = Object.freeze({
   selected: '✓ selected',
   configured: '✓ configured',
   'not-selected': '○ not selected',
@@ -563,11 +563,11 @@ const MCP_STATE_MARK: Record<string, any> = Object.freeze({
   unknown: '? unknown',
 });
 
-function printMcpSections(mcp: any) {
+function printMcpSections(mcp     ) {
   console.log('\n[MCP Servers] — named by shipped stages; not blocking');
   if (mcp.serversNote) {
     console.log(`  ${mcp.serversNote}`);
-  } else if (!mcp.servers.some((server: any) => server.harnesses.length)) {
+  } else if (!mcp.servers.some((server     ) => server.harnesses.length)) {
     console.log('  No harness has DoFlow ledger rows here, so no server selection to report.');
   } else {
     for (const server of mcp.servers) {
@@ -602,11 +602,11 @@ function printMcpSections(mcp: any) {
   if (unreadableRuns) console.log(`  ${unreadableRuns} run file(s) could not be read`);
 }
 
-function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, execFileImpl, fsImpl = fs, detector, adapters }: any = {}) {
+function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, execFileImpl, fsImpl = fs, detector, adapters }      = {}) {
   const root = repoRoot || REPO_ROOT;
   const registry = loadRegistry({ repoRoot: root });
   const activeRouter = router || new CapabilityRouter({ repoRoot: root, projectRoot });
-  const probes: Record<string, any> = probeProviders({ repoRoot: root, projectRoot, router: activeRouter, execFileImpl, fsImpl });
+  const probes                      = probeProviders({ repoRoot: root, projectRoot, router: activeRouter, execFileImpl, fsImpl });
   const project = { root: path.resolve(projectRoot), commands: detectProjectCommands({ projectRoot, detector }) };
 
   // `native.test` is the one provider with neither a binary nor a probe: it stands for whatever the
@@ -621,8 +621,8 @@ function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, exec
       : 'no probe of its own, and no project test command was detected — nothing establishes that this capability can answer';
   }
 
-  const capabilities = Object.entries<any>(activeRouter.capabilities || {}).map(([id, capability]) => {
-    const declared = (capability.providers || []).map((provider: any) => probes[provider.id]).filter(Boolean);
+  const capabilities = Object.entries     (activeRouter.capabilities || {}).map(([id, capability]) => {
+    const declared = (capability.providers || []).map((provider     ) => probes[provider.id]).filter(Boolean);
     const rolled = capabilityStatus(declared);
     return {
       capability: id,
@@ -630,14 +630,14 @@ function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, exec
       status: rolled.status,
       activeProvider: rolled.activeProvider,
       totalProviders: declared.length,
-      providers: declared.map((probe: any) => ({ id: probe.id, status: probe.status, detail: probe.detail })),
+      providers: declared.map((probe     ) => ({ id: probe.id, status: probe.status, detail: probe.detail })),
     };
   });
 
   // External tools are the same binaries the providers use, so their status comes from the probe
   // that already ran rather than from a second, weaker presence check.
-  const externalTools = registry.externalTools.map((tool: any) => {
-    const probe: any = Object.values(probes).find((candidate) => candidate.binary === tool.id);
+  const externalTools = registry.externalTools.map((tool     ) => {
+    const probe      = Object.values(probes).find((candidate) => candidate.binary === tool.id);
     if (probe) return { id: tool.id, displayName: tool.displayName, status: probe.status, detail: probe.detail };
     const present = activeRouter.isBinaryAvailable(tool.id);
     return {
@@ -662,8 +662,8 @@ function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, exec
       .filter((capability) => capability.status === 'DEGRADED')
       .map((capability) => ({ kind: 'capability-degraded', subject: capability.capability, detail: 'every installed provider for this capability failed its probe' })),
     ...reach.rows
-      .filter((row: any) => row.state === 'NO-REACH')
-      .map((row: any) => ({ kind: 'runtime-no-reach', subject: `${row.harness}:${row.scope}`, detail: `${row.reason}; fix: ${row.fix}` })),
+      .filter((row     ) => row.state === 'NO-REACH')
+      .map((row     ) => ({ kind: 'runtime-no-reach', subject: `${row.harness}:${row.scope}`, detail: `${row.reason}; fix: ${row.fix}` })),
   ];
   const warnings = [
     ...freshness
@@ -676,7 +676,7 @@ function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, exec
       .filter((probe) => probe.status === UNVERIFIED)
       .map((probe) => ({ kind: 'provider-unverified', subject: probe.id, detail: probe.detail })),
     ...reach.unreadable
-      .map((item: any) => ({ kind: 'reach-ledger-unreadable', subject: `${item.scope}: ${item.ledger}`, detail: item.detail })),
+      .map((item     ) => ({ kind: 'reach-ledger-unreadable', subject: `${item.scope}: ${item.ledger}`, detail: item.detail })),
     ...(project.commands.status === 'DETECTED' ? [] : [{ kind: 'project-commands', subject: 'build/test', detail: project.commands.reason }]),
   ];
 
@@ -692,11 +692,11 @@ function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, exec
 
   return {
     identity,
-    harnesses: registry.harnesses.map((harness: any) => ({
+    harnesses: registry.harnesses.map((harness     ) => ({
       id: harness.id,
       displayName: harness.displayName,
       status: 'PASS',
-      reach: reach.rows.filter((row: any) => row.harness === harness.id).map(({ harness: _harness, ...row }: any) => row),
+      reach: reach.rows.filter((row     ) => row.harness === harness.id).map(({ harness: _harness, ...row }     ) => row),
     })),
     externalTools,
     capabilities,
@@ -728,12 +728,12 @@ function buildHealthReport({ repoRoot, projectRoot = process.cwd(), router, exec
  * @param {number} code
  * @returns {number}
  */
-function finish(code: any) {
+function finish(code     ) {
   process.exitCode = code;
   return code;
 }
 
-const STATUS_MARK: Record<string, any> = Object.freeze({
+const STATUS_MARK                      = Object.freeze({
   HEALTHY: '✓ HEALTHY',
   UNHEALTHY: '✗ UNHEALTHY',
   ABSENT: '○ ABSENT',
@@ -743,13 +743,13 @@ const STATUS_MARK: Record<string, any> = Object.freeze({
   UNAVAILABLE: '○ UNAVAILABLE',
 });
 
-const REACH_MARK: Record<string, any> = Object.freeze({
+const REACH_MARK                      = Object.freeze({
   REACHED: '✓ REACHED',
   'NO-REACH': '✗ NO-REACH',
   'N/A': '○ N/A',
 });
 
-const FRESHNESS_MARK: Record<string, any> = Object.freeze({
+const FRESHNESS_MARK                      = Object.freeze({
   FRESH: '✓ FRESH',
   STALE: '▲ STALE',
   UNKNOWN: '? UNKNOWN',
@@ -764,9 +764,9 @@ const FRESHNESS_MARK: Record<string, any> = Object.freeze({
  * @returns {number} process exit code — 1 when a provider is installed but does not answer, or an
  *   installed harness's skills cannot reach a runtime
  */
-async function handleDoctorCommand({ json = false, repoRoot, projectRoot = process.cwd(), ...rest }: any = {}) {
-  const report: any = buildHealthReport({ repoRoot, projectRoot, ...rest });
-  const { buildAdviceDoctor, printAdviceDoctor } = require('./advice/doctor.ts');
+async function handleDoctorCommand({ json = false, repoRoot, projectRoot = process.cwd(), ...rest }      = {}) {
+  const report      = buildHealthReport({ repoRoot, projectRoot, ...rest });
+  const { buildAdviceDoctor, printAdviceDoctor } = require('./advice/doctor.js');
   const adviceSections = await buildAdviceDoctor({ repoRoot, projectRoot, fsImpl: rest.fsImpl });
   report.decisionModel = adviceSections.decisionModel;
   report.advice = adviceSections.advice;
@@ -790,8 +790,8 @@ async function handleDoctorCommand({ json = false, repoRoot, projectRoot = proce
   for (const harness of report.harnesses) console.log(`  ${harness.displayName.padEnd(28)} adapter PASS`);
 
   console.log('\n[Runtime Reach]');
-  const reachLines = report.harnesses.flatMap((harness: any) => harness.reach.map((row: any) => {
-    const detail = ({ REACHED: row.root, 'NO-REACH': `fix: ${row.fix}`, 'N/A': row.reason } as Record<string, any>)[row.state];
+  const reachLines = report.harnesses.flatMap((harness     ) => harness.reach.map((row     ) => {
+    const detail = ({ REACHED: row.root, 'NO-REACH': `fix: ${row.fix}`, 'N/A': row.reason }                       )[row.state];
     const where = row.scope === 'project' ? ` [install at ${row.installRoot}]` : '';
     return `  ${harness.id.padEnd(14)}${row.scope.padEnd(9)}${(REACH_MARK[row.state] || row.state).padEnd(13)}${detail}${where}`;
   }));
@@ -819,7 +819,7 @@ async function handleDoctorCommand({ json = false, repoRoot, projectRoot = proce
 
   console.log('\n[Project Commands]');
   const commands = report.project.commands;
-  const commandLine = (role: any) => (role
+  const commandLine = (role     ) => (role
     ? `✓ ${role.command}${role.source ? `  (${role.source}, ${role.derivation || 'declared'})` : ''}`
     : '? not detected');
   console.log(`  build             ${commandLine(commands.build)}`);