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

package/src/runtime/{task-attempts.ts → task-attempts.js}

@@ -22,11 +22,11 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { updateTaskState, readTaskState } = require('./task-state.ts');
-const { parsePlan } = require('./scaffold/artifacts.ts');
-const { EvidenceLedger } = require('./evidence-ledger.ts');
-const { projectRoot: lifecycleProjectRoot } = require('./lifecycle/root.ts');
-const { isSafeSlug } = require('./task-scope.ts');
+const { updateTaskState, readTaskState } = require('./task-state.js');
+const { parsePlan } = require('./scaffold/artifacts.js');
+const { EvidenceLedger } = require('./evidence-ledger.js');
+const { projectRoot: lifecycleProjectRoot } = require('./lifecycle/root.js');
+const { isSafeSlug } = require('./task-scope.js');
 
 const SCHEMA_VERSION = 1;
 const MODES = Object.freeze(['manual', 'sequential', 'subagent']);
@@ -37,8 +37,8 @@ const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._ -]*$/;
 
 /** A failure that is the caller's or the environment's, not a finding: exit 2. */
 class TaskAttemptError extends Error {
-  declare code: any;
-  constructor(code: any, message: any) {
+                    
+  constructor(code     , message     ) {
     super(message);
     this.name = 'TaskAttemptError';
     this.code = code;
@@ -48,13 +48,13 @@ class TaskAttemptError extends Error {
 /** Thrown inside the locked build to abandon a write without touching the store. */
 class NoWrite extends Error {}
 
-function storeFile(root: any, slug: any) {
+function storeFile(root     , slug     ) {
   return path.join(root, '.doflow', 'state', 'task-attempts', `${slug}.json`);
 }
 
-function uniq(values: any) { return [...new Set(values)]; }
+function uniq(values     ) { return [...new Set(values)]; }
 
-function assertSlug(slug: any) {
+function assertSlug(slug     ) {
   if (!isSafeSlug(slug)) throw new TaskAttemptError('usage', `'${slug}' is not a valid feature slug`);
   return slug;
 }
@@ -63,7 +63,7 @@ function assertSlug(slug: any) {
 
 /** The hash a claim records and `finish` compares: everything about the task's plan line except
  * its checkbox, so ticking the box after a finish is not an edit of the task. */
-function taskLineHash(task: any) {
+function taskLineHash(task     ) {
   const material = JSON.stringify([
     task.id, task.description, task.stories, task.owner, task.files, task.dependsOn, task.externalContract,
   ]);
@@ -74,27 +74,27 @@ function taskLineHash(task: any) {
  * The plan's tasks, in plan order, with phase order taken from first appearance.
  * @returns {{planPath: string, tasks: Array<{id: string, phase: string, phaseIndex: number, checked: boolean, hash: string}>}}
  */
-function loadPlan({ roots, slug, fsImpl = fs }: any) {
+function loadPlan({ roots, slug, fsImpl = fs }     ) {
   const relative = path.join('agent-docs', 'doflow', slug, 'plan.md');
-  const found = roots.map((root: any) => path.join(root, relative)).find((file: any) => fsImpl.existsSync(file));
+  const found = roots.map((root     ) => path.join(root, relative)).find((file     ) => fsImpl.existsSync(file));
   if (!found) throw new TaskAttemptError('plan-unreadable', `no plan.md for feature '${slug}' (looked for ${relative} under ${roots.join(', ')})`);
   let text;
-  try { text = fsImpl.readFileSync(found, 'utf8'); } catch (error: any) {
+  try { text = fsImpl.readFileSync(found, 'utf8'); } catch (error     ) {
     throw new TaskAttemptError('plan-unreadable', `cannot read ${found}: ${error.message}`);
   }
   const parsed = parsePlan(text);
   if (parsed.tasks.length === 0) {
-    throw new TaskAttemptError('plan-malformed', `${found} holds no \`- [ ] <phase>.<n>\` tasks: ${parsed.gaps.map((g: any) => g.why).join('; ') || 'nothing to track'}`);
+    throw new TaskAttemptError('plan-malformed', `${found} holds no \`- [ ] <phase>.<n>\` tasks: ${parsed.gaps.map((g     ) => g.why).join('; ') || 'nothing to track'}`);
   }
   const seen = new Set();
   for (const task of parsed.tasks) {
     if (seen.has(task.id)) throw new TaskAttemptError('plan-malformed', `plan task id '${task.id}' appears more than once in ${found}`);
     seen.add(task.id);
   }
-  const phases = uniq(parsed.tasks.map((t: any) => t.phase));
+  const phases = uniq(parsed.tasks.map((t     ) => t.phase));
   return {
     planPath: relative.split(path.sep).join('/'),
-    tasks: parsed.tasks.map((t: any) => ({
+    tasks: parsed.tasks.map((t     ) => ({
       id: t.id, phase: t.phase, phaseIndex: phases.indexOf(t.phase), checked: t.done, hash: taskLineHash(t),
     })),
   };
@@ -102,19 +102,19 @@ function loadPlan({ roots, slug, fsImpl = fs }: any) {
 
 // ── store ──────────────────────────────────────────────────────────────────────────────────────
 
-function unreadable(file: any, why: any) {
+function unreadable(file     , why     ) {
   return new TaskAttemptError('store-unreadable', `${why} Refusing to read or write '${file}'; it was left unchanged.`);
 }
 
 /** The store as an object, or a fresh empty one when the file does not exist. Shape-checked: a file
  * that parses but is not a ledger is as unusable as one that does not parse. */
-function normalizeStore(data: any, file: any) {
+function normalizeStore(data     , file     ) {
   if (data === null || data === undefined) return { version: SCHEMA_VERSION, revision: 0, planPath: null, tasks: {} };
   if (typeof data !== 'object' || Array.isArray(data) || data.version !== SCHEMA_VERSION
     || typeof data.tasks !== 'object' || data.tasks === null || Array.isArray(data.tasks)) {
     throw unreadable(file, 'It is not a version-1 task-attempt ledger.');
   }
-  for (const [id, entry] of (Object.entries(data.tasks) as [string, any][])) {
+  for (const [id, entry] of (Object.entries(data.tasks)                   )) {
     if (!entry || !Number.isInteger(entry.nextToken) || !Array.isArray(entry.attempts)) {
       throw unreadable(file, `Task '${id}' has no readable attempt list.`);
     }
@@ -122,10 +122,10 @@ function normalizeStore(data: any, file: any) {
   return data;
 }
 
-function readStore(file: any, fsImpl: any) {
+function readStore(file     , fsImpl     ) {
   try {
     return normalizeStore(readTaskState(fsImpl, file), file);
-  } catch (error: any) {
+  } catch (error     ) {
     if (error instanceof TaskAttemptError) throw error;
     throw unreadable(file, error.message);
   }
@@ -133,12 +133,12 @@ function readStore(file: any, fsImpl: any) {
 
 /** One locked read-decide-write. `apply(store)` returns `{result, write}`; with `write` false the
  * store is not touched, which is how a refusal or a stale token changes nothing. */
-function mutate({ file, fsImpl, apply }: any) {
-  let outcome: any = null;
+function mutate({ file, fsImpl, apply }     ) {
+  let outcome      = null;
   try {
     updateTaskState({
       fsImpl, file,
-      build: (disk: any) => {
+      build: (disk     ) => {
         const store = normalizeStore(disk, file);
         store.revision = (Number.isInteger(store.revision) ? store.revision : 0) + 1;
         outcome = apply(store);
@@ -146,7 +146,7 @@ function mutate({ file, fsImpl, apply }: any) {
         return store;
       },
     });
-  } catch (error: any) {
+  } catch (error     ) {
     if (error instanceof NoWrite) return outcome.result;
     if (error instanceof TaskAttemptError) throw error;
     throw unreadable(file, error.message);
@@ -154,24 +154,24 @@ function mutate({ file, fsImpl, apply }: any) {
   return outcome.result;
 }
 
-function entryFor(store: any, taskId: any) {
+function entryFor(store     , taskId     ) {
   if (!store.tasks[taskId]) store.tasks[taskId] = { nextToken: 1, attempts: [] };
   return store.tasks[taskId];
 }
 
-const activeAttempt = (entry: any) => (entry ? entry.attempts.find((a: any) => a.state === 'active') || null : null);
-const doneAttempt = (entry: any) => (entry ? entry.attempts.find((a: any) => a.state === 'finished' && a.result === 'COMPLETED') || null : null);
+const activeAttempt = (entry     ) => (entry ? entry.attempts.find((a     ) => a.state === 'active') || null : null);
+const doneAttempt = (entry     ) => (entry ? entry.attempts.find((a     ) => a.state === 'finished' && a.result === 'COMPLETED') || null : null);
 
-function latestFinished(entry: any) {
-  const finished = entry ? entry.attempts.filter((a: any) => a.state === 'finished') : [];
-  return finished.length ? finished.reduce((a: any, b: any) => (b.token > a.token ? b : a)) : null;
+function latestFinished(entry     ) {
+  const finished = entry ? entry.attempts.filter((a     ) => a.state === 'finished') : [];
+  return finished.length ? finished.reduce((a     , b     ) => (b.token > a.token ? b : a)) : null;
 }
 
 // ── evidence ───────────────────────────────────────────────────────────────────────────────────
 
 /** Evidence ids recorded in any task file under the evidence store, to tell "belongs to another task"
  * from "does not exist". Reads only; a file that cannot be read simply does not match. */
-function evidenceBelongsElsewhere({ roots, slug, evidenceId, fsImpl }: any) {
+function evidenceBelongsElsewhere({ roots, slug, evidenceId, fsImpl }     ) {
   for (const root of roots) {
     const base = path.join(root, '.doflow', 'state', 'evidence');
     for (const dir of [base, path.join(base, slug)]) {
@@ -181,7 +181,7 @@ function evidenceBelongsElsewhere({ roots, slug, evidenceId, fsImpl }: any) {
         if (!name.endsWith('.json')) continue;
         try {
           const data = JSON.parse(fsImpl.readFileSync(path.join(dir, name), 'utf8'));
-          if (Array.isArray(data.evidence) && data.evidence.some((item: any) => item && item.id === evidenceId)) return true;
+          if (Array.isArray(data.evidence) && data.evidence.some((item     ) => item && item.id === evidenceId)) return true;
         } catch { /* unreadable files do not match */ }
       }
     }
@@ -190,7 +190,7 @@ function evidenceBelongsElsewhere({ roots, slug, evidenceId, fsImpl }: any) {
 }
 
 /** The refusal reason for `evidenceId` as proof of a COMPLETED attempt, or null when it qualifies (FR-004). */
-function evidenceRefusal({ evidenceId, slug, taskId, startedAt, roots, fsImpl }: any) {
+function evidenceRefusal({ evidenceId, slug, taskId, startedAt, roots, fsImpl }     ) {
   if (!evidenceId) return 'evidence-required';
   const allowed = [slug, taskId];
   let item = null;
@@ -216,25 +216,25 @@ function evidenceRefusal({ evidenceId, slug, taskId, startedAt, roots, fsImpl }:
 
 // ── actions ────────────────────────────────────────────────────────────────────────────────────
 
-function rootsFor({ cwd, lifecycleRoot }: any) {
+function rootsFor({ cwd, lifecycleRoot }     ) {
   return uniq([path.resolve(cwd), lifecycleRoot]);
 }
 
-function claim({ file, fsImpl, roots, slug, task, owner, mode, now = new Date() }: any) {
+function claim({ file, fsImpl, roots, slug, task, owner, mode, now = new Date() }     ) {
   if (!TASK_ID.test(task || '')) throw new TaskAttemptError('usage', '--task is required: a plan task id such as A.1');
   if (!owner || !SAFE_NAME.test(owner)) throw new TaskAttemptError('usage', '--owner is required: the name of the agent or person taking the task');
   if (!MODES.includes(mode)) throw new TaskAttemptError('usage', `--mode is required: one of ${MODES.join(', ')}`);
   const plan = loadPlan({ roots, slug, fsImpl });
   return mutate({
     file, fsImpl,
-    apply: (store: any) => {
-      const refuse = (reason: any, extra: any = {}) => ({ write: false, result: { disposition: 'refused', taskId: task, reason, ...extra } });
-      const target = plan.tasks.find((t: any) => t.id === task);
+    apply: (store     ) => {
+      const refuse = (reason     , extra      = {}) => ({ write: false, result: { disposition: 'refused', taskId: task, reason, ...extra } });
+      const target = plan.tasks.find((t     ) => t.id === task);
       if (!target) return refuse('unknown-task');
       if (doneAttempt(store.tasks[task])) return refuse('already-done');
       const active = activeAttempt(store.tasks[task]);
       if (active) return refuse('active-attempt', { activeToken: active.token, owner: active.owner, startedAt: active.startedAt });
-      const unmet = plan.tasks.filter((t: any) => t.phaseIndex < target.phaseIndex && !doneAttempt(store.tasks[t.id])).map((t: any) => t.id);
+      const unmet = plan.tasks.filter((t     ) => t.phaseIndex < target.phaseIndex && !doneAttempt(store.tasks[t.id])).map((t     ) => t.id);
       if (unmet.length) return refuse('unmet-phase', { unmet });
       const entry = entryFor(store, task);
       const token = entry.nextToken;
@@ -249,23 +249,23 @@ function claim({ file, fsImpl, roots, slug, task, owner, mode, now = new Date()
   });
 }
 
-function stale(taskId: any, token: any, reason: any) {
+function stale(taskId     , token     , reason     ) {
   return { write: false, result: { disposition: 'stale', taskId, token, reason } };
 }
 
-function finish({ file, fsImpl, roots, slug, task, token, result, evidenceId }: any) {
+function finish({ file, fsImpl, roots, slug, task, token, result, evidenceId }     ) {
   if (!TASK_ID.test(task || '')) throw new TaskAttemptError('usage', '--task is required: a plan task id such as A.1');
   if (!Number.isInteger(token) || token < 1) throw new TaskAttemptError('usage', '--token is required: the token claim returned');
   if (!RESULTS.includes(result)) throw new TaskAttemptError('usage', `--result is required: one of ${RESULTS.join(', ')}`);
   return mutate({
     file, fsImpl,
-    apply: (store: any) => {
+    apply: (store     ) => {
       const active = activeAttempt(store.tasks[task]);
       if (!active) return stale(task, token, 'no-active-attempt');
       if (active.token !== token) return stale(task, token, 'token-mismatch');
-      const refuse = (reason: any) => ({ write: false, result: { disposition: 'refused', taskId: task, token, reason } });
+      const refuse = (reason     ) => ({ write: false, result: { disposition: 'refused', taskId: task, token, reason } });
       const plan = loadPlan({ roots, slug, fsImpl });
-      const line = plan.tasks.find((t: any) => t.id === task);
+      const line = plan.tasks.find((t     ) => t.id === task);
       if (!line) return refuse('unknown-task');
       if (line.hash !== active.taskLineHash) return refuse('plan-changed');
       if (result === 'COMPLETED') {
@@ -280,13 +280,13 @@ function finish({ file, fsImpl, roots, slug, task, token, result, evidenceId }:
   });
 }
 
-function release({ file, fsImpl, task, token, reason }: any) {
+function release({ file, fsImpl, task, token, reason }     ) {
   if (!TASK_ID.test(task || '')) throw new TaskAttemptError('usage', '--task is required: a plan task id such as A.1');
   if (!Number.isInteger(token) || token < 1) throw new TaskAttemptError('usage', '--token is required: the token claim returned');
   if (!reason || !String(reason).trim()) throw new TaskAttemptError('usage', '--reason is required: why the attempt is being released');
   return mutate({
     file, fsImpl,
-    apply: (store: any) => {
+    apply: (store     ) => {
       const active = activeAttempt(store.tasks[task]);
       if (!active) return stale(task, token, 'no-active-attempt');
       if (active.token !== token) return stale(task, token, 'token-mismatch');
@@ -298,10 +298,10 @@ function release({ file, fsImpl, task, token, reason }: any) {
 }
 
 /** Completion read from the ledger and the plan, never from checkboxes (FR-005). */
-function status({ file, fsImpl, roots, slug }: any) {
+function status({ file, fsImpl, roots, slug }     ) {
   const plan = loadPlan({ roots, slug, fsImpl });
   const store = readStore(file, fsImpl);
-  const tasks = plan.tasks.map((t: any) => {
+  const tasks = plan.tasks.map((t     ) => {
     const entry = store.tasks[t.id];
     const active = activeAttempt(entry);
     const done = doneAttempt(entry);
@@ -310,7 +310,7 @@ function status({ file, fsImpl, roots, slug }: any) {
     if (done) derived = 'done';
     else if (active) derived = 'running';
     else if (last && last.result === 'BLOCKED') derived = 'blocked';
-    else if (plan.tasks.every((o: any) => o.phaseIndex >= t.phaseIndex || doneAttempt(store.tasks[o.id]))) derived = 'ready';
+    else if (plan.tasks.every((o     ) => o.phaseIndex >= t.phaseIndex || doneAttempt(store.tasks[o.id]))) derived = 'ready';
     else derived = 'pending';
     return {
       id: t.id, phase: t.phase, derived,
@@ -320,10 +320,10 @@ function status({ file, fsImpl, roots, slug }: any) {
     };
   });
   return {
-    complete: tasks.length > 0 && tasks.every((t: any) => t.derived === 'done'),
+    complete: tasks.length > 0 && tasks.every((t     ) => t.derived === 'done'),
     revision: store.revision,
     tasks,
-    unclaimedChecked: plan.tasks.filter((t: any) => t.checked && !doneAttempt(store.tasks[t.id])).map((t: any) => t.id),
+    unclaimedChecked: plan.tasks.filter((t     ) => t.checked && !doneAttempt(store.tasks[t.id])).map((t     ) => t.id),
   };
 }
 
@@ -333,26 +333,26 @@ function status({ file, fsImpl, roots, slug }: any) {
  * otherwise. A store or plan that cannot be read throws, so the gate refuses rather than guessing.
  * @returns {{state: 'none'|'complete'|'incomplete', slug: string|null, incomplete: Array<string>}}
  */
-function checkCompletion({ slug, cwd, fsImpl = fs }: any) {
+function checkCompletion({ slug, cwd, fsImpl = fs }     ) {
   if (!isSafeSlug(slug)) return { state: 'none', slug: null, incomplete: [] };
   const lifecycleRoot = lifecycleProjectRoot(cwd);
   const file = storeFile(lifecycleRoot, slug);
   if (!fsImpl.existsSync(file)) return { state: 'none', slug, incomplete: [] };
   const answer = status({ file, fsImpl, roots: rootsFor({ cwd, lifecycleRoot }), slug });
-  const incomplete = answer.tasks.filter((t: any) => t.derived !== 'done').map((t: any) => t.id);
+  const incomplete = answer.tasks.filter((t     ) => t.derived !== 'done').map((t     ) => t.id);
   return { state: answer.complete ? 'complete' : 'incomplete', slug, incomplete };
 }
 
 // ── CLI ────────────────────────────────────────────────────────────────────────────────────────
 
-function failure(code: any, message: any, json: any) {
-  const { finishRuntime } = require('./cli-result.ts');
+function failure(code     , message     , json     ) {
+  const { finishRuntime } = require('./cli-result.js');
   if (json) console.log(JSON.stringify({ ok: false, error: code, message }, null, 2));
   else console.error(`doflow task-attempt: ${message}`);
   return finishRuntime(2);
 }
 
-function describe(result: any) {
+function describe(result     ) {
   const parts = [`${result.disposition}`];
   if (result.taskId) parts.push(`task ${result.taskId}`);
   if (result.token !== undefined) parts.push(`token ${result.token}`);
@@ -370,8 +370,8 @@ function describe(result: any) {
 function handleTaskAttemptCommand({
   action = 'status', slug = null, task, owner, mode, token, result, evidenceId, reason, json = false,
   cwd = process.cwd(), resolveSlug = null, fsImpl = fs, now = new Date(),
-}: any = {}) {
-  const { finishRuntime } = require('./cli-result.ts');
+}      = {}) {
+  const { finishRuntime } = require('./cli-result.js');
   try {
     if (!ACTIONS.includes(action)) throw new TaskAttemptError('usage', `unknown action '${action}'; valid: ${ACTIONS.join(' | ')}`);
     const feature = slug || (resolveSlug ? resolveSlug(cwd) : null);
@@ -403,7 +403,7 @@ function handleTaskAttemptCommand({
       if (answer.unclaimedChecked.length) console.log(`Checked in plan.md with no COMPLETED attempt: ${answer.unclaimedChecked.join(', ')}`);
     } else (ok ? console.log : console.error)(describe(answer));
     return finishRuntime(ok ? 0 : 1);
-  } catch (error: any) {
+  } catch (error     ) {
     if (error instanceof TaskAttemptError) return failure(error.code, error.message, json);
     throw error;
   }
@@ -411,5 +411,5 @@ function handleTaskAttemptCommand({
 
 module.exports = {
   handleTaskAttemptCommand, checkCompletion, claim, finish, release, status, loadPlan, taskLineHash,
-  storeFile, TaskAttemptError, MODES, RESULTS, ACTIONS,
+  storeFile, TaskAttemptError, MODES, RESULTS, ACTIONS, activeAttempt,
 };

package/src/runtime/{task-classifier.ts → task-classifier.js}

@@ -5,16 +5,16 @@
 const path = require('node:path');
 const fs = require('node:fs');
 const { TextDecoder } = require('node:util');
-const { WorkflowEngine, CALLER_ROLES } = require('./workflow-engine.ts');
-const { finishRuntime } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
-const { loadAdviceRegistry } = require('./advice/registry.ts');
-const { createAdviceClient } = require('./advice/client.ts');
-const { materializeKind } = require('./advice/kinds.ts');
-const { appendOutcome, findPick } = require('./advice/record.ts');
-const { strengthWords } = require('./advice/strength.ts');
-const { loadStorageRegistry } = require('./storage/registry.ts');
-const { resolveRoots } = require('./storage/roots.ts');
+const { WorkflowEngine, CALLER_ROLES } = require('./workflow-engine.js');
+const { finishRuntime } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
+const { loadAdviceRegistry } = require('./advice/registry.js');
+const { createAdviceClient } = require('./advice/client.js');
+const { materializeKind } = require('./advice/kinds.js');
+const { appendOutcome, findPick } = require('./advice/record.js');
+const { strengthWords } = require('./advice/strength.js');
+const { loadStorageRegistry } = require('./storage/registry.js');
+const { resolveRoots } = require('./storage/roots.js');
 
 
 /**
@@ -79,7 +79,7 @@ const NEAR_MISS_KEYS = ['class', 'taskType', 'type', 'proposedClass', 'workflow'
  * silent skip of the fit check. */
 const CALLER_NEAR_MISS_KEYS = ['caller', 'callerSkill', 'skill', 'skillId', 'invokedBy', 'calledBy'];
 
-function isPlainObject(value: any) {
+function isPlainObject(value     ) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
 
@@ -90,7 +90,7 @@ function isPlainObject(value: any) {
  * a silent match. Trimming here would be a small coercion that hides a real formatting bug in the
  * caller's output.
  */
-function readProposal(proposal: any) {
+function readProposal(proposal     ) {
   if (proposal === null || proposal === undefined) {
     return {
       taskClass: null, rationale: null, proposedBy: null, callingSkill: null,
@@ -138,10 +138,10 @@ function readProposal(proposal: any) {
  * every `do-*` skill. That is acceptable for a hint nobody acts on; it is why the messages present
  * the result as "Did you mean" rather than as a shortlist.
  */
-function suggestFrom(proposed: any, candidates: any) {
+function suggestFrom(proposed     , candidates     ) {
   if (typeof proposed !== 'string' || proposed.trim() === '') return [];
   const needle = proposed.trim().toLowerCase();
-  return candidates.filter((candidate: any) => {
+  return candidates.filter((candidate     ) => {
     const other = candidate.toLowerCase();
     return other === needle || other.includes(needle) || needle.includes(other);
   });
@@ -163,8 +163,8 @@ function suggestFrom(proposed: any, candidates: any) {
  *   hostedStageIds: Array<string>, hostingClasses: Array<{taskClass: string, stageIds: Array<string>}>,
  *   callerSuggestions: Array<string>}} frozen
  */
-function judgeFit(engine: any, taskClass: string, callingSkill: any, nearMissCallerKeys: any) {
-  const unevaluated = (reason: any, extra: any = {}) => Object.freeze({
+function judgeFit(engine     , taskClass        , callingSkill     , nearMissCallerKeys     ) {
+  const unevaluated = (reason     , extra      = {}) => Object.freeze({
     state: FIT_STATES.NOT_EVALUATED,
     reason,
     callingSkill,
@@ -194,7 +194,7 @@ function judgeFit(engine: any, taskClass: string, callingSkill: any, nearMissCal
   // Derived from the stage lists rather than declared, so it cannot drift from them. On HOSTED it
   // includes the accepted class: it is the caller's complete map, not a list of alternatives.
   const hostingClasses = engine.classesHosting(callingSkill);
-  const decided = (state: any, reason: any, hostedStageIds: any = []) => Object.freeze({
+  const decided = (state     , reason     , hostedStageIds      = []) => Object.freeze({
     state, reason, callingSkill, callerRole, hostedStageIds, hostingClasses, callerSuggestions: [],
   });
 
@@ -212,9 +212,9 @@ function judgeFit(engine: any, taskClass: string, callingSkill: any, nearMissCal
 }
 
 /** `bug (root-cause), refactor (architecture-mapping)` — the caller's hosting map, as prose. */
-function renderHostingClasses(hostingClasses: any) {
+function renderHostingClasses(hostingClasses     ) {
   return hostingClasses
-    .map(({ taskClass, stageIds }: any) => `${taskClass} (${stageIds.join(', ')})`)
+    .map(({ taskClass, stageIds }     ) => `${taskClass} (${stageIds.join(', ')})`)
     .join(', ');
 }
 
@@ -223,7 +223,7 @@ function renderHostingClasses(hostingClasses: any) {
  * when fit was not evaluated: an operator must be able to read the blind spot off the message
  * without inspecting the JSON.
  */
-function describeAcceptedFit(fit: any, nearMissCallerKeys: any) {
+function describeAcceptedFit(fit     , nearMissCallerKeys     ) {
   if (fit.state === FIT_STATES.HOSTED) {
     return ` It hosts '${fit.callingSkill}' at stage(s): ${fit.hostedStageIds.join(', ')}.`;
   }
@@ -233,7 +233,7 @@ function describeAcceptedFit(fit: any, nearMissCallerKeys: any) {
   }
   if (fit.reason === FIT_REASONS.CALLER_KEY_NEAR_MISS) {
     return ' Fit was NOT evaluated: the proposal carries '
-      + `${nearMissCallerKeys.map((key: any) => `'${key}'`).join(', ')}; the calling skill must be given `
+      + `${nearMissCallerKeys.map((key     ) => `'${key}'`).join(', ')}; the calling skill must be given `
       + 'as `callingSkill`. Membership is all this decision establishes.';
   }
   return ' Fit was NOT evaluated: no calling skill was named, so this decision establishes that the '
@@ -245,7 +245,7 @@ function describeAcceptedFit(fit: any, nearMissCallerKeys: any) {
  * The message for a rejection the fit check produced. Each one names the remedy: a rejection nobody
  * can act on is a stop rather than a fix.
  */
-function describeFitRejection(fit: any, taskClass: any, workflow: any, engine: any) {
+function describeFitRejection(fit     , taskClass     , workflow     , engine     ) {
   if (fit.reason === REJECTION_REASONS.UNKNOWN_CALLER) {
     const hint = fit.callerSuggestions.length > 0
       ? ` Did you mean: ${fit.callerSuggestions.join(', ')}?`
@@ -272,14 +272,14 @@ function describeFitRejection(fit: any, taskClass: any, workflow: any, engine: a
 }
 
 class TaskClassifier {
-  declare engine: any;
-  declare now: any;
+                      
+                   
   /**
    * @param {Object} [options]
    * @param {WorkflowEngine} [options.engine] Pre-built engine; otherwise one is built from `options`.
    * @param {Function} [options.now] Clock returning an ISO timestamp, for deterministic tests.
    */
-  constructor(options: any = {}) {
+  constructor(options      = {}) {
     this.engine = options.engine || new WorkflowEngine(options);
     this.now = options.now || (() => new Date().toISOString());
   }
@@ -306,7 +306,7 @@ class TaskClassifier {
    *   skill can occupy — including `NOT_EVALUATED` when no caller was named, since an unchecked fit
    *   must never read as a checked one.
    */
-  classify(proposal: any, context: any = {}) {
+  classify(proposal     , context      = {}) {
     const validClasses = this.listClasses();
     const parsed = readProposal(proposal);
     const base = {
@@ -411,7 +411,7 @@ class TaskClassifier {
    * @param {Object} [context]
    * @returns {Object} the resolved workflow
    */
-  resolve(proposal: any, context: any = {}) {
+  resolve(proposal     , context      = {}) {
     const decision = this.classify(proposal, context);
     if (decision.outcome !== CLASSIFICATION_OUTCOMES.ACCEPTED) {
       throw new Error(decision.message);
@@ -438,7 +438,7 @@ class TaskClassifier {
  * @param {boolean} [options.json=false]
  * @returns {number|Promise<number>} exit code; advisory calls are asynchronous
  */
-function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill, request, requestFile, taskId, projectRoot, json = false }: any = {}) {
+function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill, request, requestFile, taskId, projectRoot, json = false }      = {}) {
   const classifier = new TaskClassifier({ repoRoot: REPO_ROOT });
   const decision = classifier.classify({ taskClass, rationale, proposedBy, callingSkill });
   const exitCode = decision.outcome === CLASSIFICATION_OUTCOMES.ACCEPTED
@@ -459,7 +459,7 @@ function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill,
       try {
         state = new TextDecoder('utf-8', { fatal: true }).decode(fs.readFileSync(requestFile));
         if (!state.length) throw new Error('file is empty');
-      } catch (error: any) {
+      } catch (error     ) {
         fileError = error;
       }
     }
@@ -471,7 +471,7 @@ function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill,
         const advice = loadAdviceRegistry({ repoRoot: REPO_ROOT });
         const storage = loadStorageRegistry({ repoRoot: REPO_ROOT });
         const roots = resolveRoots({ registry: storage, projectRoot: path.resolve(projectRoot || process.cwd()) });
-        const source = (name: any) => JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'core/registry', name), 'utf8'));
+        const source = (name     ) => JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'core/registry', name), 'utf8'));
         const sources = { workflows: source('workflows.json') };
         const built = materializeKind('task-class', { adviceRegistry: advice.ok ? advice.registry : null, sources });
         const client = createAdviceClient({ adviceRegistry: advice.ok ? advice.registry : null, roots, sources });
@@ -498,12 +498,12 @@ function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill,
   }
 }
 
-function emptySecondOpinion(status: any, reason: any) {
+function emptySecondOpinion(status     , reason     ) {
   return { status, reason, pick: null, strength: null, between: null, agrees: null, proposed: null,
     pickId: null, probabilities: null, confidence: null, model: null };
 }
 
-function secondOpinion(result: any, proposed: any) {
+function secondOpinion(result     , proposed     ) {
   const answer = result.answers?.[0];
   if (result.status !== 'answered' || !answer) return emptySecondOpinion(result.status, result.reason);
   return {
@@ -513,7 +513,7 @@ function secondOpinion(result: any, proposed: any) {
   };
 }
 
-function printClassifyDecision(decision: any, opinion: any) {
+function printClassifyDecision(decision     , opinion     ) {
   console.log(`\nDoFlow Task Classification [${decision.outcome}]:`);
   console.log('═'.repeat(78));
   console.log(decision.message);
@@ -527,7 +527,7 @@ function printClassifyDecision(decision: any, opinion: any) {
   }
   if (decision.fit.state === 'NOT_HOSTED' && decision.fit.hostingClasses.length > 0) {
     console.log(`Classes that host ${decision.fit.callingSkill}: `
-      + decision.fit.hostingClasses.map((h: any) => `${h.taskClass} (${h.stageIds.join(', ')})`).join(', '));
+      + decision.fit.hostingClasses.map((h     ) => `${h.taskClass} (${h.stageIds.join(', ')})`).join(', '));
   }
   if (decision.workflow) {
     console.log('─'.repeat(78));