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

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

@@ -5,26 +5,26 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { randomBytes } = require('node:crypto');
-const { formatBound } = require('./registry.ts');
-const { resolveStorePath } = require('./roots.ts');
-const { selectCandidates, recordStillCandidate, protectedLogs, removableRules, ruleOrder, projectRoot } = require('./rules.ts');
-const { retainLocked } = require('../lifecycle/store-upkeep.ts');
-const { parseWindow, selectExpired } = require('../lifecycle/retention.ts');
-const { readEvents } = require('../lifecycle/event-store.ts');
-const { createWorkCache } = require('./work-status.ts');
-const { projectKey } = require('../lifecycle/report-store.ts');
+const { formatBound } = require('./registry.js');
+const { resolveStorePath } = require('./roots.js');
+const { selectCandidates, recordStillCandidate, protectedLogs, removableRules, ruleOrder, projectRoot } = require('./rules.js');
+const { retainLocked } = require('../lifecycle/store-upkeep.js');
+const { parseWindow, selectExpired } = require('../lifecycle/retention.js');
+const { readEvents } = require('../lifecycle/event-store.js');
+const { createWorkCache } = require('./work-status.js');
+const { projectKey } = require('../lifecycle/report-store.js');
 const SAFE_NAMESPACE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const TOMBSTONE = /^\.[A-Za-z0-9][A-Za-z0-9._-]*\.pruning-[0-9]+-[0-9a-f]{8}$/;
 
-function stat(fsImpl: any,file: any) { try { return fsImpl.lstatSync(file); } catch { return null; } }
-function ownedPathLinked(store: any,roots: any,fsImpl: any) {
+function stat(fsImpl     ,file     ) { try { return fsImpl.lstatSync(file); } catch { return null; } }
+function ownedPathLinked(store     ,roots     ,fsImpl     ) {
   const root=roots[store.root]; if (!root) return false;
   const owned=path.basename(root)==='doflow' || path.basename(root)==='.doflow' ? root : path.dirname(root);
-  for (const dir of [owned,...(store.path ? [root,...store.path.split('/').reduce((a: any,part: any)=>{a.push(path.join(a.at(-1)||root,part));return a;},[])] : [root])])
+  for (const dir of [owned,...(store.path ? [root,...store.path.split('/').reduce((a     ,part     )=>{a.push(path.join(a.at(-1)||root,part));return a;},[])] : [root])])
     if (stat(fsImpl,dir)?.isSymbolicLink()) return true;
   return false;
 }
-function inventory(store: any,storeDir: any,fsImpl: any,shouldStop: any) {
+function inventory(store     ,storeDir     ,fsImpl     ,shouldStop     ) {
   const match=new RegExp(store.match), entries=[];
   for (const name of fsImpl.readdirSync(storeDir)) {
     if (shouldStop?.()) return null;
@@ -39,7 +39,7 @@ function inventory(store: any,storeDir: any,fsImpl: any,shouldStop: any) {
   }
   return entries;
 }
-function sweepTombstones(fsImpl: any,storeDir: any,row: any) {
+function sweepTombstones(fsImpl     ,storeDir     ,row     ) {
   for (const name of fsImpl.readdirSync(storeDir)) {
     if (!TOMBSTONE.test(name)) continue;
     const target=path.join(storeDir,name);
@@ -49,13 +49,13 @@ function sweepTombstones(fsImpl: any,storeDir: any,row: any) {
       // Node's recursive rm removes nested links themselves, never their referents.
       fsImpl.rmSync(target,{recursive:true});
       row.removed++;
-    } catch (error: any) {
+    } catch (error     ) {
       if (error.code==='ENOENT') row.removed++;
       else row.failed.push({name,code:error.code || 'EIO'});
     }
   }
 }
-function removalOrder(candidates: any) {
+function removalOrder(candidates     ) {
   const oldest=[...candidates].sort((a,b)=>a.mtimeMs-b.mtimeMs || a.name.localeCompare(b.name));
   const byName=new Map(oldest.map(candidate=>[candidate.name,candidate])), emitted=new Set(), ordered=[];
   for (const candidate of oldest) {
@@ -67,9 +67,9 @@ function removalOrder(candidates: any) {
   }
   return ordered;
 }
-function removeOne(fsImpl: any,storeDir: any,candidate: any,store: any,context: any) {
+function removeOne(fsImpl     ,storeDir     ,candidate     ,store     ,context     ) {
   const parts=candidate.name.split('/');
-  if (parts.length>2 || parts.some((part: any)=>!part || part==='.' || part==='..')) throw Object.assign(new Error('unsafe name'),{code:'EINVAL'});
+  if (parts.length>2 || parts.some((part     )=>!part || part==='.' || part==='..')) throw Object.assign(new Error('unsafe name'),{code:'EINVAL'});
   const target=path.join(storeDir,...parts), lock=`${target}.lock`;
   let locked=false;
   try {
@@ -79,7 +79,7 @@ function removeOne(fsImpl: any,storeDir: any,candidate: any,store: any,context:
     }
     if (store.entry==='record') {
       try { fsImpl.mkdirSync(lock); locked=true; }
-      catch(error: any) { if (error.code==='EEXIST') return false; throw error; }
+      catch(error     ) { if (error.code==='EEXIST') return false; throw error; }
     }
     const info=fsImpl.lstatSync(target);
     if (info.isSymbolicLink()) return false;
@@ -104,14 +104,14 @@ function removeOne(fsImpl: any,storeDir: any,candidate: any,store: any,context:
     } else if (info.isFile()) fsImpl.unlinkSync(target);
     else return false;
     return true;
-  } catch(error: any) { if (error.code==='ENOENT') return true; throw error; }
+  } catch(error     ) { if (error.code==='ENOENT') return true; throw error; }
   finally {
     if (locked) {
-      try { fsImpl.rmdirSync(lock); } catch(error: any) { if (error.code!=='ENOENT') throw error; }
+      try { fsImpl.rmdirSync(lock); } catch(error     ) { if (error.code!=='ENOENT') throw error; }
     }
   }
 }
-function cleanEmptyNamespace(fsImpl: any,storeDir: any,name: any,report = false) {
+function cleanEmptyNamespace(fsImpl     ,storeDir     ,name     ,report = false) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) return;
   const dir=path.join(storeDir,name);
   try {
@@ -119,7 +119,7 @@ function cleanEmptyNamespace(fsImpl: any,storeDir: any,name: any,report = false)
     fsImpl.rmdirSync(dir);
   } catch { /* another record, or an active writer */ }
 }
-function projectKeyMarker(fsImpl: any,storeDir: any,roots: any) {
+function projectKeyMarker(fsImpl     ,storeDir     ,roots     ) {
   const project=projectRoot(roots);
   if (!project) return;
   let key;
@@ -129,15 +129,15 @@ function projectKeyMarker(fsImpl: any,storeDir: any,roots: any) {
   try { fsImpl.writeFileSync(path.join(dir,'.root'),`${fsImpl.realpathSync(project)}\n`,{flag:'wx'}); } catch { /* best effort */ }
 }
 /** A bounded pass over registry-declared stores; report mode never writes. */
-function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,maxRemovals,env=process.env,fsImpl=fs}: any) {
+function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,maxRemovals,env=process.env,fsImpl=fs}     ) {
   if (mode!=='report' && mode!=='prune') throw new Error('Storage pass mode must be report or prune');
   const started=performance.now(), budget=budgetMs===undefined?(mode==='report'?Infinity:registry.settings.passBudgetMs):budgetMs;
   const cap=maxRemovals===undefined?registry.settings.maxRemovalsPerPass:maxRemovals;
-  const requested=new Set(stores || registry.stores.filter((s: any)=>removableRules.has(s.rule)).map((s: any)=>s.id));
+  const requested=new Set(stores || registry.stores.filter((s     )=>removableRules.has(s.rule)).map((s     )=>s.id));
   const ordered=[...registry.stores].filter(s=>requested.has(s.id) && removableRules.has(s.rule))
     .sort((a,b)=>ruleOrder.indexOf(a.id)-ruleOrder.indexOf(b.id));
-  const result: any={mode,partial:false,durationMs:0,stores:[]};
-  let removals=0, protectedSet: any=null;
+  const result     ={mode,partial:false,durationMs:0,stores:[]};
+  let removals=0, protectedSet     =null;
   const shouldStop=()=>mode==='prune' && (removals>=cap || performance.now()-started>=budget);
   const project=projectRoot(roots);
   const workCache=project && ordered.some(s=>s.rule==='work' || s.protect==='open-work')
@@ -148,7 +148,7 @@ function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,
   for (const store of ordered) {
     const root=roots[store.root], storeSetting=typeof setting[store.root]==='string'?setting[store.root]:setting[store.root]?.setting || 'on';
     const location=root?path.join(root,...(store.path?store.path.split('/'):[])):'';
-    const row: any={id:store.id,root:root || '',location,bound:formatBound(store),setting:storeSetting,entries:0,bytes:0,selected:[],removed:0,protected:0,failed:[]};
+    const row     ={id:store.id,root:root || '',location,bound:formatBound(store),setting:storeSetting,entries:0,bytes:0,selected:[],removed:0,protected:0,failed:[]};
     result.stores.push(row);
     if (!root) { row.skipped='absent'; continue; }
     if (ownedPathLinked(store,roots,fsImpl) || resolveStorePath({store,roots,fsImpl})===null) { row.skipped='link'; continue; }
@@ -158,7 +158,7 @@ function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,
     if (mode==='prune' && storeSetting==='off' && explicitWindow.state!=='on') { row.skipped='setting-off'; continue; }
     if (mode==='prune') {
       try { sweepTombstones(fsImpl,location,row); }
-      catch(error: any) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
+      catch(error     ) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
     }
     ready.push({store,row,location,explicitWindow,storeSetting});
   }
@@ -166,7 +166,7 @@ function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,
     if (shouldStop()) { result.partial=true; break; }
     let entries;
     try { entries=inventory(store,location,fsImpl,shouldStop); }
-    catch(error: any) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
+    catch(error     ) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
     if (entries===null) { result.partial=true; break; }
     row.entries=entries.length;
     for (const entry of entries) {
@@ -184,17 +184,17 @@ function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,
         if (mode==='report') {
           let snapshot;
           try { snapshot=readEvents(project,{fsImpl,lockFallback:false,shouldStop}); }
-          catch(error: any) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
+          catch(error     ) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
           if (snapshot.incomplete) { result.partial=true; break; }
           if (snapshot.unreadable.length) { row.failed.push({name:store.id,code:'EIO'}); continue; }
           const selection=selectExpired(snapshot.events,{now:new Date(now),windowMs:window.ms,shouldStop});
           if (selection.incomplete) { result.partial=true; break; }
-          row.selected=selection.files.map((name: any)=>({name,reason:'settled',bytes:stat(fsImpl,path.join(location,name))?.size || 0}));
+          row.selected=selection.files.map((name     )=>({name,reason:'settled',bytes:stat(fsImpl,path.join(location,name))?.size || 0}));
         } else {
           let output;
           try { output=retainLocked(project,{fsImpl,now:new Date(now),window,maxFiles:Math.max(0,cap-removals),shouldStop}); }
-          catch(error: any) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
-          row.selected=output.selected.map(({name,bytes}: any)=>({name,reason:'settled',bytes}));
+          catch(error     ) { row.failed.push({name:store.id,code:error.code || 'EIO'}); continue; }
+          row.selected=output.selected.map(({name,bytes}     )=>({name,reason:'settled',bytes}));
           row.removed=output.removed; removals+=row.removed;
           if (output.warning.length) row.failed.push({name:store.id,code:output.code || 'EIO'});
           if (output.partial) { result.partial=true; break; }
@@ -205,7 +205,7 @@ function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,
     }
     let candidates;
     try { candidates=selectCandidates(store,entries,{registry,roots,fsImpl,storeDir:location,now,settings:registry.settings,shouldStop,cache:workCache}); }
-    catch(error: any) {
+    catch(error     ) {
       if (error.partial) { result.partial=true; break; }
       row.failed.push({name:store.id,code:error.code || 'EIO'}); continue;
     }
@@ -219,8 +219,8 @@ function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,
         }
         protectedSet=protection.names;
       }
-      row.protected=candidates.filter((c: any)=>protectedSet.has(c.name)).length;
-      candidates=candidates.filter((c: any)=>!protectedSet.has(c.name));
+      row.protected=candidates.filter((c     )=>protectedSet.has(c.name)).length;
+      candidates=candidates.filter((c     )=>!protectedSet.has(c.name));
     }
     const orderedCandidates=store.entry==='record' ? removalOrder(candidates)
       : [...candidates].sort((a,b)=>a.mtimeMs-b.mtimeMs || a.name.localeCompare(b.name));
@@ -238,7 +238,7 @@ function runPass({registry,roots,stores,mode,setting={},now=Date.now(),budgetMs,
           if (store.entry==='record' && candidate.name.includes('/')) cleanEmptyNamespace(fsImpl,location,candidate.name.split('/')[0]);
           if (store.rule==='report-orphan' && candidate.name.includes('/')) cleanEmptyNamespace(fsImpl,location,candidate.name.split('/')[0],true);
         }
-      } catch(error: any) { row.failed.push({name:candidate.name,code:error.code || 'EIO'}); }
+      } catch(error     ) { row.failed.push({name:candidate.name,code:error.code || 'EIO'}); }
     }
     if (store.rule==='report-orphan' && !result.partial) projectKeyMarker(fsImpl,location,roots);
     if (result.partial) break;

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

@@ -7,7 +7,7 @@ const path = require('node:path');
 
 const ROOT_BASES = new Set(['project', 'home', 'xdg-config']);
 const ENTRIES = new Set(['file', 'dir', 'record']);
-const RULES: Map<string, string[]> = new Map([
+const RULES                        = new Map([
   ['count-and-age', ['keepNewest', 'maxAgeDays']],
   ['work', ['finishedDays']],
   ['date-partition', ['maxAgeDays']],
@@ -21,13 +21,13 @@ const RULES: Map<string, string[]> = new Map([
 const MOMENTS = new Set(['verb', 'session', 'verify', 'install', 'lifecycle-verb', 'uninstall']);
 const STORE_ID = /^[a-z][a-z0-9-]*$/;
 
-function isObject(value: any): boolean { return value !== null && typeof value === 'object' && !Array.isArray(value); }
-function positiveInteger(value: any): boolean { return Number.isInteger(value) && value > 0; }
-function error(errors: string[], where: string, message: string): void { errors.push(`${where}: ${message}`); }
+function isObject(value     )          { return value !== null && typeof value === 'object' && !Array.isArray(value); }
+function positiveInteger(value     )          { return Number.isInteger(value) && value > 0; }
+function error(errors          , where        , message        )       { errors.push(`${where}: ${message}`); }
 
 /** Validates the closed IC-001 storage declaration document without touching the filesystem. */
-function validateStorageRegistry(registry: any): { ok: boolean; errors: string[] } {
-  const errors: string[] = [];
+function validateStorageRegistry(registry     )                                    {
+  const errors           = [];
   if (!isObject(registry)) return { ok: false, errors: ['registry: must be an object'] };
   if (registry.version !== 1) error(errors, 'version', 'must be 1');
   if (typeof registry.description !== 'string' || !registry.description.trim()) error(errors, 'description', 'must be a non-empty string');
@@ -39,28 +39,28 @@ function validateStorageRegistry(registry: any): { ok: boolean; errors: string[]
       if (!positiveInteger(settings[field])) error(errors, `settings.${field}`, 'must be a positive integer');
     }
     if (!isObject(settings.ignoreFile) || settings.ignoreFile.name !== '.gitignore'
-      || !Array.isArray(settings.ignoreFile.lines) || settings.ignoreFile.lines.some((line: any) => typeof line !== 'string')) {
+      || !Array.isArray(settings.ignoreFile.lines) || settings.ignoreFile.lines.some((line     ) => typeof line !== 'string')) {
       error(errors, 'settings.ignoreFile', 'must name .gitignore and contain string lines');
     }
   }
   const roots = registry.roots;
   if (!isObject(roots) || Object.keys(roots).length === 0) error(errors, 'roots', 'must be a non-empty object');
-  else for (const [id, root] of Object.entries(roots) as [string, any][]) {
+  else for (const [id, root] of Object.entries(roots)                   ) {
     if (!isObject(root) || !ROOT_BASES.has(root.base) || !Array.isArray(root.segments)
-      || root.segments.some((segment: any) => typeof segment !== 'string' || !segment || segment === '.' || segment === '..' || segment.includes('/') || segment.includes('\\'))) {
+      || root.segments.some((segment     ) => typeof segment !== 'string' || !segment || segment === '.' || segment === '..' || segment.includes('/') || segment.includes('\\'))) {
       error(errors, `roots.${id}`, 'must have a known base and safe path segments');
     }
   }
   if (!Array.isArray(registry.stores)) error(errors, 'stores', 'must be an array');
   else {
     const ids = new Set();
-    registry.stores.forEach((store: any, index: number) => {
+    registry.stores.forEach((store     , index        ) => {
       const where = `stores[${index}]`;
       if (!isObject(store)) { error(errors, where, 'must be an object'); return; }
       if (typeof store.id !== 'string' || !STORE_ID.test(store.id)) error(errors, `${where}.id`, 'must match ^[a-z][a-z0-9-]*$');
       else if (ids.has(store.id)) error(errors, `${where}.id`, `duplicate id '${store.id}'`); else ids.add(store.id);
       if (typeof store.root !== 'string' || !roots?.[store.root]) error(errors, `${where}.root`, 'must name a declared root');
-      if (typeof store.path !== 'string' || store.path.startsWith('/') || store.path.split('/').some((part: string) => part === '..' || !part && store.path !== '')) error(errors, `${where}.path`, 'must be relative, slash-separated, and contain no ..');
+      if (typeof store.path !== 'string' || store.path.startsWith('/') || store.path.split('/').some((part        ) => part === '..' || !part && store.path !== '')) error(errors, `${where}.path`, 'must be relative, slash-separated, and contain no ..');
       if (!ENTRIES.has(store.entry)) error(errors, `${where}.entry`, 'must be file, dir, or record');
       if (typeof store.match !== 'string' || !store.match.startsWith('^') || !store.match.endsWith('$')) error(errors, `${where}.match`, 'must be an anchored regular expression');
       else { try { new RegExp(store.match); } catch { error(errors, `${where}.match`, 'must compile'); } }
@@ -72,9 +72,9 @@ function validateStorageRegistry(registry: any): { ok: boolean; errors: string[]
         if (store.rule === 'existing' && store.bound.value !== undefined && !positiveInteger(store.bound.value)) error(errors, `${where}.bound.value`, 'must be a positive integer when present');
       }
       if (store.protect !== null && store.protect !== 'open-work') error(errors, `${where}.protect`, 'must be open-work or null');
-      if (!Array.isArray(store.moments) || store.moments.some((moment: any) => !MOMENTS.has(moment)) || new Set(store.moments).size !== store.moments.length) error(errors, `${where}.moments`, 'must be a unique subset of known moments');
+      if (!Array.isArray(store.moments) || store.moments.some((moment     ) => !MOMENTS.has(moment)) || new Set(store.moments).size !== store.moments.length) error(errors, `${where}.moments`, 'must be a unique subset of known moments');
       if (store.rule === 'existing' && store.moments?.length) error(errors, `${where}.moments`, 'must be empty for existing stores');
-      if (!Array.isArray(store.writers) || store.writers.some((writer: any) => typeof writer !== 'string' || !writer)) error(errors, `${where}.writers`, 'must be an array of repository-relative paths');
+      if (!Array.isArray(store.writers) || store.writers.some((writer     ) => typeof writer !== 'string' || !writer)) error(errors, `${where}.writers`, 'must be an array of repository-relative paths');
       else if (!store.writers.length && store.rule !== 'control' && !store.id.startsWith('user-settings-')) error(errors, `${where}.writers`, 'may be empty only for control or user-settings stores');
       if (store.rule === 'existing') {
         if (!isObject(store.source) || typeof store.source.file !== 'string' || !store.source.file
@@ -87,17 +87,17 @@ function validateStorageRegistry(registry: any): { ok: boolean; errors: string[]
     });
   }
   if (!Array.isArray(registry.externalWriters)) error(errors, 'externalWriters', 'must be an array');
-  else registry.externalWriters.forEach((writer: any, index: number) => {
+  else registry.externalWriters.forEach((writer     , index        ) => {
     if (!isObject(writer) || typeof writer.file !== 'string' || !writer.file || typeof writer.reason !== 'string' || !writer.reason.trim()) error(errors, `externalWriters[${index}]`, 'requires a file and non-empty reason');
   });
   return { ok: errors.length === 0, errors };
 }
 
 /** Loads and fails closed on an IC-001 storage registry. */
-function loadStorageRegistry({ repoRoot, file, fsImpl = fs }: any = {}): any {
+function loadStorageRegistry({ repoRoot, file, fsImpl = fs }      = {})      {
   const target = file || path.join(path.resolve(repoRoot || process.cwd()), 'core', 'registry', 'storage.json');
-  let registry: any;
-  try { registry = JSON.parse(fsImpl.readFileSync(target, 'utf8')); } catch (cause: any) { throw new Error(`Could not load storage registry '${target}': ${cause.message}`); }
+  let registry     ;
+  try { registry = JSON.parse(fsImpl.readFileSync(target, 'utf8')); } catch (cause     ) { throw new Error(`Could not load storage registry '${target}': ${cause.message}`); }
   const validation = validateStorageRegistry(registry);
   if (!validation.ok) throw new Error(`Invalid storage registry:\n- ${validation.errors.join('\n- ')}`);
   return registry;
@@ -105,13 +105,13 @@ function loadStorageRegistry({ repoRoot, file, fsImpl = fs }: any = {}): any {
 
 /** Renders IC-001's canonical human-readable bound for a store. */
 /** Renders an existing-store source pattern for G26's literal source check. */
-function renderSourcePattern(store: any): string {
+function renderSourcePattern(store     )         {
   const pattern = store?.source?.pattern;
   if (typeof pattern !== 'string') throw new Error('Existing store has no source pattern');
   return pattern.includes('{value}') ? pattern.replaceAll('{value}', String(store.bound.value)) : pattern;
 }
 
-function formatBound(store: any): string {
+function formatBound(store     )         {
   const bound = store.bound;
   switch (store.rule) {
     case 'count-and-age': return `keep newest ${bound.keepNewest}; prune entries older than ${bound.maxAgeDays} days`;

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

@@ -6,22 +6,22 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
-function absolute(value: any): string | null { return typeof value === 'string' && path.isAbsolute(value) ? value : null; }
+function absolute(value     )                { return typeof value === 'string' && path.isAbsolute(value) ? value : null; }
 
 /** Resolves IC-001's five physical roots; -g/global deliberately omits project roots. */
-function resolveRoots({ registry, projectRoot, global = false, env = process.env }: any = {}): Record<string, string | null> {
+function resolveRoots({ registry, projectRoot, global = false, env = process.env }      = {})                                {
   const home = absolute(env.HOME) || os.homedir();
   const xdgBase = env.XDG_CONFIG_HOME === undefined || env.XDG_CONFIG_HOME === ''
     ? path.join(home, '.config') : absolute(env.XDG_CONFIG_HOME);
   const project = global ? null : absolute(projectRoot);
-  const bases: Record<string, string | null> = { project, home, 'xdg-config': xdgBase };
-  return Object.fromEntries(Object.entries(registry.roots).map(([id, root]: [string, any]) => {
+  const bases                                = { project, home, 'xdg-config': xdgBase };
+  return Object.fromEntries(Object.entries(registry.roots).map(([id, root]               ) => {
     const base = bases[root.base];
     return [id, base ? path.join(base, ...root.segments) : null];
   }));
 }
 
-function readSetting(file: string, fsImpl: any): string {
+function readSetting(file        , fsImpl     )         {
   try {
     const first = fsImpl.readFileSync(file, 'utf8').split(/\r?\n/, 1)[0].trim().toLowerCase();
     return first === 'on' || first === 'off' ? first : 'off';
@@ -29,7 +29,7 @@ function readSetting(file: string, fsImpl: any): string {
 }
 
 /** Reads IC-014 and reports exactly which present file made the decision, if any. */
-function readPruneSetting({ registry, roots, rootId, fsImpl = fs }: any = {}): { setting: string; decidedBy: string | null } {
+function readPruneSetting({ registry, roots, rootId, fsImpl = fs }      = {})                                                {
   const projectFile = roots['project-doflow'] ? path.join(roots['project-doflow'], registry.settings.optOutFile) : null;
   const userFile = roots['config-home'] ? path.join(roots['config-home'], registry.settings.optOutFile) : null;
   const usesProject = rootId === 'project-doflow' || rootId === 'project-state';
@@ -38,7 +38,7 @@ function readPruneSetting({ registry, roots, rootId, fsImpl = fs }: any = {}): {
   return { setting: 'on', decidedBy: null };
 }
 
-function linked(file: string, fsImpl: any): boolean {
+function linked(file        , fsImpl     )          {
   try { return fsImpl.lstatSync(file).isSymbolicLink(); } catch { return false; }
 }
 
@@ -46,7 +46,7 @@ function linked(file: string, fsImpl: any): boolean {
  * Returns the physical directory for a declared store, or null when a DoFlow-owned component is a
  * link. The engine treats null as a refuse-to-touch result, never as a path to repair.
  */
-function resolveStorePath({ store, roots, fsImpl = fs }: any = {}): string | null {
+function resolveStorePath({ store, roots, fsImpl = fs }      = {})                {
   const root = roots[store.root];
   if (!root) return null;
   if (linked(root, fsImpl)) return null;

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': {