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

package/src/runtime/scaffold/{languages.ts → languages.js}

@@ -10,7 +10,7 @@
  * repository itself uses (for test stubs, which have no file extension of their own to read).
  */
 
-const { detectCommands } = require('../command-detect.ts');
+const { detectCommands } = require('../command-detect.js');
 
 /**
  * Per-file language comes from the file's own extension, because `plan.md` already states it:
@@ -22,7 +22,7 @@ const { detectCommands } = require('../command-detect.ts');
  * is this repository" — is `command-detect.ts`'s, so it is asked there rather than answered a
  * second time here. See `repoLanguage()` for the one place its output is interpreted.
  */
-const EXTENSION_LANGUAGE: Readonly<Record<string, string>> = Object.freeze({
+const EXTENSION_LANGUAGE                                   = Object.freeze({
   '.js': 'javascript',
   '.mjs': 'javascript',
   '.cjs': 'javascript',
@@ -41,7 +41,7 @@ const EXTENSION_LANGUAGE: Readonly<Record<string, string>> = Object.freeze({
  * generator — there is no signature to emit for a markdown file — so these skip benignly and never
  * push the run to a non-zero exit.
  */
-const PROSE_EXTENSIONS: ReadonlySet<string> = new Set([
+const PROSE_EXTENSIONS                      = new Set([
   '.md', '.markdown', '.txt', '.rst',
   '.yaml', '.yml', '.json', '.jsonc', '.toml', '.ini', '.cfg', '.conf', '.env', '.lock',
   '.html', '.css', '.scss', '.svg', '.png', '.jpg', '.gif', '.csv',
@@ -53,7 +53,7 @@ const PROSE_EXTENSIONS: ReadonlySet<string> = new Set([
  * plan that touches one produces "no emitter for Java", not silence — the gap is real and belongs
  * in the manifest, not in a reader's assumptions.
  */
-const UNEMITTED_SOURCE_EXTENSIONS: Readonly<Record<string, { name: string; inProseGrammar: boolean }>> = Object.freeze({
+const UNEMITTED_SOURCE_EXTENSIONS                                                                      = Object.freeze({
   '.java': { name: 'Java', inProseGrammar: true },
   '.kt': { name: 'Kotlin', inProseGrammar: true },
   '.kts': { name: 'Kotlin', inProseGrammar: true },
@@ -73,7 +73,7 @@ const UNEMITTED_SOURCE_EXTENSIONS: Readonly<Record<string, { name: string; inPro
 
 /** Splits an identifier-ish path segment into lowercase words, so every language can re-case it
  * to its own convention from one parse. */
-function words(name: string): string[] {
+function words(name        )           {
   return name
     .replace(/\.[^.]+$/, '')
     .split(/[^A-Za-z0-9]+/)
@@ -82,9 +82,9 @@ function words(name: string): string[] {
     .map((part) => part.toLowerCase());
 }
 
-const camel = (parts: string[]): string => parts.map((w, i) => (i === 0 ? w : w[0].toUpperCase() + w.slice(1))).join('') || 'scaffold';
-const pascal = (parts: string[]): string => parts.map((w) => w[0].toUpperCase() + w.slice(1)).join('') || 'Scaffold';
-const snake = (parts: string[]): string => parts.join('_') || 'scaffold';
+const camel = (parts          )         => parts.map((w, i) => (i === 0 ? w : w[0].toUpperCase() + w.slice(1))).join('') || 'scaffold';
+const pascal = (parts          )         => parts.map((w) => w[0].toUpperCase() + w.slice(1)).join('') || 'Scaffold';
+const snake = (parts          )         => parts.join('_') || 'scaffold';
 
 /**
  * One entry per language this module can emit. Each `module` and `test` body is a signature plus a
@@ -92,10 +92,10 @@ const snake = (parts: string[]): string => parts.join('_') || 'scaffold';
  * `references/scaffold.md` — the same table the external-dependency case uses, so the two halves of
  * that document agree on what an unimplemented body looks like.
  */
-const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
+const EMITTERS                                = Object.freeze({
   javascript: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message }     ) => [
       '/**',
       ' * Placeholder signature — replace with the real surface before implementing.',
       ' * @returns {never}',
@@ -106,11 +106,11 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
       '',
       `module.exports = { ${symbol} };`,
     ].join('\n'),
-    testName: (id: string) => `${id}.test.js`,
-    test: ({ id, cases, message }: any) => [
+    testName: (id        ) => `${id}.test.js`,
+    test: ({ id, cases, message }     ) => [
       "const { test } = require('node:test');",
       '',
-      ...cases.map(({ statement }: any) => [
+      ...cases.map(({ statement }     ) => [
         `test(${JSON.stringify(`${id} — ${statement}`)}, () => {`,
         `  throw new Error(${JSON.stringify(message)});`,
         '});',
@@ -120,18 +120,18 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   typescript: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message }     ) => [
       '/** Placeholder signature — replace with the real surface before implementing. */',
       `export function ${symbol}(): never {`,
       `  throw new Error(${JSON.stringify(message)});`,
       '}',
     ].join('\n'),
-    testName: (id: string) => `${id}.test.ts`,
-    test: ({ id, cases, message }: any) => [
+    testName: (id        ) => `${id}.test.ts`,
+    test: ({ id, cases, message }     ) => [
       "import { test } from 'node:test';",
       '',
-      ...cases.map(({ statement }: any) => [
+      ...cases.map(({ statement }     ) => [
         `test(${JSON.stringify(`${id} — ${statement}`)}, (): void => {`,
         `  throw new Error(${JSON.stringify(message)});`,
         '});',
@@ -141,14 +141,14 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   python: {
-    line: (t: string) => (t ? `# ${t}` : '#'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `# ${t}` : '#'),
+    module: ({ symbol, message }     ) => [
       `def ${symbol}() -> None:`,
       '    """Placeholder signature — replace with the real surface before implementing."""',
       `    raise NotImplementedError(${JSON.stringify(message)})`,
     ].join('\n'),
-    testName: (id: string) => `test_${id.toLowerCase().replace(/-/g, '_')}.py`,
-    test: ({ cases, message }: any) => cases.map(({ statement }: any, i: number) => [
+    testName: (id        ) => `test_${id.toLowerCase().replace(/-/g, '_')}.py`,
+    test: ({ cases, message }     ) => cases.map(({ statement }     , i        ) => [
       `def test_case_${i + 1}() -> None:`,
       `    """${statement.replace(/"/g, "'")}"""`,
       `    raise NotImplementedError(${JSON.stringify(message)})`,
@@ -157,8 +157,8 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   go: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message, pkg }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message, pkg }     ) => [
       `package ${pkg}`,
       '',
       'import "errors"',
@@ -168,13 +168,13 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
       `\treturn errors.New(${JSON.stringify(message)})`,
       '}',
     ].join('\n'),
-    testName: (id: string) => `${id.toLowerCase().replace(/-/g, '_')}_test.go`,
-    test: ({ id, cases, message, pkg }: any) => [
+    testName: (id        ) => `${id.toLowerCase().replace(/-/g, '_')}_test.go`,
+    test: ({ id, cases, message, pkg }     ) => [
       `package ${pkg}`,
       '',
       'import "testing"',
       '',
-      ...cases.map(({ statement }: any, i: number) => [
+      ...cases.map(({ statement }     , i        ) => [
         `// ${statement}`,
         `func Test${pascal(words(id))}Case${i + 1}(t *testing.T) {`,
         `\tt.Fatal(${JSON.stringify(message)})`,
@@ -185,15 +185,15 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   rust: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message }     ) => [
       '/// Placeholder signature — replace with the real surface before implementing.',
       `pub fn ${symbol}() {`,
       `    unimplemented!(${JSON.stringify(message)});`,
       '}',
     ].join('\n'),
-    testName: (id: string) => `${id.toLowerCase().replace(/-/g, '_')}.rs`,
-    test: ({ id, cases, message }: any) => cases.map(({ statement }: any, i: number) => [
+    testName: (id        ) => `${id.toLowerCase().replace(/-/g, '_')}.rs`,
+    test: ({ id, cases, message }     ) => cases.map(({ statement }     , i        ) => [
       `// ${statement}`,
       '#[test]',
       `fn ${snake(words(id))}_case_${i + 1}() {`,
@@ -212,12 +212,12 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
  * TypeScript. The one extra bit is read from its own output (a `typecheck` role exists only when a
  * tsc script or a `tsconfig.json` was found), so no second detector is introduced.
  */
-function repoLanguage(repoRoot: string, fsImpl: any): any {
+function repoLanguage(repoRoot        , fsImpl     )      {
   const detected = detectCommands({ projectRoot: repoRoot, fsImpl });
   if (!detected.manifestFound) {
     return { id: null, signal: 'none', why: 'no build manifest found by command-detect.ts' };
   }
-  const has = (name: string) => detected.manifests.includes(name);
+  const has = (name        ) => detected.manifests.includes(name);
   if (has('package.json')) {
     const typescript = Boolean(detected.commands.typecheck);
     return { id: typescript ? 'typescript' : 'javascript', signal: 'package.json', why: null };

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

@@ -4,13 +4,13 @@
 
 const path = require('node:path');
 const fs = require('node:fs');
-const { loadStorageRegistry } = require('./registry.ts');
-const { resolveRoots, readPruneSetting } = require('./roots.ts');
-const { runPass } = require('./engine.ts');
-const { upkeepAfterVerb } = require('./upkeep.ts');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
+const { loadStorageRegistry } = require('./registry.js');
+const { resolveRoots, readPruneSetting } = require('./roots.js');
+const { runPass } = require('./engine.js');
+const { upkeepAfterVerb } = require('./upkeep.js');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
 
-function handleStorageCommand({ action = 'report', json = false, global = false, projectRoot = '.', env = process.env, fsImpl = fs }: any = {}) {
+function handleStorageCommand({ action = 'report', json = false, global = false, projectRoot = '.', env = process.env, fsImpl = fs }      = {}) {
   if (!['report', 'prune', 'upkeep'].includes(action)) {
     console.error(`doflow storage: unknown action '${action}' (expected report, prune, or upkeep)`);
     process.exitCode = 2;
@@ -23,7 +23,7 @@ function handleStorageCommand({ action = 'report', json = false, global = false,
   }
   let registry;
   try { registry = loadStorageRegistry({ repoRoot: REPO_ROOT, fsImpl }); }
-  catch (error: any) {
+  catch (error     ) {
     console.error(`doflow storage: storage registry unavailable${error.message ? `: ${error.message}` : ''}`);
     process.exitCode = 2;
     return;
@@ -35,7 +35,7 @@ function handleStorageCommand({ action = 'report', json = false, global = false,
     readPruneSetting({ registry, roots, rootId, fsImpl })]));
   const mode = action === 'prune' ? 'prune' : 'report';
   const result = runPass({ registry, roots, mode, setting, now: Date.now(), env, fsImpl });
-  const removed = result.stores.reduce((sum: any, row: any) => sum + row.removed, 0);
+  const removed = result.stores.reduce((sum     , row     ) => sum + row.removed, 0);
   const entries = `entr${removed === 1 ? 'y' : 'ies'}`;
   if (action === 'prune' && Object.values(setting).every(value => value.setting === 'off')) {
     const decision = projectSetting.decidedBy || userSetting.decidedBy || path.join(roots['config-home'], registry.settings.optOutFile);
@@ -54,7 +54,7 @@ function handleStorageCommand({ action = 'report', json = false, global = false,
   }
   console.log(`Settings: project ${projectSetting.setting}${projectSetting.decidedBy ? ` (${projectSetting.decidedBy})` : ' (default)'}; user ${userSetting.setting}${userSetting.decidedBy ? ` (${userSetting.decidedBy})` : ' (default)'}`);
   for (const row of result.stores) {
-    const names = row.selected.slice(0, 20).map((entry: any) => entry.name);
+    const names = row.selected.slice(0, 20).map((entry     ) => entry.name);
     const more = row.selected.length > 20 ? `\n    ... and ${row.selected.length - 20} more` : '';
     console.log(`${row.id}\n  Location: ${row.location || '(not configured)'}\n  Entries: ${row.entries}; size: ${row.bytes} bytes\n  Bound: ${row.bound}\n  Would remove: ${row.selected.length}${names.length ? `\n    ${names.join('\n    ')}` : ''}${more}`);
   }

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;