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

package/src/runtime/{model-router.ts → model-router.js}

@@ -11,15 +11,15 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { loadRegistry } = require('../registry/index.ts');
-const { finishRuntime, usageError, captureCaught } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { loadRegistry } = require('../registry/index.js');
+const { finishRuntime, usageError, captureCaught } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 /** The machine-level command each provider's backend answers to. A provider without a local CLI
  * (hosted-only access through another harness) reports backendCli null and is never "available". */
-const BACKEND_CLI: Readonly<Record<string, string>> = Object.freeze({ claude: 'claude', codex: 'codex', copilot: 'copilot', ollama: 'ollama' });
+const BACKEND_CLI                                   = Object.freeze({ claude: 'claude', codex: 'codex', copilot: 'copilot', ollama: 'ollama' });
 
-function whichLike(command: string | undefined, { fsImpl = fs, pathEnv = process.env.PATH }: { fsImpl?: any; pathEnv?: string } = {}): boolean {
+function whichLike(command                    , { fsImpl = fs, pathEnv = process.env.PATH }                                     = {})          {
   if (!command) return false;
   for (const dir of String(pathEnv ?? '').split(path.delimiter)) {
     if (!dir) continue;
@@ -33,7 +33,7 @@ function whichLike(command: string | undefined, { fsImpl = fs, pathEnv = process
 }
 
 /** Providers whose backend CLI resolves on PATH. Injectable in tests; never guessed otherwise. */
-function availableProviderIds({ fsImpl = fs }: { fsImpl?: any } = {}): string[] {
+function availableProviderIds({ fsImpl = fs }                   = {})           {
   return Object.entries(BACKEND_CLI)
     .filter(([, cli]) => whichLike(cli, { fsImpl }))
     .map(([id]) => id);
@@ -46,13 +46,13 @@ function availableProviderIds({ fsImpl = fs }: { fsImpl?: any } = {}): string[]
  * review with require:different-family) and is reported back rather than hidden.
  * Availability unknown stays null — absence of evidence is not reported as absent.
  */
-function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [] }: any = {}): any {
-  const role = (registry.modelRoles || []).find((entry: any) => entry.id === roleId);
+function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [] }      = {})      {
+  const role = (registry.modelRoles || []).find((entry     ) => entry.id === roleId);
   if (!role) {
-    throw new Error(`Unknown model role '${roleId}'; valid: ${(registry.modelRoles || []).map((r: any) => r.id).join(', ')}`);
+    throw new Error(`Unknown model role '${roleId}'; valid: ${(registry.modelRoles || []).map((r     ) => r.id).join(', ')}`);
   }
   const excluded = new Set(exclude);
-  const candidates: any[] = [];
+  const candidates        = [];
   for (const [index, provider] of (registry.modelProviders || []).entries()) {
     if (excluded.has(provider.id)) continue;
     const tiers = provider.tiers ?? [];
@@ -67,13 +67,13 @@ function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [] }
       _index: index,
     });
   }
-  const rank = (candidate: any): number[] => [
+  const rank = (candidate     )           => [
     candidate.available === true ? 0 : candidate.available === false ? 1 : 2,
     candidate.servesPreferredTier ? 0 : 1,
     candidate.servesFallbackTier ? 0 : 1,
     candidate._index,
   ];
-  candidates.sort((a: any, b: any) => {
+  candidates.sort((a     , b     ) => {
     const ra = rank(a); const rb = rank(b);
     for (let i = 0; i < ra.length; i += 1) if (ra[i] !== rb[i]) return ra[i] - rb[i];
     return 0;
@@ -98,10 +98,10 @@ function resolveModelRole({ registry, roleId, isAvailable = null, exclude = [] }
  * lexical rather than guess. Unknown slot ids also resolve to `{active:false}` rather than
  * throwing: absence of a slot is every install's normal state, unlike an unknown role.
  */
-function resolveRetrievalSlot({ registry, slotId, isAvailable = null }: any = {}): any {
-  const slot = (registry.retrievalSlots || []).find((entry: any) => entry.id === slotId);
+function resolveRetrievalSlot({ registry, slotId, isAvailable = null }      = {})      {
+  const slot = (registry.retrievalSlots || []).find((entry     ) => entry.id === slotId);
   if (!slot || !slot.enabled) return { slotId, active: false, reason: slot ? 'disabled' : 'undeclared' };
-  const provider = (registry.modelProviders || []).find((entry: any) => entry.id === slot.provider);
+  const provider = (registry.modelProviders || []).find((entry     ) => entry.id === slot.provider);
   if (!provider) return { slotId, active: false, reason: 'provider-missing' };
   return {
     slotId,
@@ -118,11 +118,11 @@ function resolveRetrievalSlot({ registry, slotId, isAvailable = null }: any = {}
 
 /** CLI handler for `doflow model-role`. Read-only advisory routing; exits 1 on an unknown role
  * because a silently-empty candidate list would read as "no providers" rather than "bad input". */
-function handleModelRoleCommand({ role, exclude, json = false, repoRoot }: any = {}): number | undefined {
+function handleModelRoleCommand({ role, exclude, json = false, repoRoot }      = {})                     {
   if (!role) return usageError('model-role', '--role is required (one of the roles in core/registry/models.json)', json);
   const registry = (() => {
     try { return loadRegistry({ repoRoot: repoRoot || REPO_ROOT }); }
-    catch (error: any) { captureCaught(error, 'model-role', 1); console.error(`[ERROR] model-role: ${error.message}`); return finishRuntime(1); }
+    catch (error     ) { captureCaught(error, 'model-role', 1); console.error(`[ERROR] model-role: ${error.message}`); return finishRuntime(1); }
   })();
   if (!registry) return undefined;
   const available = new Set(availableProviderIds());
@@ -130,8 +130,8 @@ function handleModelRoleCommand({ role, exclude, json = false, repoRoot }: any =
     const resolution = resolveModelRole({
       registry,
       roleId: role,
-      isAvailable: (providerId: string) => available.has(providerId),
-      exclude: Array.isArray(exclude) ? exclude : String(exclude ?? '').split(',').map((s: string) => s.trim()).filter(Boolean),
+      isAvailable: (providerId        ) => available.has(providerId),
+      exclude: Array.isArray(exclude) ? exclude : String(exclude ?? '').split(',').map((s        ) => s.trim()).filter(Boolean),
     });
     if (json) console.log(JSON.stringify(resolution, null, 2));
     else {
@@ -143,7 +143,7 @@ function handleModelRoleCommand({ role, exclude, json = false, repoRoot }: any =
       if (resolution.excluded.length) console.log(`Excluded: ${resolution.excluded.join(', ')}`);
     }
     return finishRuntime(0);
-  } catch (error: any) {
+  } catch (error     ) {
     captureCaught(error, 'model-role', 1);
     console.error(`[ERROR] model-role: ${error.message}`);
     return finishRuntime(1);

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

@@ -42,22 +42,22 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { EvidenceLedger, assertSafeTaskId } = require('./evidence-ledger.ts');
-const { taskStoreDir } = require('./task-scope.ts');
+const { EvidenceLedger, assertSafeTaskId } = require('./evidence-ledger.js');
+const { taskStoreDir } = require('./task-scope.js');
 // The two verdict vocabularies, imported from the modules that own them rather than respelled
 // here. A second copy would let this file accept a readiness state readiness itself has retired.
-const { READINESS_STATES } = require('./readiness.ts');
-const { VERIFICATION_STATUSES } = require('./verification/engine.ts');
-const { WorkflowEngine } = require('./workflow-engine.ts');
+const { READINESS_STATES } = require('./readiness.js');
+const { VERIFICATION_STATUSES } = require('./verification/engine.js');
+const { WorkflowEngine } = require('./workflow-engine.js');
 // Read, not re-derived: the retrieval plan's location is `retrieval-plan.ts`'s to define, and the
 // unreached items this record carries forward are the ones that record already holds.
-const { planPath, UNREACHED } = require('./retrieval-plan.ts');
+const { planPath, UNREACHED } = require('./retrieval-plan.js');
 // One definition of the score refusal, applied at a further boundary. See the note on
 // EVIDENCE_SCORE_FIELDS in cli.js: a terminal state that carried a confidence would be exactly the
 // number NFR-001 exists to keep out of the one record the next worker reads first.
-const { assertNoScoreFields } = require('./cli.ts');
-const { finishRuntime, usageError } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { assertNoScoreFields } = require('./evidence-fields.js');
+const { finishRuntime, usageError } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 // ── the closed terminal vocabulary (design §4) ───────────────────────────────────────────────
 
@@ -96,7 +96,7 @@ const NOT_RECORDED = 'NOT_RECORDED';
  * @param {string|null} [slug] the feature the task belongs to, when not the branch's (task-scope.js)
  * @returns {string}
  */
-function outcomePath(projectRoot: any, taskId: any, slug: any = null) {
+function outcomePath(projectRoot     , taskId     , slug      = null) {
   const dir = taskStoreDir({ projectRoot, store: 'outcome', taskId: assertSafeTaskId(taskId), slug });
   return path.join(dir, `${taskId}.json`);
 }
@@ -106,12 +106,12 @@ function outcomePath(projectRoot: any, taskId: any, slug: any = null) {
  * @param {string} taskId
  * @returns {Object|null} the record, or null when no outcome was recorded
  */
-function readOutcome(projectRoot: any, taskId: any, slug: any = null) {
+function readOutcome(projectRoot     , taskId     , slug      = null) {
   const file = outcomePath(projectRoot, taskId, slug);
   if (!fs.existsSync(file)) return null;
   try {
     return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch (error: any) {
+  } catch (error     ) {
     throw new Error(`the outcome record at '${file}' is not readable: ${error.message}`);
   }
 }
@@ -122,7 +122,7 @@ function readOutcome(projectRoot: any, taskId: any, slug: any = null) {
  * @param {Object} record
  * @returns {string} the file written
  */
-function writeOutcome(projectRoot: any, taskId: any, record: any, slug: any = null) {
+function writeOutcome(projectRoot     , taskId     , record     , slug      = null) {
   const file = outcomePath(projectRoot, taskId, slug);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
@@ -142,7 +142,7 @@ function writeOutcome(projectRoot: any, taskId: any, record: any, slug: any = nu
  * @param {string} taskId
  * @returns {number}
  */
-function countEvidence(projectRoot: any, taskId: any, slug: any = null) {
+function countEvidence(projectRoot     , taskId     , slug      = null) {
   const ledger = new EvidenceLedger({ repoRoot: projectRoot, slug });
   ledger.load(taskId);
   return ledger.queryEvidence({ taskId }).length;
@@ -164,14 +164,14 @@ function countEvidence(projectRoot: any, taskId: any, slug: any = null) {
  * @param {string} verification the stated verification verdict, or NOT_RECORDED
  * @returns {Array<string>}
  */
-function unreachedItems(projectRoot: any, taskId: any, verification: any, slug: any = null) {
+function unreachedItems(projectRoot     , taskId     , verification     , slug      = null) {
   const items = [];
   const file = planPath(projectRoot, taskId, slug);
   if (fs.existsSync(file)) {
     let plan;
     try {
       plan = JSON.parse(fs.readFileSync(file, 'utf8'));
-    } catch (error: any) {
+    } catch (error     ) {
       throw new Error(`the retrieval plan at '${file}' is not readable: ${error.message}`);
     }
     for (const need of plan.needs || []) {
@@ -198,7 +198,7 @@ function unreachedItems(projectRoot: any, taskId: any, verification: any, slug:
  * @param {string} flag the flag name, for the refusal
  * @returns {{value: string, stated: boolean}}
  */
-function statedVerdict(value: any, vocabulary: any, flag: any) {
+function statedVerdict(value     , vocabulary     , flag     ) {
   if (value === undefined || value === null || String(value).trim() === '') {
     return { value: NOT_RECORDED, stated: false };
   }
@@ -226,7 +226,7 @@ function statedVerdict(value: any, vocabulary: any, flag: any) {
  *
  * @returns {number} exit code
  */
-function recordOutcome({ projectRoot, packageRoot, taskId, taskClass, stage, state, readiness, verification, json, slug }: any) {
+function recordOutcome({ projectRoot, packageRoot, taskId, taskClass, stage, state, readiness, verification, json, slug }     ) {
   if (state === undefined || state === null || String(state).trim() === '') {
     return usageError('outcome',
       `--action record needs --state <state>. Valid: ${OUTCOME_STATES.join(', ')}`, json);
@@ -249,7 +249,7 @@ function recordOutcome({ projectRoot, packageRoot, taskId, taskClass, stage, sta
   let workflow;
   try {
     workflow = new WorkflowEngine({ repoRoot: packageRoot }).resolveWorkflow(taskClass);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('outcome', error.message, json, error);
   }
   const terminalStage = workflow.terminalStage;
@@ -266,7 +266,7 @@ function recordOutcome({ projectRoot, packageRoot, taskId, taskClass, stage, sta
   try {
     basisReadiness = statedVerdict(readiness, READINESS_STATES, '--readiness');
     basisVerification = statedVerdict(verification, VERIFICATION_STATUSES, '--verification');
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('outcome', error.message, json, error);
   }
 
@@ -275,7 +275,7 @@ function recordOutcome({ projectRoot, packageRoot, taskId, taskClass, stage, sta
   try {
     evidenceCount = countEvidence(projectRoot, taskId, slug);
     unreached = unreachedItems(projectRoot, taskId, basisVerification.value, slug);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('outcome', error.message, json, error);
   }
 
@@ -331,11 +331,11 @@ function recordOutcome({ projectRoot, packageRoot, taskId, taskClass, stage, sta
  *
  * @returns {number} exit code
  */
-function showOutcome({ projectRoot, taskId, json, slug }: any) {
+function showOutcome({ projectRoot, taskId, json, slug }     ) {
   let record;
   try {
     record = readOutcome(projectRoot, taskId, slug);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('outcome', error.message, json, error);
   }
   if (!record) {
@@ -365,7 +365,7 @@ function showOutcome({ projectRoot, taskId, json, slug }: any) {
 }
 
 /** The one text rendering both actions print, so a shown record reads exactly as the written one. */
-function printOutcome(record: any, file: any, verb: any) {
+function printOutcome(record     , file     , verb     ) {
   const basis = record.basis || {};
   console.log(`\nDoFlow Task Outcome [Task: ${record.taskId}] — ${record.state}:`);
   console.log('═'.repeat(78));
@@ -413,7 +413,7 @@ function printOutcome(record: any, file: any, verb: any) {
  * @param {string} [options.stateRoot] the project the task belongs to, holding its state
  * @returns {number} exit code
  */
-function handleOutcomeCommand(options: any = {}) {
+function handleOutcomeCommand(options      = {}) {
   const {
     taskId, action = 'show', state, taskClass, stage, readiness, verification,
     json = false, repoRoot, stateRoot, slug,
@@ -424,7 +424,7 @@ function handleOutcomeCommand(options: any = {}) {
   // option object, so a second input surface cannot arrive later without inheriting the refusal.
   try {
     assertNoScoreFields(options, '');
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('outcome', error.message, json, error);
   }
 
@@ -443,7 +443,7 @@ function handleOutcomeCommand(options: any = {}) {
 
   try {
     assertSafeTaskId(taskId);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('outcome', error.message, json, error);
   }
 

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

@@ -15,7 +15,7 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { readLedger, stateRoot } = require('../state/index.ts');
+const { readLedger, stateRoot } = require('../state/index.js');
 
 /** Where the dispatcher sits under a `.doflow` root; the skill resolver and the locator shim spell the same path. */
 const REACH_DISPATCHER_REL = 'scripts/doflow/bin/doflow-run';
@@ -23,18 +23,18 @@ const REACH_DISPATCHER_REL = 'scripts/doflow/bin/doflow-run';
 const REACH_RUNTIME_REL = 'runtime/bin/doflow.js';
 
 /** `dir`, then each parent, ending when the parent is the directory itself (`/`, `C:\`). */
-function* ancestors(dir: string): Generator<string> {
+function* ancestors(dir        )                    {
   for (let current = dir; ; current = path.dirname(current)) {
     yield current;
     if (path.dirname(current) === current) return;
   }
 }
 
-function statIs(fsImpl: any, target: string, kind: string): boolean {
+function statIs(fsImpl     , target        , kind        )          {
   try { return fsImpl.statSync(target)[kind](); } catch { return false; }
 }
 
-function isExecutableFile(fsImpl: any, target: string): boolean {
+function isExecutableFile(fsImpl     , target        )          {
   if (!statIs(fsImpl, target, 'isFile')) return false;
   try { fsImpl.accessSync(target, fs.constants.X_OK); return true; } catch { return false; }
 }
@@ -47,8 +47,8 @@ function isExecutableFile(fsImpl: any, target: string): boolean {
  * @param {Object} [options.fsImpl]
  * @returns {{rows: Array<{harness: string, scope: 'project'|'global', installRoot: string, state: 'REACHED'|'NO-REACH'|'N/A', root?: string, reason?: string, fix?: string}>, unreadable: Array<{scope: string, ledger: string, detail: string}>}}
  */
-function evaluateReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs }: { registry: any; projectRoot: string; homeDir?: string; fsImpl?: any }): { rows: any[]; unreadable: any[] } {
-  const real = (target: string): string => { try { return fsImpl.realpathSync(target); } catch { return path.resolve(target); } };
+function evaluateReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl = fs }                                                                        )                                     {
+  const real = (target        )         => { try { return fsImpl.realpathSync(target); } catch { return path.resolve(target); } };
   const start = real(projectRoot);
   const home = real(homeDir);
   const homeDoflow = path.join(home, '.doflow');
@@ -57,14 +57,14 @@ function evaluateReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl =
   // Every ledger on the walk is read, not only the nearest: a removed harness's residue in a
   // subdirectory must not hide the install that encloses it. The walk stops at the home directory,
   // whose own ledger is the global scope; nothing above it is read.
-  const scopes: any[] = [];
+  const scopes        = [];
   if (start !== home) {
-    const walk: string[] = [];
+    const walk           = [];
     for (const dir of ancestors(start)) {
       if (dir === home) break;
       walk.push(dir);
     }
-    for (const installRoot of walk.filter((dir: string) => statIs(fsImpl, path.join(dir, '.doflow', 'state'), 'isDirectory'))) {
+    for (const installRoot of walk.filter((dir        ) => statIs(fsImpl, path.join(dir, '.doflow', 'state'), 'isDirectory'))) {
       scopes.push({
         scope: 'project',
         installRoot,
@@ -72,7 +72,7 @@ function evaluateReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl =
         from: start,
         searched: `${path.join(start, '.doflow', REACH_DISPATCHER_REL)} and each directory above it, then ${homeDispatcher}`,
         doflowDirs: [...ancestors(start)].map((dir) => path.join(dir, '.doflow')).concat(homeDoflow),
-        fix: (harness: string) => `npx @khoavu882/doflow install ${installRoot} -t ${harness}`,
+        fix: (harness        ) => `npx @khoavu882/doflow install ${installRoot} -t ${harness}`,
       });
     }
   }
@@ -83,14 +83,14 @@ function evaluateReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl =
     from: home,
     searched: homeDispatcher,
     doflowDirs: [homeDoflow],
-    fix: (harness: string) => `npx @khoavu882/doflow install -g -t ${harness}`,
+    fix: (harness        ) => `npx @khoavu882/doflow install -g -t ${harness}`,
   });
 
-  const harnessIds = registry.harnesses.map((harness: any) => harness.id);
-  const rows: any[] = [];
-  const unreadable: any[] = [];
-  const seen = new Set<string>();
-  const addRow = (row: any): void => {
+  const harnessIds = registry.harnesses.map((harness     ) => harness.id);
+  const rows        = [];
+  const unreadable        = [];
+  const seen = new Set        ();
+  const addRow = (row     )       => {
     // A stale outer ledger that says what a nearer one already said adds nothing.
     const key = JSON.stringify([row.harness, row.scope, row.state, row.root, row.reason]);
     if (seen.has(key)) return;
@@ -99,20 +99,20 @@ function evaluateReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl =
   };
 
   for (const { scope, installRoot, stateDir, from, searched, doflowDirs, fix } of scopes) {
-    let ledger: any;
+    let ledger     ;
     try {
       ledger = readLedger(stateDir, { fsImpl });
-    } catch (error: any) {
+    } catch (error     ) {
       unreadable.push({ scope, ledger: stateDir, detail: error.message });
       continue;
     }
     if (!ledger) continue;
 
     const resources = ledger.resources || [];
-    const installed = harnessIds.filter((id: string) => resources.some((resource: any) => resource.harness === id));
+    const installed = harnessIds.filter((id        ) => resources.some((resource     ) => resource.harness === id));
     if (!installed.length) continue;
 
-    const root = doflowDirs.find((dir: string) => isExecutableFile(fsImpl, path.join(dir, REACH_DISPATCHER_REL)));
+    const root = doflowDirs.find((dir        ) => isExecutableFile(fsImpl, path.join(dir, REACH_DISPATCHER_REL)));
     const dispatcher = root && path.join(root, REACH_DISPATCHER_REL);
     const configDir = [...ancestors(from)].map((dir) => path.join(dir, '.doflow')).find((dir) => statIs(fsImpl, dir, 'isDirectory'));
     const runtime = [configDir, homeDoflow].filter(Boolean).some((dir) => statIs(fsImpl, path.join(dir, REACH_RUNTIME_REL), 'isFile'));
@@ -121,7 +121,7 @@ function evaluateReach({ registry, projectRoot, homeDir = os.homedir(), fsImpl =
     const hiddenBy = scope === 'project' && configDir && configDir !== path.join(installRoot, '.doflow') ? configDir : null;
 
     for (const harness of installed) {
-      if (!resources.some((resource: any) => resource.harness === harness && resource.assetId === 'skills.doflow')) {
+      if (!resources.some((resource     ) => resource.harness === harness && resource.assetId === 'skills.doflow')) {
         addRow({ harness, scope, installRoot, state: 'N/A', reason: `no skills at ${scope} scope` });
       } else if (dispatcher && runtime) {
         addRow({ harness, scope, installRoot, state: 'REACHED', root });

package/src/runtime/{readiness-record.ts → readiness-record.js}

@@ -4,9 +4,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { updateTaskState } = require('./task-state.ts');
-const { resolveTaskScope } = require('./task-scope.ts');
-const { findStateFile } = require('./checkouts.ts');
+const { updateTaskState } = require('./task-state.js');
+const { resolveTaskScope } = require('./task-scope.js');
+const { findStateFile } = require('./checkouts.js');
 
 // The readiness record: the latest evaluation of one task, kept where `readiness` ran.
 //
@@ -26,19 +26,19 @@ const STORE = path.join('.doflow', 'state', 'readiness');
  * @param {string|null} slug the task's feature slug, when one is known
  * @returns {Array<string>} paths relative to a checkout root
  */
-function recordCandidates(taskId: string, slug: any) {
+function recordCandidates(taskId        , slug     ) {
   const flat = path.join(STORE, `${taskId}.json`);
   return slug && slug !== taskId ? [path.join(STORE, slug, `${taskId}.json`), flat] : [flat];
 }
 
 /** A record version this runtime cannot read because a newer DoFlow wrote it, else null. */
-function newerVersionOf(record: any) {
+function newerVersionOf(record     ) {
   const v = record && typeof record === 'object' ? record.version : undefined;
   return Number.isInteger(v) && v > RECORD_VERSION ? v : null;
 }
 
 /** The refusal for a record a newer DoFlow wrote: it names the file and is never overwritten. */
-function newerRecordText(file: any, version: any) {
+function newerRecordText(file     , version     ) {
   return `the readiness record ${file} was written by a newer DoFlow (record version ${version}; this runtime reads ${RECORD_VERSION}), `
     + 'so it was left as it is. Run this command with the DoFlow that wrote the record, or upgrade DoFlow here.';
 }
@@ -48,11 +48,11 @@ function newerRecordText(file: any, version: any) {
  * wrote, or bytes no evaluation can be read from.
  * @returns {{kind: 'none'|'record'|'newer'|'unreadable', version?: number}}
  */
-function priorRecord(file: any, fsImpl: any) {
+function priorRecord(file     , fsImpl     ) {
   let text;
   try {
     text = fsImpl.readFileSync(file, 'utf8');
-  } catch (error: any) {
+  } catch (error     ) {
     if (error.code === 'ENOENT') return { kind: 'none' };
     throw error;
   }
@@ -86,7 +86,7 @@ function priorRecord(file: any, fsImpl: any) {
  * @returns {{file: string, record: Object, replacedUnreadable: string|null}} the `.unreadable` path when
  *   a previous file was set aside
  */
-function writeReadinessRecord({ stateRoot, taskId, slug = null, report, inputs, declaredScope = null, mode, now = new Date(), fsImpl = fs }: any) {
+function writeReadinessRecord({ stateRoot, taskId, slug = null, report, inputs, declaredScope = null, mode, now = new Date(), fsImpl = fs }     ) {
   const scope = resolveTaskScope({ projectRoot: stateRoot, taskId, slug });
   const recordSlug = scope.slug || slug || null;
   // The record a reader would find in this checkout is the one replaced; with none, the record goes
@@ -104,7 +104,7 @@ function writeReadinessRecord({ stateRoot, taskId, slug = null, report, inputs,
     executionMode: mode,
     inputs: { ...inputs },
     declaredScope: Array.isArray(declaredScope) ? [...declaredScope] : null,
-    unmet: (report.requirements || []).filter((r: any) => r.required && !r.satisfied).map((r: any) => r.id),
+    unmet: (report.requirements || []).filter((r     ) => r.required && !r.satisfied).map((r     ) => r.id),
     evidenceCount: Number.isInteger(report.evidenceCount) ? report.evidenceCount : 0,
     evaluatedAt: now.toISOString(),
   };
@@ -136,13 +136,13 @@ function writeReadinessRecord({ stateRoot, taskId, slug = null, report, inputs,
  * @returns {{status: 'found'|'missing'|'ambiguous'|'unreadable', record: Object|null, file: string|null,
  *   origin: 'current'|'other'|null, candidates: Array<string>, detail: string|null}}
  */
-function readReadinessRecord({ stateRoot, taskId, slug = null, exec, fsImpl = fs }: any) {
+function readReadinessRecord({ stateRoot, taskId, slug = null, exec, fsImpl = fs }     ) {
   const found = findStateFile({ stateRoot, relPath: recordCandidates(taskId, slug), ...(exec ? { exec } : {}), fsImpl });
   const base = { record: null, file: found.file, origin: found.origin, candidates: found.candidates, detail: null };
   if (found.status !== 'found') return { ...base, status: found.status };
   try {
     return { ...base, status: 'found', record: JSON.parse(fsImpl.readFileSync(found.file, 'utf8')) };
-  } catch (error: any) {
+  } catch (error     ) {
     return { ...base, status: 'unreadable', detail: `unparsable JSON: ${error.message}` };
   }
 }