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

package/src/runtime/storage/{rules.ts → rules.js}

@@ -4,9 +4,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { workStatus, createWorkCache, refreshedWorkCache } = require('./work-status.ts');
-const { projectKey } = require('../lifecycle/report-store.ts');
-const { readEvents } = require('../lifecycle/event-store.ts');
+const { workStatus, createWorkCache, refreshedWorkCache } = require('./work-status.js');
+const { projectKey } = require('../lifecycle/report-store.js');
+const { readEvents } = require('../lifecycle/event-store.js');
 
 const DAY = 86400000;
 const HOUR = 3600000;
@@ -18,12 +18,12 @@ const removableRules = new Set(['count-and-age','work','date-partition','recover
 const SAFE_NAMESPACE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 // Open-log protection cannot vouch for a record store that holds a link, so the pass fails closed.
 const LINKED = 'link-in-record-store';
-function stopped(context: any) { return Boolean(context.shouldStop?.()); }
+function stopped(context     ) { return Boolean(context.shouldStop?.()); }
 function budgetError() { return Object.assign(new Error('storage pass budget exhausted'), { code: 'EBUDGET', partial: true }); }
-function projectRoot(roots: any) { return roots['project-state'] ? path.dirname(path.dirname(roots['project-state'])) : null; }
-function safeStat(fsImpl: any, file: any) { try { return fsImpl.lstatSync(file); } catch { return null; } }
-function names(fsImpl: any, dir: any) { return fsImpl.readdirSync(dir); }
-function ageReason(store: any, entry: any, now: any, fsImpl: any, storeDir: any, shouldStop: any) {
+function projectRoot(roots     ) { return roots['project-state'] ? path.dirname(path.dirname(roots['project-state'])) : null; }
+function safeStat(fsImpl     , file     ) { try { return fsImpl.lstatSync(file); } catch { return null; } }
+function names(fsImpl     , dir     ) { return fsImpl.readdirSync(dir); }
+function ageReason(store     , entry     , now     , fsImpl     , storeDir     , shouldStop     ) {
   const limit = store.bound.maxAgeDays * DAY;
   if (store.rule === 'date-partition') {
     const date = entry.name.slice(0, 10);
@@ -45,13 +45,13 @@ function ageReason(store: any, entry: any, now: any, fsImpl: any, storeDir: any,
   }
   return now - newest > limit ? 'age' : null;
 }
-function workCandidates(store: any, entries: any, context: any) {
+function workCandidates(store     , entries     , context     ) {
   const { fsImpl, storeDir, now, roots, settings, shouldStop } = context;
   const project = projectRoot(roots);
   if (!project) return [];
   const cache = context.cache || createWorkCache({ projectRoot: project, fsImpl });
-  const recordMatch = new RegExp(store.match), selected: any[] = [];
-  const visit = (dir: any, namespace: any = null) => {
+  const recordMatch = new RegExp(store.match), selected        = [];
+  const visit = (dir     , namespace      = null) => {
     let children;
     try { children = names(fsImpl, dir); } catch { return true; }
     for (const name of children) {
@@ -77,7 +77,7 @@ function workCandidates(store: any, entries: any, context: any) {
   return selected;
 }
 /** Revalidate the subject under its try-lock against its current run and plan, not the selection snapshot. */
-function recordStillCandidate(store: any, candidate: any, info: any, context: any) {
+function recordStillCandidate(store     , candidate     , info     , context     ) {
   const { fsImpl, roots, now, settings, cache, shouldStop, storeDir } = context;
   const before = candidate.recordStat;
   if (!info.isFile() || !before || ['mtimeMs', 'ctimeMs', 'size', 'ino', 'dev'].some(key => info[key] !== before[key])) return false;
@@ -96,7 +96,7 @@ function recordStillCandidate(store: any, candidate: any, info: any, context: an
   return !status.incomplete && !shouldStop?.() && status.state === 'finished'
     && status.since === candidate.mtimeMs && now - status.since > store.bound.finishedDays * DAY;
 }
-function workStorePathStatus(store: any, roots: any, fsImpl: any) {
+function workStorePathStatus(store     , roots     , fsImpl     ) {
   const project = projectRoot(roots), root = roots[store.root];
   if (!project || !root) return 'missing';
   const paths = [path.join(project, '.doflow'), root];
@@ -105,16 +105,16 @@ function workStorePathStatus(store: any, roots: any, fsImpl: any) {
   for (const candidate of paths) {
     let info;
     try { info = fsImpl.lstatSync(candidate); }
-    catch (error: any) { return error.code === 'ENOENT' || error.code === 'ENOTDIR' ? 'missing' : 'inaccessible'; }
+    catch (error     ) { return error.code === 'ENOENT' || error.code === 'ENOTDIR' ? 'missing' : 'inaccessible'; }
     if (info.isSymbolicLink()) return 'linked';
   }
   return 'safe';
 }
-function protectedLogs({ registry, roots, fsImpl, cache, shouldStop }: any) {
+function protectedLogs({ registry, roots, fsImpl, cache, shouldStop }     ) {
   const project = projectRoot(roots), protectedNames = new Set();
   if (!project) return { names: protectedNames, incomplete: false };
   const workCache = cache || createWorkCache({ projectRoot: project, fsImpl });
-  for (const store of registry.stores.filter((s: any) => s.root === 'project-state' && s.entry === 'record' && s.rule === 'work')) {
+  for (const store of registry.stores.filter((s     ) => s.root === 'project-state' && s.entry === 'record' && s.rule === 'work')) {
     if (shouldStop?.()) return { names: protectedNames, incomplete: true };
     const pathStatus = workStorePathStatus(store, roots, fsImpl);
     if (pathStatus === 'missing') continue;
@@ -122,16 +122,16 @@ function protectedLogs({ registry, roots, fsImpl, cache, shouldStop }: any) {
     const dir = path.join(roots[store.root], ...store.path.split('/'));
     const recordMatch = new RegExp(store.match);
     let linked = false;
-    const visit = (folder: any, namespace: any = null) => {
+    const visit = (folder     , namespace      = null) => {
       let list;
       try { list = names(fsImpl, folder); }
-      catch (error: any) { return error.code === 'ENOENT' || error.code === 'ENOTDIR'; }
+      catch (error     ) { return error.code === 'ENOENT' || error.code === 'ENOTDIR'; }
       for (const name of list) {
         if (shouldStop?.()) return false;
         const file = path.join(folder, name);
         let stat;
         try { stat = fsImpl.lstatSync(file); }
-        catch (error: any) { if (error.code === 'ENOENT' || error.code === 'ENOTDIR') continue; return false; }
+        catch (error     ) { if (error.code === 'ENOENT' || error.code === 'ENOTDIR') continue; return false; }
         if (stat.isSymbolicLink()) { linked = true; return false; }
         if (namespace === null && stat.isDirectory() && SAFE_NAMESPACE.test(name) && !name.includes('..')) {
           if (!visit(file, name)) return false;
@@ -158,18 +158,18 @@ function protectedLogs({ registry, roots, fsImpl, cache, shouldStop }: any) {
   }
   return { names: protectedNames, incomplete: false };
 }
-function lifecyclePathsSafe(project: any, fsImpl: any) {
+function lifecyclePathsSafe(project     , fsImpl     ) {
   for (const rel of [path.join('.doflow'), path.join('.doflow', 'state'), path.join('.doflow', 'state', 'lifecycle'), path.join('.doflow', 'state', 'lifecycle', 'events')]) {
     try { if (fsImpl.lstatSync(path.join(project, rel)).isSymbolicLink()) return false; }
-    catch (error: any) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') return false; if (rel !== path.join('.doflow', 'state', 'lifecycle', 'events')) return false; }
+    catch (error     ) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') return false; if (rel !== path.join('.doflow', 'state', 'lifecycle', 'events')) return false; }
   }
   return true;
 }
-function definitelyMissing(fsImpl: any, target: any) {
+function definitelyMissing(fsImpl     , target     ) {
   try { fsImpl.lstatSync(target); return false; }
-  catch (error: any) { return error.code === 'ENOENT' || error.code === 'ENOTDIR'; }
+  catch (error     ) { return error.code === 'ENOENT' || error.code === 'ENOTDIR'; }
 }
-function reportCandidates(store: any, entries: any, context: any) {
+function reportCandidates(store     , entries     , context     ) {
   const { fsImpl, storeDir, roots, now, settings, shouldStop } = context;
   const project = projectRoot(roots);
   const key = project && projectKey(project, fsImpl), selected = [];
@@ -183,7 +183,7 @@ function reportCandidates(store: any, entries: any, context: any) {
         if (shouldStop?.()) throw budgetError();
         if (BODY.test(name) && safeStat(fsImpl, path.join(folder, name))?.isFile()) bodyNames.push(name);
       }
-    } catch (error: any) { if (error.partial) throw error; continue; }
+    } catch (error     ) { if (error.partial) throw error; continue; }
     if (entry.name === key) {
       const lifecycle = path.join(project, '.doflow/state/lifecycle');
       if (!safeStat(fsImpl, path.join(lifecycle, 'migrated.json'))?.isFile() || !lifecyclePathsSafe(project, fsImpl)) continue;
@@ -232,7 +232,7 @@ function reportCandidates(store: any, entries: any, context: any) {
   }
   return selected;
 }
-function selectCandidates(store: any, entries: any, context: any) {
+function selectCandidates(store     , entries     , context     ) {
   const { now, fsImpl, storeDir, roots, shouldStop } = context;
   switch (store.rule) {
     case 'count-and-age': {

package/src/runtime/storage/{upkeep.ts → upkeep.js}

@@ -5,39 +5,39 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { randomBytes } = require('node:crypto');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
-const { loadStorageRegistry } = require('./registry.ts');
-const { resolveRoots, readPruneSetting } = require('./roots.ts');
-const engine = require('./engine.ts');
-const { RunLedger } = require('../trace/ledger.ts');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+const { loadStorageRegistry } = require('./registry.js');
+const { resolveRoots, readPruneSetting } = require('./roots.js');
+const engine = require('./engine.js');
+const { RunLedger } = require('../trace/ledger.js');
 
 // Load once: a not-due moment only reads the three small markers, never the catalogue again.
-let registry: any;
+let registry     ;
 try { registry = loadStorageRegistry({ repoRoot: REPO_ROOT }); } catch { /* fail closed */ }
 const MOMENT_ROOTS = ['project-state', 'user-state', 'config-home'];
 
-function silently(fn: any) {
+function silently(fn     ) {
   const exitCode = process.exitCode;
   try { if (registry) return fn(); } catch { /* upkeep must never affect its caller */ }
   finally { process.exitCode = exitCode; }
 }
-function stat(file: any, fsImpl: any) {
+function stat(file     , fsImpl     ) {
   try { return fsImpl.lstatSync(file); }
-  catch (error: any) { if (error.code === 'ENOENT') return null; throw error; }
+  catch (error     ) { if (error.code === 'ENOENT') return null; throw error; }
 }
-function usableRoot(root: any, fsImpl: any) {
+function usableRoot(root     , fsImpl     ) {
   if (!root) return false;
   const owned = path.basename(root) === 'state' ? path.dirname(root) : root;
   const parent = stat(owned, fsImpl), info = stat(root, fsImpl);
   return !!parent?.isDirectory() && !parent.isSymbolicLink() && !!info?.isDirectory() && !info.isSymbolicLink();
 }
-function atomicWrite(file: any, text: any, fsImpl: any, { preserveExisting = false }: any = {}) {
+function atomicWrite(file     , text     , fsImpl     , { preserveExisting = false }      = {}) {
   const temp = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
   try {
     fsImpl.writeFileSync(temp, text, { flag: 'wx' });
     if (preserveExisting) {
       // IC-016: a link never replaces a name, so a file created since the caller's check stays.
-      try { fsImpl.linkSync(temp, file); } catch (error: any) { if (error.code === 'EEXIST') return false; throw error; }
+      try { fsImpl.linkSync(temp, file); } catch (error     ) { if (error.code === 'EEXIST') return false; throw error; }
       return true;
     }
     fsImpl.renameSync(temp, file);
@@ -47,7 +47,7 @@ function atomicWrite(file: any, text: any, fsImpl: any, { preserveExisting = fal
   }
 }
 function ignoreBytes() { return `${registry.settings.ignoreFile.lines.join('\n')}\n`; }
-function ensureIgnore({ roots, rootId, projectRoot, fsImpl }: any) {
+function ensureIgnore({ roots, rootId, projectRoot, fsImpl }     ) {
   const root = roots[rootId];
   if (!usableRoot(root, fsImpl)) return;
   const file = path.join(root, registry.settings.ignoreFile.name);
@@ -64,7 +64,7 @@ function ensureIgnore({ roots, rootId, projectRoot, fsImpl }: any) {
  * never appended. Its own pass (at most daily) adds it once user state exists, so a global
  * uninstall can still find its controls (IC-019).
  */
-function registerProject(roots: any, fsImpl: any) {
+function registerProject(roots     , fsImpl     ) {
   const projectState = roots['project-state'], userState = roots['user-state'];
   if (!usableRoot(projectState, fsImpl) || !usableRoot(userState, fsImpl)) return;
   if (!stat(path.join(projectState, registry.settings.ignoreFile.name), fsImpl)?.isFile()) return;
@@ -75,31 +75,31 @@ function registerProject(roots: any, fsImpl: any) {
   if ((indexedRoots(index, fsImpl) || []).includes(project)) return;
   fsImpl.appendFileSync(index, `${project}\n`, 'utf8');
 }
-function indexedRoots(file: any, fsImpl: any) {
+function indexedRoots(file     , fsImpl     ) {
   const info = stat(file, fsImpl);
   if (!info || info.isSymbolicLink() || !info.isFile()) return null;
-  return fsImpl.readFileSync(file, 'utf8').split('\n').filter((root: any) => path.isAbsolute(root));
+  return fsImpl.readFileSync(file, 'utf8').split('\n').filter((root     ) => path.isAbsolute(root));
 }
-function rewriteRoots(roots: any, fsImpl: any, forget: any = null) {
+function rewriteRoots(roots     , fsImpl     , forget      = null) {
   const file = path.join(roots['user-state'], 'upkeep-roots');
   if (!usableRoot(roots['user-state'], fsImpl)) return;
   const lines = indexedRoots(file, fsImpl);
   if (!lines) return;
   const kept = forget === null
     ? [...new Set(lines)].filter(root => stat(path.join(root, '.doflow/state/.gitignore'), fsImpl))
-    : lines.filter((root: any) => root !== forget);
+    : lines.filter((root     ) => root !== forget);
   atomicWrite(file, kept.length ? `${kept.join('\n')}\n` : '', fsImpl);
 }
-function due(root: any, now: any, fsImpl: any) {
+function due(root     , now     , fsImpl     ) {
   try {
     const text = fsImpl.readFileSync(path.join(root, 'upkeep-due'), 'utf8').trim();
     return !/^\d+$/.test(text) || !Number.isFinite(Number(text)) || Number(text) * 1000 <= now;
   } catch { return true; }
 }
-function takeLock(root: any, now: any, fsImpl: any) {
+function takeLock(root     , now     , fsImpl     ) {
   const lock = path.join(root, 'upkeep.lock');
   try { fsImpl.mkdirSync(lock); return true; }
-  catch (error: any) {
+  catch (error     ) {
     if (error.code !== 'EEXIST') throw error;
     const info = stat(lock, fsImpl);
     if (info?.isDirectory() && !info.isSymbolicLink() && now - info.mtimeMs > registry.settings.passLockStaleSeconds * 1000) {
@@ -108,12 +108,12 @@ function takeLock(root: any, now: any, fsImpl: any) {
     return false;
   }
 }
-function writeDue(root: any, time: any, fsImpl: any) {
+function writeDue(root     , time     , fsImpl     ) {
   const file = path.join(root, 'upkeep-due');
   if (stat(file, fsImpl)?.isSymbolicLink()) throw new Error('linked upkeep marker');
   atomicWrite(file, `${Math.floor(time / 1000)}\n`, fsImpl);
 }
-function passForRoot({ roots, rootId, stores, now, env, fsImpl, throttled = false }: any) {
+function passForRoot({ roots, rootId, stores, now, env, fsImpl, throttled = false }     ) {
   const root = roots[rootId];
   if (!usableRoot(root, fsImpl)) return;
   const setting = readPruneSetting({ registry, roots, rootId, fsImpl });
@@ -124,7 +124,7 @@ function passForRoot({ roots, rootId, stores, now, env, fsImpl, throttled = fals
     if (throttled) writeDue(root, now + registry.settings.upkeepIntervalHours * 3600000, fsImpl);
     ran = true;
     result = engine.runPass({ registry, roots, stores, mode: 'prune', setting: { [rootId]: 'on' }, now, env, fsImpl });
-    outcome = result.partial ? 'partial' : result.stores.some((store: any) => store.failed.length) ? 'error' : 'ok';
+    outcome = result.partial ? 'partial' : result.stores.some((store     ) => store.failed.length) ? 'error' : 'ok';
     if (rootId === 'user-state') rewriteRoots(roots, fsImpl);
     if (rootId === 'project-state') { try { registerProject(roots, fsImpl); } catch { /* the index is best effort */ } }
   } catch { outcome = 'error'; /* the record never includes failure content */ }
@@ -146,7 +146,7 @@ function passForRoot({ roots, rootId, stores, now, env, fsImpl, throttled = fals
 }
 
 /** IC-009: silent throttled upkeep after a verb, using that verb's resolved store root. */
-function upkeepAfterVerb({ projectRoot, now = Date.now(), env = process.env, fsImpl = fs }: any = {}) {
+function upkeepAfterVerb({ projectRoot, now = Date.now(), env = process.env, fsImpl = fs }      = {}) {
   return silently(() => {
     const roots = resolveRoots({ registry, projectRoot, env });
     for (const rootId of ['project-state', 'user-state']) {
@@ -156,7 +156,7 @@ function upkeepAfterVerb({ projectRoot, now = Date.now(), env = process.env, fsI
       try {
         const root = roots[rootId];
         if (!usableRoot(root, fsImpl) || !due(root, now, fsImpl)) continue;
-        const stores = registry.stores.filter((store: any) => store.root === rootId && store.moments.includes('verb')).map((store: any) => store.id);
+        const stores = registry.stores.filter((store     ) => store.root === rootId && store.moments.includes('verb')).map((store     ) => store.id);
         passForRoot({ roots, rootId, stores, now, env, fsImpl, throttled: true });
       } catch { /* one inaccessible root cannot stop the others */ }
     }
@@ -164,7 +164,7 @@ function upkeepAfterVerb({ projectRoot, now = Date.now(), env = process.env, fsI
 }
 
 /** IC-010: the verify moment is project-only and unthrottled. Wiring belongs to D.3. */
-function upkeepAfterVerify({ projectRoot, now = Date.now(), env = process.env, fsImpl = fs }: any = {}) {
+function upkeepAfterVerify({ projectRoot, now = Date.now(), env = process.env, fsImpl = fs }      = {}) {
   return silently(() => {
     const roots = resolveRoots({ registry, projectRoot, env });
     return passForRoot({ roots, rootId: 'project-state', stores: ['verification-logs'], now, env, fsImpl });
@@ -172,7 +172,7 @@ function upkeepAfterVerify({ projectRoot, now = Date.now(), env = process.env, f
 }
 
 /** IC-011: only this scope's recovery store; install/update call sites belong to D.4. */
-function storageAfterInstall({ scope, scopeRoot, now = Date.now(), env = process.env, fsImpl = fs }: any = {}) {
+function storageAfterInstall({ scope, scopeRoot, now = Date.now(), env = process.env, fsImpl = fs }      = {}) {
   return silently(() => {
     if (!['project', 'global'].includes(scope)) return;
     const global = scope === 'global';
@@ -184,20 +184,20 @@ function storageAfterInstall({ scope, scopeRoot, now = Date.now(), env = process
 }
 
 /** IC-019: user-initiated cleanup removes owned controls, never state or user settings. */
-function storageForgetScope({ scope, scopeRoot, env = process.env, fsImpl = fs }: any = {}) {
+function storageForgetScope({ scope, scopeRoot, env = process.env, fsImpl = fs }      = {}) {
   const exitCode = process.exitCode;
   let removed = 0;
-  const failures: any = [];
-  const attempt = (file: any, fn: any) => {
-    try { fn(); } catch (error: any) { if (error.code !== 'ENOENT') failures.push(`${file}: ${error.code || error.message}`); }
+  const failures      = [];
+  const attempt = (file     , fn     ) => {
+    try { fn(); } catch (error     ) { if (error.code !== 'ENOENT') failures.push(`${file}: ${error.code || error.message}`); }
   };
-  const removeFile = (file: any, exact = false) => attempt(file, () => {
+  const removeFile = (file     , exact = false) => attempt(file, () => {
     const info = stat(file, fsImpl);
     if (!info?.isFile() || info.isSymbolicLink()) return;
     if (exact && fsImpl.readFileSync(file, 'utf8') !== ignoreBytes()) return;
     fsImpl.unlinkSync(file); removed++;
   });
-  const removeControls = (root: any, ignore = true) => {
+  const removeControls = (root     , ignore = true) => {
     if (!usableRoot(root, fsImpl)) return;
     if (ignore) removeFile(path.join(root, '.gitignore'), true);
     removeFile(path.join(root, 'upkeep-due'));
@@ -235,7 +235,7 @@ function storageForgetScope({ scope, scopeRoot, env = process.env, fsImpl = fs }
     }
     if (failures.length) for (const failure of failures) console.error(`[WARN] Storage: ${failure}`);
     else if (removed > 0) console.log(`[INFO] Storage: removed ${removed} DoFlow control file(s)`);
-  } catch (error: any) {
+  } catch (error     ) {
     try { console.error(`[WARN] Storage: ${error.code || error.message}`); } catch { /* no exit change */ }
   } finally { process.exitCode = exitCode; }
 }

package/src/runtime/storage/{work-status.ts → work-status.js}

@@ -4,8 +4,8 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
-const { loadStorageRegistry } = require('./registry.ts');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+const { loadStorageRegistry } = require('./registry.js');
 
 const RUN_STATES = new Set(['RUNNING', 'AWAITING_GATE', 'COMPLETED', 'REJECTED']);
 const RUN_OPEN_STATES = Object.freeze(['RUNNING', 'AWAITING_GATE']);
@@ -13,18 +13,18 @@ const UNCHECKED = /^\s*- \[ \] /m;
 const UNCHECKED_TASK = /^\s*- \[ \] (\S+)/gm;
 const SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 
-function recordStorePaths(fsImpl: any): Map<string, string> {
+function recordStorePaths(fsImpl     )                      {
   try {
     const registry = loadStorageRegistry({ repoRoot: REPO_ROOT, fsImpl });
     return new Map(registry.stores
-      .filter((store: any) => store.root === 'project-state' && store.entry === 'record' && store.rule === 'work')
-      .map((store: any): [string, string] => [store.id, store.path]));
+      .filter((store     ) => store.root === 'project-state' && store.entry === 'record' && store.rule === 'work')
+      .map((store     )                   => [store.id, store.path]));
   } catch {
     return new Map();
   }
 }
 
-function createWorkCache({ projectRoot, fsImpl = fs }: { projectRoot: string; fsImpl?: any }): any {
+function createWorkCache({ projectRoot, fsImpl = fs }                                       )      {
   return {
     projectRoot: path.resolve(projectRoot),
     fsImpl,
@@ -43,38 +43,38 @@ function createWorkCache({ projectRoot, fsImpl = fs }: { projectRoot: string; fs
  * plan and listing, so the recheck reads the work's current run and plan rather than the snapshot
  * taken at selection. A run reopened or a plan task unchecked after selection keeps the record.
  */
-function refreshedWorkCache(cache: any): any {
+function refreshedWorkCache(cache     )      {
   return { ...cache, runNames: null, runListError: false, featureNames: null, featureListError: false,
     runs: new Map(), plans: new Map() };
 }
 
-function cacheFor({ projectRoot, fsImpl, cache }: { projectRoot: string; fsImpl: any; cache?: any }): any {
+function cacheFor({ projectRoot, fsImpl, cache }                                                   )      {
   const resolved = path.resolve(projectRoot);
   if (cache && cache.projectRoot === resolved && cache.fsImpl === fsImpl
       && cache.recordStorePaths instanceof Map && cache.runs instanceof Map && cache.plans instanceof Map) return cache;
   return createWorkCache({ projectRoot: resolved, fsImpl });
 }
 
-function stateRoot(projectRoot: string): string {
+function stateRoot(projectRoot        )         {
   return path.join(projectRoot, '.doflow', 'state');
 }
 
-function safeSegment(value: any): boolean {
+function safeSegment(value     )          {
   return typeof value === 'string' && SAFE_SEGMENT.test(value) && !value.includes('..');
 }
 
-function listRunNames(cache: any, shouldStop?: () => boolean): { names: string[]; incomplete: boolean } {
+function listRunNames(cache     , shouldStop                )                                           {
   if (shouldStop?.()) return { names: [], incomplete: true };
   if (cache.runNames !== null) return { names: cache.runNames, incomplete: false };
   const dir = path.join(stateRoot(cache.projectRoot), 'orchestration');
-  let entries: any[];
+  let entries       ;
   try { entries = cache.fsImpl.readdirSync(dir, { withFileTypes: true }); }
-  catch (error: any) {
+  catch (error     ) {
     if (error?.code === 'ENOENT') entries = [];
     else { cache.runNames = []; cache.runListError = true; return { names: cache.runNames, incomplete: false }; }
   }
   if (shouldStop?.()) return { names: [], incomplete: true };
-  const names: string[] = [];
+  const names           = [];
   for (const entry of entries) {
     if (shouldStop?.()) return { names: [], incomplete: true };
     if (entry.name.endsWith('.json')) names.push(entry.name.slice(0, -5));
@@ -84,10 +84,10 @@ function listRunNames(cache: any, shouldStop?: () => boolean): { names: string[]
   return { names, incomplete: false };
 }
 
-function readRun(cache: any, runId: string): any {
+function readRun(cache     , runId        )      {
   if (cache.runs.has(runId)) return cache.runs.get(runId);
   const file = path.join(stateRoot(cache.projectRoot), 'orchestration', `${runId}.json`);
-  let result: any;
+  let result     ;
   try {
     const value = JSON.parse(cache.fsImpl.readFileSync(file, 'utf8'));
     result = value && typeof value === 'object' && !Array.isArray(value) && RUN_STATES.has(value.state)
@@ -100,11 +100,11 @@ function readRun(cache: any, runId: string): any {
   return result;
 }
 
-function resolveRun(cache: any, taskId: string, namespace: any, shouldStop?: () => boolean): any {
+function resolveRun(cache     , taskId        , namespace     , shouldStop                )      {
   const listed = listRunNames(cache, shouldStop);
   if (listed.incomplete) return { id: null, unreadable: false, incomplete: true };
   if (cache.runListError) return { id: null, unreadable: true };
-  let exact = false, namespaced = false, prefix: string | null = null;
+  let exact = false, namespaced = false, prefix                = null;
   for (const candidate of listed.names) {
     if (shouldStop?.()) return { id: null, unreadable: false, incomplete: true };
     if (candidate === taskId) exact = true;
@@ -120,9 +120,9 @@ function resolveRun(cache: any, taskId: string, namespace: any, shouldStop?: ()
   return read.ok ? { id, value: read.value, unreadable: false } : { id, value: null, unreadable: true };
 }
 
-function readRecord({ projectRoot, storePath, recordId, namespace, mtimeMs, fsImpl }: any): any {
+function readRecord({ projectRoot, storePath, recordId, namespace, mtimeMs, fsImpl }     )      {
   const storeSegments = typeof storePath === 'string' && storePath !== '' ? storePath.split('/') : [];
-  if (typeof storePath !== 'string' || storeSegments.some((segment: string) => !safeSegment(segment))
+  if (typeof storePath !== 'string' || storeSegments.some((segment        ) => !safeSegment(segment))
       || !safeSegment(recordId)
       || (namespace !== null && namespace !== undefined && !safeSegment(namespace))) {
     return { ok: false };
@@ -138,18 +138,18 @@ function readRecord({ projectRoot, storePath, recordId, namespace, mtimeMs, fsIm
   }
 }
 
-function listFeatureNames(cache: any, shouldStop?: () => boolean): { names: string[]; incomplete: boolean } {
+function listFeatureNames(cache     , shouldStop                )                                           {
   if (shouldStop?.()) return { names: [], incomplete: true };
   if (cache.featureNames !== null) return { names: cache.featureNames, incomplete: false };
   const dir = path.join(cache.projectRoot, 'agent-docs', 'doflow');
-  let entries: any[];
+  let entries       ;
   try { entries = cache.fsImpl.readdirSync(dir, { withFileTypes: true }); }
-  catch (error: any) {
+  catch (error     ) {
     if (error?.code === 'ENOENT') entries = [];
     else { cache.featureNames = []; cache.featureListError = true; return { names: cache.featureNames, incomplete: false }; }
   }
   if (shouldStop?.()) return { names: [], incomplete: true };
-  const names: string[] = [];
+  const names           = [];
   for (const entry of entries) {
     if (shouldStop?.()) return { names: [], incomplete: true };
     if (entry.isDirectory() && safeSegment(entry.name)) names.push(entry.name);
@@ -159,10 +159,10 @@ function listFeatureNames(cache: any, shouldStop?: () => boolean): { names: stri
   return { names, incomplete: false };
 }
 
-function featureFromFolders(cache: any, taskId: string, shouldStop?: () => boolean): { feature: string | null; incomplete: boolean } {
+function featureFromFolders(cache     , taskId        , shouldStop                )                                                  {
   const listed = listFeatureNames(cache, shouldStop);
   if (listed.incomplete) return { feature: null, incomplete: true };
-  let best: string | null = null;
+  let best                = null;
   for (const name of listed.names) {
     if (shouldStop?.()) return { feature: null, incomplete: true };
     if ((taskId === name || taskId.startsWith(`${name}-`) || taskId.startsWith(`${name}.`))
@@ -171,18 +171,18 @@ function featureFromFolders(cache: any, taskId: string, shouldStop?: () => boole
   return { feature: best, incomplete: false };
 }
 
-function stringField(record: any, field: string): string | null {
+function stringField(record     , field        )                {
   const value = record && typeof record === 'object' ? record[field] : null;
   return typeof value === 'string' && value !== '' ? value : null;
 }
 
 /** true, false when the folder is definitely absent, or null when it cannot be told. */
-function folderExists(fsImpl: any, folder: string): boolean | null {
+function folderExists(fsImpl     , folder        )                 {
   try { fsImpl.lstatSync(folder); return true; }
-  catch (error: any) { return error?.code === 'ENOENT' || error?.code === 'ENOTDIR' ? false : null; }
+  catch (error     ) { return error?.code === 'ENOENT' || error?.code === 'ENOTDIR' ? false : null; }
 }
 
-function readPlan(cache: any, feature: string, shouldStop?: () => boolean): any {
+function readPlan(cache     , feature        , shouldStop                )      {
   if (shouldStop?.()) return { exists: false, ok: false, text: null, incomplete: true };
   if (cache.plans.has(feature)) return cache.plans.get(feature);
   if (!safeSegment(feature)) {
@@ -191,10 +191,10 @@ function readPlan(cache: any, feature: string, shouldStop?: () => boolean): any
     return invalid;
   }
   const folder = path.join(cache.projectRoot, 'agent-docs', 'doflow', feature);
-  let result: any;
+  let result     ;
   try {
     result = { exists: true, ok: true, text: cache.fsImpl.readFileSync(path.join(folder, 'plan.md'), 'utf8'), folder: true };
-  } catch (error: any) {
+  } catch (error     ) {
     result = error?.code === 'ENOENT'
       ? { exists: false, ok: true, text: null, folder: folderExists(cache.fsImpl, folder) }
       : { exists: true, ok: false, text: null };
@@ -205,7 +205,7 @@ function readPlan(cache: any, feature: string, shouldStop?: () => boolean): any
   return result;
 }
 
-function planWithUncheckedTask(cache: any, taskId: string, shouldStop?: () => boolean): any {
+function planWithUncheckedTask(cache     , taskId        , shouldStop                )      {
   const listed = listFeatureNames(cache, shouldStop);
   if (listed.incomplete) return { found: false, unreadable: false, incomplete: true };
   if (cache.featureListError) return { found: false, unreadable: true };
@@ -216,7 +216,7 @@ function planWithUncheckedTask(cache: any, taskId: string, shouldStop?: () => bo
     if (!plan.ok) return { found: false, unreadable: true };
     if (!plan.exists) continue;
     UNCHECKED_TASK.lastIndex = 0;
-    let match: RegExpExecArray | null;
+    let match                        ;
     while ((match = UNCHECKED_TASK.exec(plan.text)) !== null) {
       if (shouldStop?.()) return { found: false, unreadable: false, incomplete: true };
       if (match[1] === taskId) return { found: true, unreadable: false };
@@ -226,11 +226,11 @@ function planWithUncheckedTask(cache: any, taskId: string, shouldStop?: () => bo
   return { found: false, unreadable: false };
 }
 
-function answer(state: string, reason: string, run: any, feature: any, since: number | null = null): any {
+function answer(state        , reason        , run     , feature     , since                = null)      {
   return { state, since, reason, run, feature };
 }
 
-function incompleteAnswer(run: any = null, feature: any = null): any {
+function incompleteAnswer(run      = null, feature      = null)      {
   return { ...answer('undecidable', 'pass-budget-exhausted', run, feature), incomplete: true };
 }
 
@@ -242,7 +242,7 @@ function incompleteAnswer(run: any = null, feature: any = null): any {
  */
 function workStatus({
   projectRoot, store, taskId, namespace = null, mtimeMs, cache, fsImpl, shouldStop,
-}: any): any {
+}     )      {
   const project = path.resolve(projectRoot);
   const fileSystem = fsImpl || cache?.fsImpl || fs;
   const pass = cacheFor({ projectRoot: project, fsImpl: fileSystem, cache });
@@ -262,7 +262,7 @@ function workStatus({
   // path. An orchestration record is also its exact run file, so reuse the cached parse rather than
   // reading that file twice.
   const storePath = pass.recordStorePaths.get(store);
-  let record: any;
+  let record     ;
   if (storePath === 'orchestration' && !namespace && recordId === workId && resolvedRun.id === workId && run) {
     try {
       const file = path.join(stateRoot(project), storePath, `${recordId}.json`);
@@ -285,7 +285,7 @@ function workStatus({
   }
 
   // W5: feature metadata is ordered; folder-name inference is the final fallback.
-  let feature: string | null = stringField(run, 'featureSlug')
+  let feature                = stringField(run, 'featureSlug')
     || stringField(record.value, 'featureSlug')
     || stringField(record.value, 'slug')
     || (safeSegment(namespace) ? namespace : null);