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

package/src/runtime/advice/{record.ts → record.js}

@@ -5,25 +5,25 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { resolveStorePath } = require('../storage/roots.ts');
+const { resolveStorePath } = require('../storage/roots.js');
 
 const RETAINED_DAYS = 90;
 const PARTITION_NAME = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
 
-function timestamp(now: any = () => new Date()): string | null {
+function timestamp(now      = () => new Date())                {
   const value = typeof now === 'function' ? now() : now;
   const date = new Date(value);
   return Number.isNaN(date.getTime()) ? null : date.toISOString();
 }
 
-function selectedStore(roots: any, requestedStore?: string): { store: string; root: string } | null {
+function selectedStore(roots     , requestedStore         )                                         {
   if (requestedStore && roots?.[requestedStore]) return { store: requestedStore, root: roots[requestedStore] };
   if (roots?.['project-state']) return { store: 'project-state', root: roots['project-state'] };
   if (roots?.['user-state']) return { store: 'user-state', root: roots['user-state'] };
   return null;
 }
 
-function appendLine({ roots, at, line, fsImpl = fs, store }: any): { file: string; store: string } | null {
+function appendLine({ roots, at, line, fsImpl = fs, store }     )                                         {
   try {
     const selected = selectedStore(roots, store);
     if (!selected) return null;
@@ -31,7 +31,7 @@ function appendLine({ roots, at, line, fsImpl = fs, store }: any): { file: strin
     if (!directory) return null;
     const file = path.join(directory, `${at.slice(0, 10)}.jsonl`);
     try { if (fsImpl.lstatSync(file).isSymbolicLink()) return null; }
-    catch (error: any) { if (error.code !== 'ENOENT') return null; }
+    catch (error     ) { if (error.code !== 'ENOENT') return null; }
     fsImpl.mkdirSync(path.dirname(file), { recursive: true });
     fsImpl.appendFileSync(file, `${JSON.stringify(line)}\n`, 'utf8');
     return { file, store: selected.store };
@@ -43,7 +43,7 @@ function appendLine({ roots, at, line, fsImpl = fs, store }: any): { file: strin
 function appendPick({
   roots, now = () => new Date(), fsImpl = fs, kind, answer, question,
   staticAnswer = null, provider = null, model = null, state, caller, taskId = null, durationMs = 0,
-}: any = {}): { pickId: string; file: string; store: string } | null {
+}      = {})                                                         {
   try {
     if (typeof state !== 'string' || !answer || !question) return null;
     const at = timestamp(now);
@@ -54,7 +54,7 @@ function appendPick({
       : question.type === 'score' ? [...(question.criteria || [])] : ['no', 'yes'];
     const instructions = kind === 'adhoc' && typeof question.instructions === 'string'
       ? question.instructions.slice(0, 500) : null;
-    const line: any = {
+    const line      = {
       schema: 1,
       type: 'pick',
       pickId,
@@ -90,7 +90,7 @@ function appendPick({
   }
 }
 
-function appendMiss({ roots, now = () => new Date(), fsImpl = fs, kind, caller, reason, model = null, durationMs = 0 }: any = {}): any {
+function appendMiss({ roots, now = () => new Date(), fsImpl = fs, kind, caller, reason, model = null, durationMs = 0 }      = {})      {
   try {
     const at = timestamp(now);
     if (!at) return null;
@@ -103,7 +103,7 @@ function appendMiss({ roots, now = () => new Date(), fsImpl = fs, kind, caller,
   } catch { return null; }
 }
 
-function appendOutcome({ roots, now = () => new Date(), fsImpl = fs, pickId, actual, source, store }: any = {}): any {
+function appendOutcome({ roots, now = () => new Date(), fsImpl = fs, pickId, actual, source, store }      = {})      {
   try {
     const at = timestamp(now);
     if (!at) return null;
@@ -112,36 +112,36 @@ function appendOutcome({ roots, now = () => new Date(), fsImpl = fs, pickId, act
   } catch { return null; }
 }
 
-function cutoffDate(now: any, maxAgeDays: number = RETAINED_DAYS): string | null {
+function cutoffDate(now     , maxAgeDays         = RETAINED_DAYS)                {
   const at = timestamp(now);
   if (!at) return null;
   const cutoff = new Date(Date.parse(at) - maxAgeDays * 24 * 60 * 60 * 1000);
   return cutoff.toISOString().slice(0, 10);
 }
 
-function partitionFiles(root: string | undefined, cutoff: string, fsImpl: any): any[] {
+function partitionFiles(root                    , cutoff        , fsImpl     )        {
   if (!root) return [];
   const directory = path.join(root, 'advice', 'picks');
   try {
     return fsImpl.readdirSync(directory)
-      .filter((name: string) => PARTITION_NAME.test(name) && name.slice(0, 10) >= cutoff)
+      .filter((name        ) => PARTITION_NAME.test(name) && name.slice(0, 10) >= cutoff)
       .sort()
-      .map((name: string) => path.join(directory, name));
-  } catch (error: any) {
+      .map((name        ) => path.join(directory, name));
+  } catch (error     ) {
     if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') return [];
     return [{ unreadable: true, file: directory }];
   }
 }
 
-function readWindow({ roots, now = () => new Date(), maxAgeDays = RETAINED_DAYS, fsImpl = fs }: any = {}): { records: any[]; unreadable: number } {
+function readWindow({ roots, now = () => new Date(), maxAgeDays = RETAINED_DAYS, fsImpl = fs }      = {})                                         {
   const cutoff = cutoffDate(now, maxAgeDays);
   if (!cutoff) return { records: [], unreadable: 0 };
-  const records: any[] = [];
+  const records        = [];
   let unreadable = 0;
   for (const store of ['project-state', 'user-state']) {
     for (const item of partitionFiles(roots?.[store], cutoff, fsImpl)) {
       if (typeof item !== 'string') { unreadable += 1; continue; }
-      let contents: string;
+      let contents        ;
       try { contents = fsImpl.readFileSync(item, 'utf8'); } catch { unreadable += 1; continue; }
       for (const line of contents.split(/\r?\n/)) {
         if (!line.trim()) continue;
@@ -156,10 +156,10 @@ function readWindow({ roots, now = () => new Date(), maxAgeDays = RETAINED_DAYS,
   return { records, unreadable };
 }
 
-function findPick({ pickId, roots, now = () => new Date(), fsImpl = fs }: any = {}): any {
+function findPick({ pickId, roots, now = () => new Date(), fsImpl = fs }      = {})      {
   if (typeof pickId !== 'string') return null;
   const window = readWindow({ roots, now, fsImpl });
-  const found = window.records.find((entry: any) => entry.record.type === 'pick' && entry.record.pickId === pickId);
+  const found = window.records.find((entry     ) => entry.record.type === 'pick' && entry.record.pickId === pickId);
   return found ? { pick: found.record, file: found.file, store: found.store } : null;
 }
 

package/src/runtime/advice/{registry.ts → registry.js}

@@ -4,28 +4,28 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
 
 const ADVICE_FILE = 'core/registry/advice.json';
 const MODELS_FILE = 'core/registry/models.json';
 const ADAPTER_DIR = 'src/runtime/advice/providers';
 const TIER_KIND = 'tier';
 const LIMIT_FIELDS = ['maxStateBytes', 'maxBodyBytes', 'minQuestions', 'maxQuestions', 'minOptions', 'maxOptions'];
-const BAND_FIELDS: Record<string, string[]> = {
+const BAND_FIELDS                           = {
   choice: ['clearAt', 'splitWithin'],
   yesno: ['clearAbove', 'clearBelow', 'splitFrom', 'splitTo'],
 };
 
-function isObject(value: any): boolean {
+function isObject(value     )          {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function addError(errors: string[], key: string, message: string): void {
+function addError(errors          , key        , message        )       {
   errors.push(`${key} ${message}`);
 }
 
-function validateAdviceRegistry(registry: any, { repoRoot = REPO_ROOT, models, fsImpl = fs }: any = {}): { ok: boolean; errors: string[] } {
-  const errors: string[] = [];
+function validateAdviceRegistry(registry     , { repoRoot = REPO_ROOT, models, fsImpl = fs }      = {})                                    {
+  const errors           = [];
   if (!isObject(registry)) return { ok: false, errors: ['registry must be an object'] };
 
   if (registry.version !== 1) addError(errors, 'version', 'must be 1');
@@ -80,7 +80,7 @@ function validateAdviceRegistry(registry: any, { repoRoot = REPO_ROOT, models, f
       }
     }
     const yesno = strength.yesno;
-    if (isObject(yesno) && ['clearBelow', 'splitFrom', 'splitTo', 'clearAbove'].every((field: string) => typeof yesno[field] === 'number')) {
+    if (isObject(yesno) && ['clearBelow', 'splitFrom', 'splitTo', 'clearAbove'].every((field        ) => typeof yesno[field] === 'number')) {
       if (!(yesno.clearBelow < yesno.splitFrom && yesno.splitFrom < yesno.splitTo && yesno.splitTo < yesno.clearAbove)) {
         addError(errors, 'strength.yesno', 'bands must satisfy clearBelow < splitFrom < splitTo < clearAbove');
       }
@@ -89,15 +89,15 @@ function validateAdviceRegistry(registry: any, { repoRoot = REPO_ROOT, models, f
 
   if (!models) {
     try { models = JSON.parse(fsImpl.readFileSync(path.join(repoRoot, MODELS_FILE), 'utf8')); }
-    catch (error: any) { addError(errors, MODELS_FILE, `could not be loaded: ${error.message}`); }
+    catch (error     ) { addError(errors, MODELS_FILE, `could not be loaded: ${error.message}`); }
   }
-  const modelProviders = Array.isArray(models?.providers) ? new Set(models.providers.map((provider: any) => provider?.id).filter((id: any) => typeof id === 'string')) : new Set();
+  const modelProviders = Array.isArray(models?.providers) ? new Set(models.providers.map((provider     ) => provider?.id).filter((id     ) => typeof id === 'string')) : new Set();
 
   if (!Array.isArray(registry.providers) || registry.providers.length === 0) {
     addError(errors, 'providers', 'must be a non-empty array');
   } else {
     const adapterRoot = path.resolve(repoRoot, ADAPTER_DIR);
-    registry.providers.forEach((provider: any, index: number) => {
+    registry.providers.forEach((provider     , index        ) => {
       const base = `providers[${index}]`;
       if (!isObject(provider)) { addError(errors, base, 'must be an object'); return; }
       for (const field of ['id', 'adapter', 'modelProvider', 'defaultEndpoint', 'route', 'minVersion', 'capability']) {
@@ -132,17 +132,17 @@ function validateAdviceRegistry(registry: any, { repoRoot = REPO_ROOT, models, f
       if (!['choice', 'yesno'].includes(kind.type)) addError(errors, `${base}.type`, 'must be choice or yesno');
       if (typeof kind.instructions !== 'string' || !kind.instructions.trim()) addError(errors, `${base}.instructions`, 'must be a non-empty string');
       if (Object.hasOwn(kind, 'criteria') === Object.hasOwn(kind, 'criteriaFrom')) addError(errors, base, 'must have exactly one of criteria or criteriaFrom');
-      if (Object.hasOwn(kind, 'criteria') && (!isObject(kind.criteria) || Object.values(kind.criteria).some((value: any) => typeof value !== 'string' || !value.trim()))) {
+      if (Object.hasOwn(kind, 'criteria') && (!isObject(kind.criteria) || Object.values(kind.criteria).some((value     ) => typeof value !== 'string' || !value.trim()))) {
         addError(errors, `${base}.criteria`, 'must map option ids to non-empty descriptions');
       }
       if (Object.hasOwn(kind, 'criteriaFrom') && (typeof kind.criteriaFrom !== 'string' || !kind.criteriaFrom.trim())) {
         addError(errors, `${base}.criteriaFrom`, 'must be a non-empty string');
       }
       if (typeof kind.staticFrom !== 'string') addError(errors, `${base}.staticFrom`, 'must be a string');
-      if (!Array.isArray(kind.askedBy) || kind.askedBy.some((caller: any) => typeof caller !== 'string')) addError(errors, `${base}.askedBy`, 'must be an array of strings');
+      if (!Array.isArray(kind.askedBy) || kind.askedBy.some((caller     ) => typeof caller !== 'string')) addError(errors, `${base}.askedBy`, 'must be an array of strings');
     }
 
-    const tier = registry.kinds.find((kind: any) => kind?.id === TIER_KIND);
+    const tier = registry.kinds.find((kind     ) => kind?.id === TIER_KIND);
     const dispatchTiers = models?.dispatchTiers?.tiers;
     if (!tier || !isObject(tier.criteria) || !Array.isArray(dispatchTiers)
       || JSON.stringify(Object.keys(tier.criteria)) !== JSON.stringify(dispatchTiers)) {
@@ -153,13 +153,13 @@ function validateAdviceRegistry(registry: any, { repoRoot = REPO_ROOT, models, f
   return { ok: errors.length === 0, errors };
 }
 
-function loadAdviceRegistry({ repoRoot = REPO_ROOT, file, fsImpl = fs }: any = {}): { ok: boolean; registry?: any; reason?: string; detail?: string } {
+function loadAdviceRegistry({ repoRoot = REPO_ROOT, file, fsImpl = fs }      = {})                                                                    {
   const root = path.resolve(repoRoot);
   const target = file || path.join(root, ADVICE_FILE);
-  let registry: any;
+  let registry     ;
   try {
     registry = JSON.parse(fsImpl.readFileSync(target, 'utf8'));
-  } catch (error: any) {
+  } catch (error     ) {
     return { ok: false, reason: 'config-invalid', detail: `${target}: ${error.message}` };
   }
   const validation = validateAdviceRegistry(registry, { repoRoot: root, fsImpl });

package/src/runtime/advice/{strength.ts → strength.js}

@@ -2,7 +2,7 @@
 
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
 
-function strengthOf(answer: any, bands: any): { word: string; between: string[] | null } {
+function strengthOf(answer     , bands     )                                             {
   const type = answer?.type;
   const thresholds = bands?.[type] || bands;
   const probabilities = answer?.probabilities;
@@ -11,9 +11,9 @@ function strengthOf(answer: any, bands: any): { word: string; between: string[]
   }
 
   if (type === 'choice') {
-    const ordered: any[] = Object.entries(probabilities)
+    const ordered        = Object.entries(probabilities)
       .filter(([, probability]) => typeof probability === 'number' && Number.isFinite(probability))
-      .sort((left: any, right: any) => right[1] - left[1]);
+      .sort((left     , right     ) => right[1] - left[1]);
     if (!ordered.length) return { word: 'leaning', between: null };
     if (ordered[0][1] >= thresholds.clearAt) return { word: 'clear', between: null };
     if (ordered.length > 1) {
@@ -30,9 +30,9 @@ function strengthOf(answer: any, bands: any): { word: string; between: string[]
     const choice = bands?.choice;
     const criteria = answer.criteria;
     if (!choice || !Array.isArray(criteria)) return { word: 'leaning', between: null };
-    const ordered = criteria.map((criterion: any, index: number) => [criterion, probabilities[String(index)]])
-      .filter(([, probability]: any) => typeof probability === 'number' && Number.isFinite(probability))
-      .sort((left: any, right: any) => right[1] - left[1]);
+    const ordered = criteria.map((criterion     , index        ) => [criterion, probabilities[String(index)]])
+      .filter(([, probability]     ) => typeof probability === 'number' && Number.isFinite(probability))
+      .sort((left     , right     ) => right[1] - left[1]);
     if (!ordered.length) return { word: 'leaning', between: null };
     if (ordered[0][1] >= choice.clearAt) return { word: 'clear', between: null };
     if (ordered.length > 1) {
@@ -56,7 +56,7 @@ function strengthOf(answer: any, bands: any): { word: string; between: string[]
   return { word: 'leaning', between: null };
 }
 
-function strengthWords(strength: any): string {
+function strengthWords(strength     )         {
   if (strength?.word === 'split' && Array.isArray(strength.between) && strength.between.length === 2) {
     return `split between ${strength.between[0]} and ${strength.between[1]}`;
   }

package/src/runtime/{brief-tools.ts → brief-tools.js}

@@ -12,53 +12,53 @@
  * those inputs and prints the block; it writes nothing.
  */
 
-const { REPO_ROOT } = require('../helper/repo-root.ts');
-const { loadRegistry } = require('../registry/index.ts');
-const { CapabilityRouter } = require('./capability-router.ts');
-const { probeProviders, HEALTHY, UNVERIFIED } = require('./health.ts');
-const { mcpReach } = require('./mcp-reach.ts');
-const { WorkflowOrchestrator } = require('./workflow-orchestrator.ts');
-const { resolveActiveFeature } = require('./feature-resolve.ts');
-const { finishRuntime, usageError, captureCaught } = require('./cli-result.ts');
+const { REPO_ROOT } = require('../helper/repo-root.js');
+const { loadRegistry } = require('../registry/index.js');
+const { CapabilityRouter } = require('./capability-router.js');
+const { probeProviders, HEALTHY, UNVERIFIED } = require('./health.js');
+const { mcpReach } = require('./mcp-reach.js');
+const { WorkflowOrchestrator } = require('./workflow-orchestrator.js');
+const { resolveActiveFeature } = require('./feature-resolve.js');
+const { finishRuntime, usageError, captureCaught } = require('./cli-result.js');
 const fs = require('node:fs');
 const path = require('node:path');
-const { loadAdviceRegistry } = require('./advice/registry.ts');
-const { loadStorageRegistry } = require('./storage/registry.ts');
-const { resolveRoots } = require('./storage/roots.ts');
-const { resolveSetting } = require('./advice/config.ts');
-const { materializeKind } = require('./advice/kinds.ts');
-const { createAdviceClient } = require('./advice/client.ts');
-const { strengthWords } = require('./advice/strength.ts');
+const { loadAdviceRegistry } = require('./advice/registry.js');
+const { loadStorageRegistry } = require('./storage/registry.js');
+const { resolveRoots } = require('./storage/roots.js');
+const { resolveSetting } = require('./advice/config.js');
+const { materializeKind } = require('./advice/kinds.js');
+const { createAdviceClient } = require('./advice/client.js');
+const { strengthWords } = require('./advice/strength.js');
 
 const SCHEMA = 1;
 const REACHABLE = new Set(['selected', 'configured']);
 
 /** The state of `server` on a harness: selected or configured on any of its scopes wins; absent
  * only when every scope says so from a complete view (IC-013); else unknown. */
-function stateOn(reach: any, harnessId: any, server: any) {
-  const rows = (reach?.harnesses || []).filter((row: any) => row.id === harnessId);
-  if (rows.some((row: any) => row.servers[server] === 'selected')) return 'selected';
-  if (rows.some((row: any) => row.servers[server] === 'configured')) return 'configured';
-  const states = rows.map((row: any) => row.servers[server] ?? 'unknown');
+function stateOn(reach     , harnessId     , server     ) {
+  const rows = (reach?.harnesses || []).filter((row     ) => row.id === harnessId);
+  if (rows.some((row     ) => row.servers[server] === 'selected')) return 'selected';
+  if (rows.some((row     ) => row.servers[server] === 'configured')) return 'configured';
+  const states = rows.map((row     ) => row.servers[server] ?? 'unknown');
   return states.length && !states.includes('unknown') ? states[0] : 'unknown';
 }
 
 /** Whether `server` is selected or configured on the target harness, or on any harness without one. */
-function hasServer(reach: any, harnessId: any, server: any) {
+function hasServer(reach     , harnessId     , server     ) {
   if (!reach) return false;
-  return harnessId ? REACHABLE.has(stateOn(reach, harnessId, server)) : reach.harnesses.some((row: any) => REACHABLE.has(row.servers[server]));
+  return harnessId ? REACHABLE.has(stateOn(reach, harnessId, server)) : reach.harnesses.some((row     ) => REACHABLE.has(row.servers[server]));
 }
 
 /** The target harness: a registry id named by the caller, else the one harness installed at the
  * project scope (the global scope when the project has none), else none. */
-function chooseTarget({ registry, reach, harness, missing }: any) {
+function chooseTarget({ registry, reach, harness, missing }     ) {
   if (harness) {
-    if (registry.harnesses.some((item: any) => item.id === harness)) return harness;
+    if (registry.harnesses.some((item     ) => item.id === harness)) return harness;
     missing.push(`harness '${harness}' is not a registry harness; ignored`);
   }
   const rows = reach?.harnesses || [];
   for (const scope of ['project', 'global']) {
-    const ids = [...new Set(rows.filter((row: any) => row.scope === scope).map((row: any) => row.id))];
+    const ids = [...new Set(rows.filter((row     ) => row.scope === scope).map((row     ) => row.id))];
     if (ids.length) return ids.length === 1 ? ids[0] : null;
   }
   return null;
@@ -66,7 +66,7 @@ function chooseTarget({ registry, reach, harness, missing }: any) {
 
 /** Tier for a dispatch: the task line's tier when valid, else the owner's, else the default (IC-004).
  * A registry without `dispatchTiers` (the key is optional) gives `standard` with a note. */
-function resolveTier({ dispatchTiers, owner, tier, missing }: any) {
+function resolveTier({ dispatchTiers, owner, tier, missing }     ) {
   if (!dispatchTiers) {
     missing.push('models.json has no dispatchTiers; tier standard assumed');
     return { tier: 'standard', source: 'default', note: 'models.json has no dispatchTiers' };
@@ -81,14 +81,14 @@ function resolveTier({ dispatchTiers, owner, tier, missing }: any) {
 }
 
 /** The first provider of a capability whose probe status is `status`, in registry order, or null. */
-function firstWith(router: any, capabilityId: any, probes: any, status: any) {
-  return (router.capabilities[capabilityId]?.providers || []).find((provider: any) => probes[provider.id]?.status === status) || null;
+function firstWith(router     , capabilityId     , probes     , status     ) {
+  return (router.capabilities[capabilityId]?.providers || []).find((provider     ) => probes[provider.id]?.status === status) || null;
 }
 
 /** What answers one route intent on this machine: a healthy provider of the primary capability,
  * else of the route's fallback capabilities in order; failing those, a provider that has no probe
  * (UNVERIFIED) in the same order; else nothing. An unhealthy provider is never chosen. */
-function resolveRoute(router: any, route: any, probes: any) {
+function resolveRoute(router     , route     , probes     ) {
   const chain = [route.capability, ...(route.fallback || [])];
   for (const status of [HEALTHY, UNVERIFIED]) {
     for (const capability of chain) {
@@ -101,8 +101,8 @@ function resolveRoute(router: any, route: any, probes: any) {
   return { capability: route.capability, provider: null, status: 'NONE', via: null };
 }
 
-const cell = (text: any) => String(text).replace(/\|/g, '\\|').replace(/\s+/g, ' ');
-const trigger = (server: any) => server.trigger.replace(/\.$/, '');
+const cell = (text     ) => String(text).replace(/\|/g, '\\|').replace(/\s+/g, ' ');
+const trigger = (server     ) => server.trigger.replace(/\.$/, '');
 
 /**
  * @param {Object} input
@@ -117,18 +117,18 @@ const trigger = (server: any) => server.trigger.replace(/\.$/, '');
  * @param {{feature:?string, runTaskId:?string, stageId:?string, skill:?string}|null} [input.stage]
  * @returns {{markdown: string, record: Object}} the record is IC-018 without `tasks`
  */
-function renderBriefTools({ registry, router, probes, reach, owner, tier, harness, headingLevel = 2, stage = null }: any) {
-  const missing: any = [];
+function renderBriefTools({ registry, router, probes, reach, owner, tier, harness, headingLevel = 2, stage = null }     ) {
+  const missing      = [];
   const hashes = '#'.repeat(Number(headingLevel) === 3 ? 3 : 2);
   const target = chooseTarget({ registry, reach, harness, missing });
-  const targetHarness = target ? registry.harnesses.find((item: any) => item.id === target) : null;
+  const targetHarness = target ? registry.harnesses.find((item     ) => item.id === target) : null;
   const resolved = resolveTier({ dispatchTiers: registry.dispatchTiers, owner, tier, missing });
   const sourceText = resolved.source === 'owner' ? `owner ${owner}`
     : resolved.source === 'task' ? 'task line' : `default; ${resolved.note || `owner ${owner} has no tier`}`;
 
   const tools = [];
   const rows = [];
-  for (const [intent, route] of Object.entries<any>(router.routes)) {
+  for (const [intent, route] of Object.entries     (router.routes)) {
     const found = resolveRoute(router, route, probes);
     if (!found.provider) {
       rows.push(`| ${cell(intent)} | no healthy provider and no fallback | - |`);
@@ -163,9 +163,9 @@ function renderBriefTools({ registry, router, probes, reach, owner, tier, harnes
 
   const skill = stage?.skill || null;
   const expectedServers = skill
-    ? registry.mcp.filter((server: any) => (server.steps || []).some((step: any) => step.skill === skill && !step.expectedWhen)) : [];
-  const expectedIds = new Set(expectedServers.map((server: any) => server.id));
-  const expected = expectedServers.map((server: any) => {
+    ? registry.mcp.filter((server     ) => (server.steps || []).some((step     ) => step.skill === skill && !step.expectedWhen)) : [];
+  const expectedIds = new Set(expectedServers.map((server     ) => server.id));
+  const expected = expectedServers.map((server     ) => {
     let state;
     if (target) state = stateOn(reach, target, server.id);
     else state = reach ? reach.anyHarnessHas(server.id) ?? 'unknown' : 'unknown';
@@ -173,8 +173,8 @@ function renderBriefTools({ registry, router, probes, reach, owner, tier, harnes
       : (state === true ? 'reachable' : state === false ? 'unreachable' : 'unknown');
     return { server: server.id, reach: reachState, detail: target ? state : `any-harness:${state}` };
   });
-  const also = registry.mcp.filter((server: any) => !expectedIds.has(server.id) && hasServer(reach, target, server.id));
-  const list = (servers: any) => (servers.length ? servers.map((server: any) => `\`${server.id}\` (${trigger(server)})`).join('; ') : 'none');
+  const also = registry.mcp.filter((server     ) => !expectedIds.has(server.id) && hasServer(reach, target, server.id));
+  const list = (servers     ) => (servers.length ? servers.map((server     ) => `\`${server.id}\` (${trigger(server)})`).join('; ') : 'none');
   const targetName = targetHarness ? targetHarness.displayName || targetHarness.id : 'any installed harness';
 
   const lines = [
@@ -218,7 +218,7 @@ function renderBriefTools({ registry, router, probes, reach, owner, tier, harnes
     tierSource: resolved.source,
     harness: target,
     expected,
-    optional: also.map((server: any) => server.id),
+    optional: also.map((server     ) => server.id),
     tools,
     missing,
   };
@@ -226,7 +226,7 @@ function renderBriefTools({ registry, router, probes, reach, owner, tier, harnes
 }
 
 /** The stage a feature's run is at, or null when there is no readable run or it is not at a stage. */
-function currentStageOf({ repoRoot = REPO_ROOT, projectRoot, taskId }: any) {
+function currentStageOf({ repoRoot = REPO_ROOT, projectRoot, taskId }     ) {
   try {
     const run = new WorkflowOrchestrator({ repoRoot, projectRoot }).readRun(taskId);
     const node = run && run.cursor < run.program.length ? run.program[run.cursor] : null;
@@ -235,7 +235,7 @@ function currentStageOf({ repoRoot = REPO_ROOT, projectRoot, taskId }: any) {
 }
 
 /** The feature (`--slug`, else the resolved one) and its current stage, with a note for what is missing. */
-function stageFor({ repoRoot, projectRoot, slug, missing }: any) {
+function stageFor({ repoRoot, projectRoot, slug, missing }     ) {
   let feature = slug || null;
   if (!feature) {
     const resolved = resolveActiveFeature({ projectRoot });
@@ -258,18 +258,18 @@ function stageFor({ repoRoot, projectRoot, slug, missing }: any) {
  * @param {Function} [options.buildAdapters] builds the adapter registry `mcpReach` reads installs through
  * @param {Function} [options.probe] injection seam for `probeProviders`
  */
-function taskLinesForAdvice({ projectRoot, feature, tasks }: any) {
+function taskLinesForAdvice({ projectRoot, feature, tasks }     ) {
   if (!feature || !Array.isArray(tasks) || tasks.length === 0) throw new Error('feature or task ids are unavailable');
   const planPath = path.join(projectRoot, 'agent-docs', 'doflow', feature, 'plan.md');
   const plan = fs.readFileSync(planPath, 'utf8');
   return tasks.map((id) => {
-    const line = plan.split(/\r?\n/).find((candidate: any) => candidate.match(/^- \[[ x]\] (\S+)/)?.[1] === id);
+    const line = plan.split(/\r?\n/).find((candidate     ) => candidate.match(/^- \[[ x]\] (\S+)/)?.[1] === id);
     if (!line) throw new Error(`task '${id}' was not found in ${planPath}`);
     return line;
   });
 }
 
-function adviceRecord(result: any) {
+function adviceRecord(result     ) {
   if (result?.status === 'answered' && result.answers?.[0]) {
     const answer = result.answers[0];
     return {
@@ -285,7 +285,7 @@ function adviceRecord(result: any) {
 /**
  * The tier renderer remains synchronous/pure; optional local advice is requested afterward.
  */
-async function handleBriefToolsCommand({ owner, tier, harness, slug, headingLevel, tasks, json = false, repoRoot = REPO_ROOT, projectRoot = process.cwd(), buildAdapters = null, probe = probeProviders, adviceClient = null }: any = {}) {
+async function handleBriefToolsCommand({ owner, tier, harness, slug, headingLevel, tasks, json = false, repoRoot = REPO_ROOT, projectRoot = process.cwd(), buildAdapters = null, probe = probeProviders, adviceClient = null }      = {}) {
   if (!owner) return usageError('brief-tools', '--owner is required (the agent type the brief is for)', json);
   const level = headingLevel === undefined ? 2 : Number(headingLevel);
   if (level !== 2 && level !== 3) return usageError('brief-tools', `--heading-level must be 2 or 3, got '${headingLevel}'`, json);
@@ -299,7 +299,7 @@ async function handleBriefToolsCommand({ owner, tier, harness, slug, headingLeve
     const stage = stageFor({ repoRoot, projectRoot, slug, missing: notes });
     const rendered = renderBriefTools({ registry, router, probes, reach, owner, tier, harness, headingLevel: level, stage });
     let markdown = rendered.markdown;
-    const record: any = rendered.record;
+    const record      = rendered.record;
     record.missing.push(...notes);
 
     const taskIds = Array.isArray(tasks) ? tasks : typeof tasks === 'string' ? tasks.split(',').filter(Boolean) : [];
@@ -325,14 +325,14 @@ async function handleBriefToolsCommand({ owner, tier, harness, slug, headingLeve
             }
           }
         }
-      } catch (error: any) {
+      } catch (error     ) {
         record.advice = { kind: 'tier', status: 'unavailable', reason: error?.reason || 'config-invalid' };
       }
     }
     if (json) console.log(JSON.stringify({ markdown, record }, null, 2));
     else process.stdout.write(markdown);
     return finishRuntime(0);
-  } catch (error: any) {
+  } catch (error     ) {
     captureCaught(error, 'brief-tools', 1);
     console.error(`[ERROR] brief-tools: ${error.message}`);
     return finishRuntime(1);