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

package/src/runtime/lifecycle/{status.ts → status.js}

@@ -29,17 +29,17 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
-const { resolveBashHelper } = require('../../helper/bash-helper.ts');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+const { resolveBashHelper } = require('../../helper/bash-helper.js');
 
 const MAX_BUFFER = 256 * 1024 * 1024;
 
 /** Where `do-git-state.sh` is: the shared resolver (package copy first, else the one projected beside the runtime). */
-function resolveGitStateHelper(repoRoot: string = REPO_ROOT, existsImpl: (file: string) => boolean = fs.existsSync): string | null {
+function resolveGitStateHelper(repoRoot         = REPO_ROOT, existsImpl                            = fs.existsSync)                {
   return resolveBashHelper('do-git-state.sh', repoRoot, existsImpl);
 }
 
-function git(root: string, args: string[]): string {
+function git(root        , args          )         {
   return execFileSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: MAX_BUFFER, stdio: ['ignore', 'pipe', 'ignore'] });
 }
 
@@ -49,7 +49,7 @@ function git(root: string, args: string[]): string {
  * @returns {{integration_ref:string|null, feature_prefixes:string[], release_tags:string[], base_tag:string|null}
  *   |{error:string}}
  */
-function readGitFacts(root: string, runtimeRoot: string = REPO_ROOT): any {
+function readGitFacts(root        , runtimeRoot         = REPO_ROOT)      {
   const helper = resolveGitStateHelper(runtimeRoot);
   if (!helper) return { error: 'git-state-helper-missing' };
   try {
@@ -57,20 +57,20 @@ function readGitFacts(root: string, runtimeRoot: string = REPO_ROOT): any {
     const facts = JSON.parse(out);
     if (facts.error) return { error: facts.error };
     return facts;
-  } catch (error: any) {
+  } catch (error     ) {
     return { error: error.code === 'ENOENT' ? 'bash-not-found' : 'git-state-failed' };
   }
 }
 
-function escapeRegExp(text: string): string { return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function escapeRegExp(text        )         { return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 
 /** The slug appears in the subject bounded by its ends or by characters outside `[a-z0-9-]`. */
-function subjectNames(subject: string, slug: string): boolean {
+function subjectNames(subject        , slug        )          {
   return new RegExp(`(?:^|[^a-z0-9-])${escapeRegExp(slug)}(?:$|[^a-z0-9-])`).test(subject);
 }
 
 /** First-parent merges of `ref`, oldest first. */
-function readMerges(root: string, ref: string): Array<{ sha: string; parents: string[]; ct: number; subject: string }> {
+function readMerges(root        , ref        )                                                                         {
   const out = git(root, ['log', '--first-parent', '--merges', '--format=%H%x09%P%x09%ct%x09%s', ref]);
   return out.split('\n').filter(Boolean).map((line) => {
     const [sha, parents, ct, ...subject] = line.split('\t');
@@ -79,9 +79,9 @@ function readMerges(root: string, ref: string): Array<{ sha: string; parents: st
 }
 
 /** Branch refs by short name (`feat/x`, `origin/feat/x`) with their tips; local branches first. */
-function readBranchTips(root: string): Array<{ short: string; local: string; sha: string }> {
+function readBranchTips(root        )                                                       {
   const out = git(root, ['for-each-ref', '--format=%(refname)%09%(objectname)', 'refs/heads', 'refs/remotes']);
-  const tips: Array<{ short: string; local: string; sha: string }> = [];
+  const tips                                                       = [];
   for (const line of out.split('\n').filter(Boolean)) {
     const [refname, sha] = line.split('\t');
     if (refname.startsWith('refs/heads/')) tips.push({ short: refname.slice('refs/heads/'.length), local: refname.slice('refs/heads/'.length), sha });
@@ -94,7 +94,7 @@ function readBranchTips(root: string): Array<{ short: string; local: string; sha
 }
 
 /** The commit a tag names, peeled through any number of tag objects, or null when it is no commit. */
-function peelTag(root: string, refname: string): string | null {
+function peelTag(root        , refname        )                {
   try { return git(root, ['rev-parse', '--verify', '--quiet', `${refname}^{commit}`]).trim() || null; } catch { return null; }
 }
 
@@ -103,14 +103,14 @@ function peelTag(root: string, refname: string): string | null {
  * `tag.sort`, as `git tag --contains` did), so the first containing tag is the one it would name.
  * @returns {Array<{name:string, commit:string|null}>}
  */
-function readTagCommits(root: string, wanted: Set<string>): Array<{ name: string; commit: string | null }> {
+function readTagCommits(root        , wanted             )                                                 {
   const out = git(root, ['tag', '--list', 'v*', '--format=%(refname)%09%(objecttype)%09%(objectname)%09%(*objecttype)%09%(*objectname)']);
-  const tags: Array<{ name: string; commit: string | null }> = [];
+  const tags                                                 = [];
   for (const line of out.split('\n').filter(Boolean)) {
     const [refname, type, object, peeledType, peeled] = line.split('\t');
     const name = refname.slice('refs/tags/'.length);
     if (!wanted.has(name)) continue;
-    let commit: string | null = null;
+    let commit                = null;
     if (type === 'commit') commit = object;
     else if (type === 'tag' && peeledType === 'commit') commit = peeled;
     else if (type === 'tag') commit = peelTag(root, refname); // a tag of a tag: rare, one call each
@@ -134,53 +134,53 @@ function readTagCommits(root: string, wanted: Set<string>): Array<{ name: string
  * @param {string} pinned a full commit sha
  * @param {string[]} [revs] further full commit shas whose history is read too
  */
-function readHistory(root: string, pinned: string, revs: string[] = []): { introducer: (sha: string) => string | undefined; isAncestor: (a: string, b: string) => boolean } {
+function readHistory(root        , pinned        , revs           = [])                                                                                                     {
   const input = `${[pinned, ...revs].join('\n')}\n`;
   const out = execFileSync('git', ['rev-list', '--parents', '--topo-order', '--stdin'], { cwd: root, input, encoding: 'utf8', maxBuffer: MAX_BUFFER, stdio: ['pipe', 'pipe', 'ignore'] });
-  const parents = new Map<string, string[]>();
-  const order: string[] = [];
+  const parents = new Map                  ();
+  const order           = [];
   for (const line of out.split('\n')) {
     if (!line) continue;
     const [sha, ...rest] = line.split(' ');
     parents.set(sha, rest);
     order.push(sha);
   }
-  const chain: string[] = [];
-  for (let sha = pinned; parents.has(sha); sha = (parents.get(sha) as string[])[0]) chain.push(sha);
+  const chain           = [];
+  for (let sha = pinned; parents.has(sha); sha = (parents.get(sha)            )[0]) chain.push(sha);
   chain.reverse();
-  const chainIndex = new Map<string, number>(chain.map((sha, i): [string, number] => [sha, i]));
+  const chainIndex = new Map                (chain.map((sha, i)                   => [sha, i]));
 
-  const introducer = new Map<string, string>();
+  const introducer = new Map                ();
   for (const head of chain) {
-    const stack: string[] = [head];
+    const stack           = [head];
     while (stack.length) {
-      const sha = stack.pop() as string;
+      const sha = stack.pop()          ;
       if (introducer.has(sha) || !parents.has(sha)) continue;
       introducer.set(sha, head);
-      stack.push(...(parents.get(sha) as string[]));
+      stack.push(...(parents.get(sha)            ));
     }
   }
 
   // --topo-order lists no parent before its children, so walking it backwards meets parents first.
-  const chainMax = new Map<string, number>();
+  const chainMax = new Map                ();
   for (let i = order.length - 1; i >= 0; i -= 1) {
     const sha = order[i];
-    let max: number = chainIndex.has(sha) ? (chainIndex.get(sha) as number) : -1;
-    if (max === -1) for (const parent of parents.get(sha) as string[]) max = Math.max(max, chainMax.get(parent) ?? -1);
+    let max         = chainIndex.has(sha) ? (chainIndex.get(sha)          ) : -1;
+    if (max === -1) for (const parent of parents.get(sha)            ) max = Math.max(max, chainMax.get(parent) ?? -1);
     chainMax.set(sha, max);
   }
 
-  const reached = new Map<string, Set<string>>();
-  function ancestorsOf(sha: string): Set<string> {
+  const reached = new Map                     ();
+  function ancestorsOf(sha        )              {
     let seen = reached.get(sha);
     if (seen) return seen;
-    seen = new Set<string>();
-    const stack: string[] = [sha];
+    seen = new Set        ();
+    const stack           = [sha];
     while (stack.length) {
-      const next = stack.pop() as string;
+      const next = stack.pop()          ;
       if (seen.has(next) || !parents.has(next)) continue;
       seen.add(next);
-      stack.push(...(parents.get(next) as string[]));
+      stack.push(...(parents.get(next)            ));
     }
     reached.set(sha, seen);
     return seen;
@@ -188,9 +188,9 @@ function readHistory(root: string, pinned: string, revs: string[] = []): { intro
 
   return {
     /** The chain commit that brought `sha` into `pinned`'s history, or undefined when it is not in it. */
-    introducer: (sha: string) => introducer.get(sha),
+    introducer: (sha        ) => introducer.get(sha),
     /** `a` is `b` or an ancestor of it; `a` must be in the read. */
-    isAncestor(a: string, b: string): boolean {
+    isAncestor(a        , b        )          {
       const index = chainIndex.get(a);
       if (index !== undefined) return index <= (chainMax.get(b) ?? -1);
       return ancestorsOf(b).has(a);
@@ -205,17 +205,17 @@ function readHistory(root: string, pinned: string, revs: string[] = []): { intro
  * (a fast-forward, or a branch with no commits of its own) is its own introducer, so it never counts;
  * a tip the merge holds but its first parent does not came in on a non-first parent.
  */
-function introducingMerge(history: () => any, mergeBySha: Map<string, any>, tip: string, lowerBound: number): any {
+function introducingMerge(history           , mergeBySha                  , tip        , lowerBound        )      {
   const merge = mergeBySha.get(history().introducer(tip));
   if (!merge || merge.sha === tip || merge.ct < lowerBound) return null;
   return merge;
 }
 
 /** Evidence of a merge of `slug` into the pinned ref, tried in IC-021's order, or null. */
-function findEvidence({ slug, lowerBound, merges, mergeBySha, newestCt, history, tips, prefixes, confirmed }: any): { kind: string; ref: string | null; commit: string | null } | null {
-  const branchNames = new Set(prefixes.map((prefix: string) => `${prefix}/${slug}`));
+function findEvidence({ slug, lowerBound, merges, mergeBySha, newestCt, history, tips, prefixes, confirmed }     )                                                                     {
+  const branchNames = new Set(prefixes.map((prefix        ) => `${prefix}/${slug}`));
   // No merge is recent enough for this feature: no branch can have one, so the graph need not be read for it.
-  const branchTips = newestCt < lowerBound ? [] : tips.filter((t: any) => branchNames.has(t.local));
+  const branchTips = newestCt < lowerBound ? [] : tips.filter((t     ) => branchNames.has(t.local));
   for (const tip of branchTips) {
     const merge = introducingMerge(history, mergeBySha, tip.sha, lowerBound);
     if (merge) return { kind: 'branch', ref: tip.short, commit: merge.sha };
@@ -228,8 +228,8 @@ function findEvidence({ slug, lowerBound, merges, mergeBySha, newestCt, history,
 }
 
 /** A value computed on first use, so a call that needs no graph never reads one. */
-function lazy<T>(make: () => T): () => T {
-  let value: T;
+function lazy   (make         )          {
+  let value   ;
   let made = false;
   return () => {
     if (!made) { value = make(); made = true; }
@@ -237,12 +237,12 @@ function lazy<T>(make: () => T): () => T {
   };
 }
 
-const BUCKET: Record<string, string> = { finished: 'finished', 'awaiting-release': 'awaitingRelease', 'in-progress': 'inProgress', unknown: 'unknown' };
+const BUCKET                         = { finished: 'finished', 'awaiting-release': 'awaitingRelease', 'in-progress': 'inProgress', unknown: 'unknown' };
 
-function emptyBuckets(): Record<string, string[]> { return { finished: [], awaitingRelease: [], inProgress: [], unknown: [] }; }
+function emptyBuckets()                           { return { finished: [], awaitingRelease: [], inProgress: [], unknown: [] }; }
 
 /** Slugs grouped in the four buckets IC-007 and IC-022 show. */
-function bucketize(statuses: any, slugs: string[] = Object.keys(statuses)): Record<string, string[]> {
+function bucketize(statuses     , slugs           = Object.keys(statuses))                           {
   const buckets = emptyBuckets();
   for (const slug of slugs) {
     const entry = statuses[slug];
@@ -251,12 +251,12 @@ function bucketize(statuses: any, slugs: string[] = Object.keys(statuses)): Reco
   return buckets;
 }
 
-function result(releaseMode: string, integrationRef: string | null, reason: string | null, statuses: any, notDetected: string[] = [], behind: number = 0): any {
+function result(releaseMode        , integrationRef               , reason               , statuses     , notDetected           = [], behind         = 0)      {
   return { releaseMode, integrationRef, integrationBehind: behind, reason, statuses, features: bucketize(statuses), notDetected };
 }
 
 /** The one-line note a stale local integration branch earns (DEC-044), or null. */
-function behindNote(ref: string, behind: number): string | null {
+function behindNote(ref        , behind        )                {
   return behind > 0
     ? `local ${ref} is ${behind} commit${behind === 1 ? '' : 's'} behind origin/${ref}; a merge that exists only on origin is not seen until you pull`
     : null;
@@ -277,10 +277,10 @@ function behindNote(ref: string, behind: number): string | null {
  *   failure?:string (git, or the git-facts helper, failed while deriving: `git-state-failed`, `bash-not-found`,
  *   `git-state-helper-missing`; an environment fault, so every status is `unknown`)}}
  */
-function deriveStatuses({ root, fold, facts = readGitFacts(root) }: { root: string; fold: any; facts?: any }): any {
+function deriveStatuses({ root, fold, facts = readGitFacts(root) }                                          )      {
   const tracked = fold.features;
-  const unknown = (reason: string) => result('unknown', facts.integration_ref ?? null, reason,
-    Object.fromEntries(tracked.map((f: any) => [f.slug, { status: 'unknown', evidence: null, release: null }])));
+  const unknown = (reason        ) => result('unknown', facts.integration_ref ?? null, reason,
+    Object.fromEntries(tracked.map((f     ) => [f.slug, { status: 'unknown', evidence: null, release: null }])));
   if (facts.error) return { ...unknown(`git facts unavailable: ${facts.error}`), failure: facts.error };
   if (!facts.integration_ref) return unknown('no integration ref resolves (develop, main, master, origin/HEAD)');
 
@@ -297,21 +297,21 @@ function deriveStatuses({ root, fold, facts = readGitFacts(root) }: { root: stri
     // Pin the ref once: every query below names the same commit.
     const pinned = git(root, ['rev-parse', '--verify', `${ref}^{commit}`]).trim();
     const merges = readMerges(root, pinned);
-    const mergeBySha = new Map(merges.map((m): [string, any] => [m.sha, m]));
+    const mergeBySha = new Map(merges.map((m)                => [m.sha, m]));
     const newestCt = merges.reduce((max, m) => Math.max(max, m.ct), -Infinity);
     const tips = readBranchTips(root);
-    const mergedSlugs = new Set<string>(fold.merged.map((m: any) => m.slug));
-    const recorded = new Map<string, string>();
+    const mergedSlugs = new Set        (fold.merged.map((m     ) => m.slug));
+    const recorded = new Map                ();
     for (const release of fold.releases) for (const f of release.features) if (!recorded.has(f.slug)) recorded.set(f.slug, release.tag);
-    const recordedTags = new Set(fold.releases.map((r: any) => r.tag));
-    const unrecordedTags = new Set<string>(facts.release_tags.filter((tag: string) => !recordedTags.has(tag)));
+    const recordedTags = new Set(fold.releases.map((r     ) => r.tag));
+    const unrecordedTags = new Set        (facts.release_tags.filter((tag        ) => !recordedTags.has(tag)));
     // Only a tag with no release record can finish a feature by containment (DEC-030), so only those are read.
     const tags = lazy(() => (releaseMode === 'tagged' && unrecordedTags.size > 0 ? readTagCommits(root, unrecordedTags) : []));
-    const history = lazy(() => readHistory(root, pinned, tags().map((t) => t.commit).filter(Boolean) as string[]));
+    const history = lazy(() => readHistory(root, pinned, tags().map((t) => t.commit).filter(Boolean)            ));
 
-    const statuses: Record<string, any> = {};
-    const evidenceCommits: Record<string, string | null> = {};
-    const notDetected: string[] = [];
+    const statuses                      = {};
+    const evidenceCommits                                = {};
+    const notDetected           = [];
     for (const feature of tracked) {
       const lowerBound = Math.floor(Date.parse(feature.trackedAt) / 1000);
       const evidence = findEvidence({
@@ -319,20 +319,20 @@ function deriveStatuses({ root, fold, facts = readGitFacts(root) }: { root: stri
       });
       const shown = evidence && { kind: evidence.kind, ref: evidence.ref };
       evidenceCommits[feature.slug] = evidence ? evidence.commit : null;
-      let status: string;
-      let release: string | null = null;
+      let status        ;
+      let release                = null;
       if (releaseMode === 'untagged') {
         status = evidence ? 'finished' : 'in-progress';
       } else if (recorded.has(feature.slug)) {
         // A record finishes the feature by itself: no containment is looked for.
         status = 'finished';
-        release = recorded.get(feature.slug) as string;
+        release = recorded.get(feature.slug)          ;
       } else {
         // DEC-030: a merge inside a `v*` tag that has no release record also finishes the feature. A
         // tag with a record uses only that record, and a feature excluded from it is already outside it.
         // The evidence commit is a first-parent merge of the pinned ref, so it is in the graph read.
         const containing = evidence && evidence.commit && unrecordedTags.size > 0
-          ? tags().filter((t) => t.commit && history().isAncestor(evidence.commit as string, t.commit as string)).map((t) => t.name)
+          ? tags().filter((t) => t.commit && history().isAncestor(evidence.commit          , t.commit          )).map((t) => t.name)
           : [];
         if (containing.length > 0) { status = 'finished'; release = containing[0]; }
         else status = evidence ? 'awaiting-release' : 'in-progress';
@@ -343,7 +343,7 @@ function deriveStatuses({ root, fold, facts = readGitFacts(root) }: { root: stri
     // `integrationSha` and `evidenceCommits` are for the release preview, which must use the very commit
     // pinned here (DEC-044) and the full merge commit an evidence names, not its 7-character `ref`.
     return { ...result(releaseMode, ref, null, statuses, notDetected, behind), integrationSha: pinned, evidenceCommits };
-  } catch (error: any) {
+  } catch (error     ) {
     // A git failure is an environment fault, not a DoFlow defect: it is reported, never thrown.
     // `failure` tells a caller git itself failed, which it reports (overview) or refuses on (release, merged).
     return { ...unknown(`git could not answer (git-state-failed): ${String(error.message).split('\n')[0]}`), failure: 'git-state-failed' };

package/src/runtime/lifecycle/{store-upkeep.ts → store-upkeep.js}

@@ -24,11 +24,11 @@
 
 const nodeFs = require('node:fs');
 const path = require('node:path');
-const { acquireLock, tryAcquireLock } = require('../task-state.ts');
+const { acquireLock, tryAcquireLock } = require('../task-state.js');
 const {
   EVENTS_REL, LIFECYCLE_REL, JOURNAL_REL, lockTarget, isEventName, randomChars, readEvents, readJournal, StoreUnsafeError,
-} = require('./event-store.ts');
-const { retentionWindow, selectExpired } = require('./retention.ts');
+} = require('./event-store.js');
+const { retentionWindow, selectExpired } = require('./retention.js');
 
 const LEGACY_LIFECYCLE_REL = path.join('agent-docs', 'lifecycle');
 const LEGACY_EVENTS_REL = path.join(LEGACY_LIFECYCLE_REL, 'events');
@@ -36,30 +36,30 @@ const LEGACY_EVENTS_REL = path.join(LEGACY_LIFECYCLE_REL, 'events');
 const MARKER_REL = path.join(LIFECYCLE_REL, 'migrated.json');
 const MIGRATING_PREFIX = 'events.migrating-';
 const NOTICE = 'note: the lifecycle store is now .doflow/state/lifecycle/events; agent-docs/lifecycle/ is no longer read and can be deleted';
-const removedLine = (count: any, hours: any) => `retention: removed ${count} event files older than ${hours} h`;
-const invalidLine = (raw: any) => `warning: DOFLOW_RETENTION_HOURS='${raw}' is not a positive whole number of hours; ignored, nothing removed`;
+const removedLine = (count     , hours     ) => `retention: removed ${count} event files older than ${hours} h`;
+const invalidLine = (raw     ) => `warning: DOFLOW_RETENTION_HOURS='${raw}' is not a positive whole number of hours; ignored, nothing removed`;
 /** Bounds one pass, so its journal stays far below the reader's cap and its lock is held briefly. */
 const MAX_PASS_FILES = 20000;
 /** Unlinks between two refreshes of the lock's age. */
 const REFRESH_EVERY = 500;
-const unwritableLine = (code: any) => `warning: retention skipped: .doflow/state/lifecycle cannot be written (${code}); nothing was hidden or removed`;
-const unlinkLine = (code: any) => `warning: retention could not remove every file (${code}); they stay hidden and the next lifecycle command finishes the removal`;
+const unwritableLine = (code     ) => `warning: retention skipped: .doflow/state/lifecycle cannot be written (${code}); nothing was hidden or removed`;
+const unlinkLine = (code     ) => `warning: retention could not remove every file (${code}); they stay hidden and the next lifecycle command finishes the removal`;
 
-function lstatOrNull(fsImpl: any, file: any) {
+function lstatOrNull(fsImpl     , file     ) {
   try { return fsImpl.lstatSync(file); } catch { return null; }
 }
 
 /** The names in a folder, or none when it is absent or not a folder. */
-function namesIn(fsImpl: any, dir: any) {
+function namesIn(fsImpl     , dir     ) {
   try {
     return fsImpl.readdirSync(dir).sort();
-  } catch (error: any) {
+  } catch (error     ) {
     if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return [];
     throw error;
   }
 }
 
-function refuseLinks(fsImpl: any, root: any, rels: any) {
+function refuseLinks(fsImpl     , root     , rels     ) {
   for (const rel of rels) {
     const folder = path.join(root, rel);
     const st = lstatOrNull(fsImpl, folder);
@@ -68,21 +68,21 @@ function refuseLinks(fsImpl: any, root: any, rels: any) {
 }
 
 /** The event files of the old folder that a copy takes: event-named regular files, nothing else. */
-function legacyEventFiles(fsImpl: any, root: any) {
+function legacyEventFiles(fsImpl     , root     ) {
   const dir = path.join(root, LEGACY_EVENTS_REL);
   const st = lstatOrNull(fsImpl, dir);
   if (!st || !st.isDirectory()) return [];
-  return namesIn(fsImpl, dir).filter((name: any) => {
+  return namesIn(fsImpl, dir).filter((name     ) => {
     if (!isEventName(name)) return false;
     const entry = lstatOrNull(fsImpl, path.join(dir, name));
     return Boolean(entry && entry.isFile());
   });
 }
 
-const hasMarker = (fsImpl: any, root: any) => lstatOrNull(fsImpl, path.join(root, MARKER_REL)) !== null;
-const storeHasEvents = (fsImpl: any, root: any) => namesIn(fsImpl, path.join(root, EVENTS_REL)).some(isEventName);
+const hasMarker = (fsImpl     , root     ) => lstatOrNull(fsImpl, path.join(root, MARKER_REL)) !== null;
+const storeHasEvents = (fsImpl     , root     ) => namesIn(fsImpl, path.join(root, EVENTS_REL)).some(isEventName);
 
-function removeQuietly(fsImpl: any, target: any) {
+function removeQuietly(fsImpl     , target     ) {
   try { fsImpl.rmSync(target, { recursive: true, force: true }); } catch { /* best effort */ }
 }
 
@@ -90,26 +90,26 @@ function removeQuietly(fsImpl: any, target: any) {
  * Flushes one copied file. The copy takes the source's mode, so it is made writable by its owner
  * first, like any file the store writes: Windows refuses to flush a read-only handle.
  */
-function fsyncCopy(fsImpl: any, file: any) {
+function fsyncCopy(fsImpl     , file     ) {
   fsImpl.chmodSync(file, 0o644);
   const fd = fsImpl.openSync(file, 'r+');
   try { fsImpl.fsyncSync(fd); } finally { fsImpl.closeSync(fd); }
 }
 
 /** Flushes a folder's entries where the platform lets a folder be opened. */
-function fsyncFolder(fsImpl: any, dir: any) {
+function fsyncFolder(fsImpl     , dir     ) {
   let fd;
   try { fd = fsImpl.openSync(dir, 'r'); } catch { return; }
   try { fsImpl.fsyncSync(fd); } finally { fsImpl.closeSync(fd); }
 }
 
-const migrationFailed = (code: any) => ({
+const migrationFailed = (code     ) => ({
   ok: false,
   finding: 'store-migration-failed',
   message: `could not copy agent-docs/lifecycle/events to .doflow/state/lifecycle/events (${code}); the old folder is unchanged and the next lifecycle command retries. Nothing was written.`,
   lines: [],
 });
-const legacyUnreadable = (code: any) => ({
+const legacyUnreadable = (code     ) => ({
   ok: false,
   finding: 'store-migration-failed',
   message: `could not list agent-docs/lifecycle/events (${code}), so the old store cannot be copied to .doflow/state/lifecycle/events; make the folder readable, or delete it if its events are not needed, and the next lifecycle command retries. Nothing was written.`,
@@ -117,7 +117,7 @@ const legacyUnreadable = (code: any) => ({
 });
 
 /** Writes `text` to `file` by a flushed temp file in the same folder and a rename. */
-function writeAtomic(fsImpl: any, file: any, text: any) {
+function writeAtomic(fsImpl     , file     , text     ) {
   const dir = path.dirname(file);
   const tmp = path.join(dir, `.${path.basename(file, '.json')}-${process.pid}-${randomChars(6)}.tmp`);
   try {
@@ -129,7 +129,7 @@ function writeAtomic(fsImpl: any, file: any, text: any) {
       fsImpl.closeSync(fd);
     }
     fsImpl.renameSync(tmp, file);
-  } catch (error: any) {
+  } catch (error     ) {
     try { fsImpl.unlinkSync(tmp); } catch { /* never written */ }
     throw error;
   }
@@ -137,7 +137,7 @@ function writeAtomic(fsImpl: any, file: any, text: any) {
 }
 
 /** Records that the store is in place; false when it cannot be written, so a later verb tries again. */
-function writeMarker(fsImpl: any, root: any, copied: any, now: any) {
+function writeMarker(fsImpl     , root     , copied     , now     ) {
   try {
     writeAtomic(fsImpl, path.join(root, MARKER_REL), `${JSON.stringify({ v: 1, from: 'agent-docs/lifecycle/events', copied, at: now.toISOString() })}\n`);
     return true;
@@ -150,7 +150,7 @@ function writeMarker(fsImpl: any, root: any, copied: any, now: any) {
  * The copy itself, under the store lock, of the event files the caller listed. Returns the number
  * copied, or the `store-migration-failed` refusal.
  */
-function copyLegacyStore(fsImpl: any, root: any, files: any) {
+function copyLegacyStore(fsImpl     , root     , files     ) {
   const lifecycleDir = path.join(root, LIFECYCLE_REL);
   const eventsDir = path.join(root, EVENTS_REL);
   const legacyDir = path.join(root, LEGACY_EVENTS_REL);
@@ -176,26 +176,26 @@ function copyLegacyStore(fsImpl: any, root: any, files: any) {
     }
     try {
       fsImpl.renameSync(tmp, eventsDir);
-    } catch (error: any) {
+    } catch (error     ) {
       if (error.code !== 'EEXIST' && error.code !== 'ENOTEMPTY') throw error;
       removeQuietly(fsImpl, tmp); // another copier committed first
     }
     fsyncFolder(fsImpl, lifecycleDir);
     return files.length;
-  } catch (error: any) {
+  } catch (error     ) {
     if (tmp) removeQuietly(fsImpl, tmp);
     return migrationFailed(error.code || error.message);
   }
 }
 
 /** The UTC time an event file name's id starts with. */
-function idTime(name: any) {
+function idTime(name     ) {
   const m = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(\d{3})Z-/.exec(name);
   return m ? Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6], +m[7]) : NaN;
 }
 
 /** Writes the retention journal, flushed to disk, with a new generation. */
-function writeJournal(fsImpl: any, root: any, pending: any) {
+function writeJournal(fsImpl     , root     , pending     ) {
   writeAtomic(fsImpl, path.join(root, JOURNAL_REL), `${JSON.stringify({ v: 1, generation: randomChars(16), pending })}\n`);
 }
 
@@ -203,13 +203,13 @@ function writeJournal(fsImpl: any, root: any, pending: any) {
  * Keeps the held store lock from looking stale: another verb breaks a lock whose folder is older
  * than the lock's stale timeout, so a long pass renews its folder's time as it goes.
  */
-function refreshLock(fsImpl: any, root: any) {
+function refreshLock(fsImpl     , root     ) {
   const now = new Date();
   try { fsImpl.utimesSync(`${lockTarget(root)}.lock`, now, now); } catch { /* the lock folder is ours; a failed touch only shortens its life */ }
 }
 
 /** Unlinks pending event files without clearing the journal until every hidden name is finished. */
-function removePending(fsImpl: any, root: any, names: any, onRemoved = () => {}, { maxFiles = Infinity, shouldStop }: any = {}) {
+function removePending(fsImpl     , root     , names     , onRemoved = () => {}, { maxFiles = Infinity, shouldStop }      = {}) {
   const dir = path.join(root, EVENTS_REL);
   let removed = 0;
   for (let index = 0; index < names.length; index += 1) {
@@ -217,14 +217,14 @@ function removePending(fsImpl: any, root: any, names: any, onRemoved = () => {},
     const file = path.join(dir, names[index]);
     if (removed >= maxFiles) {
       try { fsImpl.lstatSync(file); return { complete: false, removed }; }
-      catch (error: any) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; continue; }
+      catch (error     ) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; continue; }
     }
     if (index % REFRESH_EVERY === 0) refreshLock(fsImpl, root);
     try {
       fsImpl.unlinkSync(file);
       removed += 1;
       onRemoved();
-    } catch (error: any) {
+    } catch (error     ) {
       if (error.code !== 'ENOENT') throw error;
     }
   }
@@ -233,7 +233,7 @@ function removePending(fsImpl: any, root: any, names: any, onRemoved = () => {},
 }
 
 /** Selects whole units only; a unit that does not fit waits for the next pass. */
-function passFiles(units: any, { maxFiles = MAX_PASS_FILES, shouldStop }: any = {}) {
+function passFiles(units     , { maxFiles = MAX_PASS_FILES, shouldStop }      = {}) {
   const files = [], limit = Math.max(0, Math.min(MAX_PASS_FILES, Number.isFinite(maxFiles) ? maxFiles : MAX_PASS_FILES));
   let partial = false;
   for (const unit of units) {
@@ -248,9 +248,9 @@ function passFiles(units: any, { maxFiles = MAX_PASS_FILES, shouldStop }: any =
  * The retention pass, under the store lock: finish a pending journal within the caller's remaining
  * limits, then remove whole eligible units. A stopped deletion keeps the complete name set hidden.
  */
-function retain(fsImpl: any, root: any, window: any, now: any, { maxFiles = MAX_PASS_FILES, shouldStop }: any = {}) {
+function retain(fsImpl     , root     , window     , now     , { maxFiles = MAX_PASS_FILES, shouldStop }      = {}) {
   let removedCount = 0;
-  const selected: any[] = [];
+  const selected        = [];
   try {
     if (shouldStop?.()) return { removed: [], removedCount, warning: [], partial: true, selected };
     const pending = readJournal(root, fsImpl).pending;
@@ -274,7 +274,7 @@ function retain(fsImpl: any, root: any, window: any, now: any, { maxFiles = MAX_
       if (shouldStop?.()) return { removed: [], removedCount, warning: [], partial: true, selected };
       const file = path.join(root, EVENTS_REL, name);
       let info;
-      try { info = fsImpl.lstatSync(file); } catch (error: any) { if (error.code !== 'ENOENT') throw error; }
+      try { info = fsImpl.lstatSync(file); } catch (error     ) { if (error.code !== 'ENOENT') throw error; }
       selected.push({ name, bytes: info?.isFile() ? info.size : 0 });
     }
     refreshLock(fsImpl, root);
@@ -285,7 +285,7 @@ function retain(fsImpl: any, root: any, window: any, now: any, { maxFiles = MAX_
       removed: window.source === 'default' ? [] : [removedLine(bounded.files.length, window.hours)],
       removedCount, warning: [], partial: bounded.partial || !result.complete, selected,
     };
-  } catch (error: any) {
+  } catch (error     ) {
     // A failure is not a stopped pass: `partial` means only a stop, a held lock or the removal cap,
     // so throttled upkeep advances its due time instead of retrying a failing pass on every verb.
     return { removed: [], removedCount, warning: [unlinkLine(error.code || error.message)], partial: false, selected, code: error.code || 'EIO' };
@@ -293,10 +293,10 @@ function retain(fsImpl: any, root: any, window: any, now: any, { maxFiles = MAX_
 }
 
 /** Runs a bounded lifecycle retention pass under a non-waiting store lock for the storage engine. */
-function retainLocked(root: any, options: any = {}) {
+function retainLocked(root     , options      = {}) {
   const { window, now = new Date(), fsImpl = nodeFs, maxFiles = MAX_PASS_FILES, shouldStop } = options;
   const bounded = Object.hasOwn(options, 'maxFiles') || Object.hasOwn(options, 'shouldStop');
-  const outcome = (removed: any, warning: any, partial = false, selected: any = [], code?: any) => bounded
+  const outcome = (removed     , warning     , partial = false, selected      = [], code      ) => bounded
     ? { removed, warning, partial, selected, ...(code ? { code } : {}) }
     : { removed, warning };
   const eventsDir = path.join(root, EVENTS_REL);
@@ -314,10 +314,10 @@ function retainLocked(root: any, options: any = {}) {
 }
 
 /** Whether a lock-free look finds anything for the retention pass to remove. */
-function needsPrune(fsImpl: any, root: any, window: any, now: any) {
+function needsPrune(fsImpl     , root     , window     , now     ) {
   if (window.state !== 'on') return false;
   const cutoff = now.getTime() - window.ms;
-  if (!namesIn(fsImpl, path.join(root, EVENTS_REL)).some((name: any) => isEventName(name) && idTime(name) < cutoff)) return false;
+  if (!namesIn(fsImpl, path.join(root, EVENTS_REL)).some((name     ) => isEventName(name) && idTime(name) < cutoff)) return false;
   return selectExpired(readEvents(root, { fsImpl }).events, { now, windowMs: window.ms }).files.length > 0;
 }
 
@@ -330,7 +330,7 @@ function needsPrune(fsImpl: any, root: any, window: any, now: any) {
  *   `lines` are for stderr, without the verb prefix.
  * @throws {StoreUnsafeError} a symlinked new store folder, or a symlinked old folder when a copy must read it
  */
-function prepareStore(root: string, { env = process.env, now = new Date(), fsImpl = nodeFs, registry }: any = {}) {
+function prepareStore(root        , { env = process.env, now = new Date(), fsImpl = nodeFs, registry }      = {}) {
   refuseLinks(fsImpl, root, [LIFECYCLE_REL, EVENTS_REL]);
   const legacyDir = lstatOrNull(fsImpl, path.join(root, LEGACY_EVENTS_REL));
   const notice = legacyDir && legacyDir.isDirectory() ? [NOTICE] : [];
@@ -342,7 +342,7 @@ function prepareStore(root: string, { env = process.env, now = new Date(), fsImp
     if (storeHasEvents(fsImpl, root)) {
       markerDue = true;
     } else {
-      try { migrate = legacyEventFiles(fsImpl, root).length > 0; } catch (error: any) { return legacyUnreadable(error.code || error.message); }
+      try { migrate = legacyEventFiles(fsImpl, root).length > 0; } catch (error     ) { return legacyUnreadable(error.code || error.message); }
     }
   }
   const retentionDue = readJournal(root, fsImpl).pending.length > 0 || needsPrune(fsImpl, root, window, now);
@@ -354,7 +354,7 @@ function prepareStore(root: string, { env = process.env, now = new Date(), fsImp
     fsImpl.mkdirSync(lifecycleDir, { recursive: true });
     // An unwritable folder would only show as a lock that never comes; name it for what it is.
     fsImpl.accessSync(lifecycleDir, nodeFs.constants.W_OK);
-  } catch (error: any) {
+  } catch (error     ) {
     // Without a copy to make, an unwritable store only stops the retention pass, not the verb.
     if (!migrate) return { ok: true, lines: [...notice, ...invalid, ...(retentionDue ? [unwritableLine(error.code || error.message)] : [])] };
     return migrationFailed(error.code || error.message);
@@ -362,7 +362,7 @@ function prepareStore(root: string, { env = process.env, now = new Date(), fsImp
   let release;
   try {
     release = acquireLock(fsImpl, lockTarget(root));
-  } catch (error: any) {
+  } catch (error     ) {
     if (/^Could not lock/.test(error.message || '')) return { ok: false, finding: 'store-locked', message: `${error.message} Nothing was written.`, lines: [] };
     throw error;
   }
@@ -373,7 +373,7 @@ function prepareStore(root: string, { env = process.env, now = new Date(), fsImp
       marked = writeMarker(fsImpl, root, 0, now);
     } else if (!marked) {
       let files;
-      try { files = legacyEventFiles(fsImpl, root); } catch (error: any) { return legacyUnreadable(error.code || error.message); }
+      try { files = legacyEventFiles(fsImpl, root); } catch (error     ) { return legacyUnreadable(error.code || error.message); }
       if (files.length) {
         refuseLinks(fsImpl, root, [LEGACY_LIFECYCLE_REL, LEGACY_EVENTS_REL]);
         const copied = copyLegacyStore(fsImpl, root, files);