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

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);