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

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

@@ -35,26 +35,26 @@
 
 const nodeFs = require('node:fs');
 const { spawnSync } = require('node:child_process');
-const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.ts');
-const { appendEvents, readFold } = require('./event-store.ts');
-const { deriveStatuses, readGitFacts, behindNote, subjectNames, readMerges, readBranchTips, readHistory } = require('./status.ts');
-const { FollowupUsageError, oneLine, channelBy } = require('./followup.ts');
+const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.js');
+const { appendEvents, readFold } = require('./event-store.js');
+const { deriveStatuses, readGitFacts, behindNote, subjectNames, readMerges, readBranchTips, readHistory } = require('./status.js');
+const { FollowupUsageError, oneLine, channelBy } = require('./followup.js');
 
 /** The release-tag pattern of IC-020, the one `git-state` filters by. */
 const RELEASE_TAG = /^v[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$/;
 
-const refusal = (action: any, finding: any, message: any) => ({ ok: false, action, finding, message });
+const refusal = (action     , finding     , message     ) => ({ ok: false, action, finding, message });
 
 /** Trimmed stdout of a git call, or null when git exits non-zero. */
-function gitOut(root: any, args: any) {
+function gitOut(root     , args     ) {
   const run = spawnSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] });
   return run.status === 0 ? run.stdout.trim() : null;
 }
 
-function commitOf(root: any, ref: any) { return gitOut(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]) || null; }
+function commitOf(root     , ref     ) { return gitOut(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]) || null; }
 
 /** `a` is an ancestor of (or equal to) `b`. */
-function isAncestor(root: any, a: any, b: any) {
+function isAncestor(root     , a     , b     ) {
   return spawnSync('git', ['merge-base', '--is-ancestor', a, b], { cwd: root, stdio: 'ignore' }).status === 0;
 }
 
@@ -63,14 +63,14 @@ function isAncestor(root: any, a: any, b: any) {
  * since tracking, whose subject names the slug or whose non-first parent is an ancestor of the branch tip.
  * `merges` are the pinned ref's first-parent merges inside X, newest first; `history` holds X and the tip.
  */
-function earlierMerge({ slug, evidence, tip, lowerBound, merges, bound, history }: any) {
+function earlierMerge({ slug, evidence, tip, lowerBound, merges, bound, history }     ) {
   if (tip && history.isAncestor(tip, bound)) return { ...evidence };
   for (const merge of merges) {
     if (merge.ct < lowerBound) continue;
     // The merged side is this branch's own when it is an ancestor of the tip and the merge itself is not: a
     // branch cut from the integration ref after that merge has the merge in its history and did not make it.
     // A parent outside the first parent's history is one this merge introduced.
-    const own = (parent: any) => history.introducer(parent) === merge.sha && history.isAncestor(parent, tip);
+    const own = (parent     ) => history.introducer(parent) === merge.sha && history.isAncestor(parent, tip);
     if (tip && merge.parents.slice(1).some(own) && !history.isAncestor(merge.sha, tip)) return { ...evidence };
     if (subjectNames(merge.subject, slug)) return { kind: 'merge-subject', ref: merge.sha.slice(0, 7) };
   }
@@ -83,14 +83,14 @@ function earlierMerge({ slug, evidence, tip, lowerBound, merges, bound, history
  * other than `tag` merged into X (git's version order). A `v*` tag that is not a release (`vnext`)
  * never qualifies.
  */
-function previousTagOf(root: any, { tag, facts, bound }: any) {
+function previousTagOf(root     , { tag, facts, bound }     ) {
   const known = new Set(facts.release_tags);
   if (facts.base_tag && facts.base_tag !== tag && known.has(facts.base_tag) && isAncestor(root, `refs/tags/${facts.base_tag}`, bound)) return facts.base_tag;
   const merged = gitOut(root, ['tag', '--list', 'v*', '--sort=-v:refname', '--merged', bound]);
-  return (merged || '').split('\n').find((name: any) => name && name !== tag && known.has(name)) || null;
+  return (merged || '').split('\n').find((name     ) => name && name !== tag && known.has(name)) || null;
 }
 
-function slugList(raw: any, label: any) {
+function slugList(raw     , label     ) {
   const list = [...new Set((Array.isArray(raw) ? raw : raw === undefined || raw === null ? [] : [raw]).map(String))];
   for (const slug of list) if (!isSafeSlug(slug)) throw new FollowupUsageError(`${label}: ${invalidSlugRefusal(slug).message}`);
   return list;
@@ -107,7 +107,7 @@ function slugList(raw: any, label: any) {
  * @param {string} [options.channel]
  * @param {Object} [options.facts] `readGitFacts` output, for a caller that already has it
  */
-function releaseFeatures({ root, tag, confirm = false, features, exclude, channel, now = new Date(), fsImpl = nodeFs, facts: givenFacts }: any) {
+function releaseFeatures({ root, tag, confirm = false, features, exclude, channel, now = new Date(), fsImpl = nodeFs, facts: givenFacts }     ) {
   if (typeof tag !== 'string' || !RELEASE_TAG.test(tag)) throw new FollowupUsageError(`--tag is required and must look like v1.2.3 or v1.2.3-rc.1 (got '${tag ?? ''}')`);
   const added = slugList(features, '--feature');
   const excluded = slugList(exclude, '--exclude');
@@ -118,7 +118,7 @@ function releaseFeatures({ root, tag, confirm = false, features, exclude, channe
   if (!facts.integration_ref) return refusal('release', 'no-integration-ref', 'no integration ref resolves (develop, main, master, origin/HEAD), so no release can be previewed or recorded. Nothing was written.');
 
   const fold = readFold(root, { fsImpl, now });
-  const trackedSlugs = new Set(fold.features.map((f: any) => f.slug));
+  const trackedSlugs = new Set(fold.features.map((f     ) => f.slug));
   // An exclusion is permanent for its tag, so a mistyped slug must not be recorded any more than a mistyped addition.
   const untracked = [...new Set([...added, ...excluded])].filter((slug) => !trackedSlugs.has(slug));
   if (untracked.length) {
@@ -126,7 +126,7 @@ function releaseFeatures({ root, tag, confirm = false, features, exclude, channe
   }
 
   // DEC-030: containment in the tag being recorded never finishes a feature before its record exists.
-  const otherTags = { ...facts, release_tags: facts.release_tags.filter((name: any) => name !== tag) };
+  const otherTags = { ...facts, release_tags: facts.release_tags.filter((name     ) => name !== tag) };
   const derived = deriveStatuses({ root, fold, facts: otherTags });
   if (derived.releaseMode === 'unknown' || !derived.integrationSha) return refusal('release', 'no-integration-ref', `${derived.reason || `${facts.integration_ref} does not resolve to a commit`}. Nothing was written.`);
 
@@ -137,23 +137,23 @@ function releaseFeatures({ root, tag, confirm = false, features, exclude, channe
   // A hotfix merged only into the tag's own history has no evidence on the integration chain: derive against the tag as well.
   const atTag = tagCommit && tagCommit !== derived.integrationSha ? deriveStatuses({ root, fold, facts: { ...otherTags, integration_ref: tagCommit } }) : null;
 
-  const recorded = new Set(fold.releases.flatMap((release: any) => release.features.map((f: any) => f.slug)));
+  const recorded = new Set(fold.releases.flatMap((release     ) => release.features.map((f     ) => f.slug)));
   const tagged = derived.releaseMode === 'tagged';
   // While X is the pinned commit, every evidence commit is in its history. Once X is a tag elsewhere, one
   // graph read of the pinned ref, X and the evidence branch tips answers every ancestry question about X.
-  let read: any = null;
+  let read      = null;
   const readOfX = () => {
     if (read) return read;
-    const branchRefs = new Set(fold.features.map((f: any) => derived.statuses[f.slug].evidence).filter((e: any) => e && e.kind === 'branch').map((e: any) => e.ref));
+    const branchRefs = new Set(fold.features.map((f     ) => derived.statuses[f.slug].evidence).filter((e     ) => e && e.kind === 'branch').map((e     ) => e.ref));
     // Local branches are listed first, so a ref resolves as refs/heads/<ref> before refs/remotes/<ref>.
     const tips = new Map();
     for (const t of readBranchTips(root)) if (branchRefs.has(t.short) && !tips.has(t.short)) tips.set(t.short, t.sha);
     const history = readHistory(root, derived.integrationSha, [bound, ...tips.values()]);
-    const merges = readMerges(root, derived.integrationSha).filter((m: any) => history.isAncestor(m.sha, bound)).reverse();
+    const merges = readMerges(root, derived.integrationSha).filter((m     ) => history.isAncestor(m.sha, bound)).reverse();
     read = { history, merges, tips };
     return read;
   };
-  const inX = (commit: any) => bound === derived.integrationSha || readOfX().history.isAncestor(commit, bound);
+  const inX = (commit     ) => bound === derived.integrationSha || readOfX().history.isAncestor(commit, bound);
   const candidates = [];
   const notDetected = [];
   // A git failure while reading X's history is an environment fault: a refusal, never a throw that would
@@ -181,7 +181,7 @@ function releaseFeatures({ root, tag, confirm = false, features, exclude, channe
       }
       if (found) candidates.push({ slug, evidence: found.kind, ref: found.ref }); else notDetected.push(slug);
     }
-  } catch (error: any) {
+  } catch (error     ) {
     return refusal('release', 'no-integration-ref', `git could not answer while reading the history of ${tagCommit ? tag : facts.integration_ref} (git-state-failed): ${String(error.message).split('\n')[0]}. Nothing was written.`);
   }
 
@@ -189,9 +189,9 @@ function releaseFeatures({ root, tag, confirm = false, features, exclude, channe
   for (const slug of added) if (!shipped.some((c) => c.slug === slug)) shipped.push({ slug, evidence: 'confirmed', ref: null });
   const finishing = shipped.filter((c) => !excluded.includes(c.slug));
   const finishingSlugs = new Set(finishing.map((c) => c.slug));
-  const followupsDone = fold.followups.filter((item: any) => item.state === 'taken' && finishingSlugs.has(item.takenBy)).map((item: any) => item.id);
+  const followupsDone = fold.followups.filter((item     ) => item.state === 'taken' && finishingSlugs.has(item.takenBy)).map((item     ) => item.id);
 
-  const base: any = { ok: true, action: 'release', tag, previousTag, bound: tagCommit ? tag : facts.integration_ref, integrationRef: facts.integration_ref };
+  const base      = { ok: true, action: 'release', tag, previousTag, bound: tagCommit ? tag : facts.integration_ref, integrationRef: facts.integration_ref };
   if (derived.integrationBehind > 0) base.note = behindNote(facts.integration_ref, derived.integrationBehind);
 
   if (!confirm) {
@@ -206,7 +206,7 @@ function releaseFeatures({ root, tag, confirm = false, features, exclude, channe
   if (!tagCommit) return refusal('release', 'tag-missing', `${tag} does not exist; create the tag first, then confirm. Nothing was written.`);
   const out = appendEvents(root, [{ type: 'release.recorded', by, data: { tag, commit: tagCommit, features: finishing, excluded } }], { now, fsImpl });
   if (!out.ok) return refusal('release', out.finding, out.message);
-  return { ...base, recorded: true, candidates, added, excluded, notDetected, followupsDone, events: out.written.map((w: any) => w.file), next: [] };
+  return { ...base, recorded: true, candidates, added, excluded, notDetected, followupsDone, events: out.written.map((w     ) => w.file), next: [] };
 }
 
 /**
@@ -214,17 +214,17 @@ function releaseFeatures({ root, tag, confirm = false, features, exclude, channe
  * cherry-pick). It records an observed fact after the merge, one `feature.merged` event, and the
  * status stays derived from events on read, so nothing is written ahead of the fact (DEC-022).
  */
-function recordMerged({ root, slug, reason, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function recordMerged({ root, slug, reason, channel, now = new Date(), fsImpl = nodeFs }     ) {
   if (!slug) throw new FollowupUsageError('--slug is required for --action merged');
   if (!isSafeSlug(slug)) throw new FollowupUsageError(invalidSlugRefusal(slug).message);
-  const problems: any[] = [];
+  const problems        = [];
   const cleanReason = reason === undefined ? null : oneLine(reason, '--reason', problems);
   if (!problems.length && !cleanReason) problems.push('--reason is required for --action merged: how the merge happened, for example "squash-merged by hand"');
   if (problems.length) throw new FollowupUsageError(problems.join('; '));
   const by = channelBy(channel);
 
   const fold = readFold(root, { fsImpl, now });
-  if (!fold.features.some((f: any) => f.slug === slug)) {
+  if (!fold.features.some((f     ) => f.slug === slug)) {
     return refusal('merged', 'untracked-feature', `${slug} is not a tracked feature, so no merge can be confirmed for it; run doflow-run lifecycle --action init --slug ${slug} first. Nothing was written.`);
   }
   const before = deriveStatuses({ root, fold }).statuses[slug];
@@ -235,7 +235,7 @@ function recordMerged({ root, slug, reason, channel, now = new Date(), fsImpl =
   const out = appendEvents(root, [{ type: 'feature.merged', by, data: { slug, reason: cleanReason } }], { now, fsImpl });
   if (!out.ok) return refusal('merged', out.finding, out.message);
   const after = deriveStatuses({ root, fold: readFold(root, { fsImpl, now }) }).statuses[slug];
-  return { ok: true, action: 'merged', slug, status: after.status, evidence: after.evidence, release: after.release, events: out.written.map((w: any) => w.file), next: [] };
+  return { ok: true, action: 'merged', slug, status: after.status, evidence: after.evidence, release: after.release, events: out.written.map((w     ) => w.file), next: [] };
 }
 
 module.exports = { releaseFeatures, recordMerged, RELEASE_TAG };

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

@@ -19,7 +19,7 @@
 const nodeFs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const mask = require('../mask.ts');
+const mask = require('../mask.js');
 
 /** A `--file` or `--stdin` source is read for at most this many bytes; the rest could not be kept anyway. */
 const MAX_READ_BYTES = 16 * 1024 * 1024;
@@ -44,32 +44,32 @@ class ReportInputError extends Error {}
  * repeated here rather than required from the failure module, so the follow-up service still loads in
  * a build or an install where the failure modules cannot be loaded (IC-016).
  */
-function reportsHome(env: Record<string, string | undefined> = process.env): string | null {
+function reportsHome(env                                     = process.env)                {
   const xdg = env.XDG_CONFIG_HOME;
   if (typeof xdg === 'string' && xdg !== '') return path.isAbsolute(xdg) ? path.join(xdg, 'doflow', 'reports') : null;
   const home = env.HOME;
   return typeof home === 'string' && path.isAbsolute(home) ? path.join(home, '.config', 'doflow', 'reports') : null;
 }
 
-function realProjectRoot(root: string, fsImpl: any = nodeFs): string {
+function realProjectRoot(root        , fsImpl      = nodeFs)         {
   try { return fsImpl.realpathSync(root); } catch { return root; }
 }
 
-function projectKey(root: string, fsImpl: any = nodeFs): string {
+function projectKey(root        , fsImpl      = nodeFs)         {
   return crypto.createHash('sha256').update(realProjectRoot(root, fsImpl)).digest('hex').slice(0, 12);
 }
 
 /** @returns {string|null} the body file of a report of this project, or null when no home resolves */
-function bodyPath(root: string, id: string, { env = process.env, fsImpl = nodeFs }: any = {}): string | null {
+function bodyPath(root        , id        , { env = process.env, fsImpl = nodeFs }      = {})                {
   const home = reportsHome(env);
   return home === null ? null : path.join(home, projectKey(root, fsImpl), `${id}.txt`);
 }
 
 /** The `hasBody` the fold needs (IC-003): a report whose body file is on this machine. */
-function bodyChecker(root: string, { env = process.env, fsImpl = nodeFs }: any = {}): (item: any) => boolean {
+function bodyChecker(root        , { env = process.env, fsImpl = nodeFs }      = {})                         {
   const home = reportsHome(env);
   const folder = home === null ? null : path.join(home, projectKey(root, fsImpl));
-  return (item: any): boolean => {
+  return (item     )          => {
     // The id comes from an event file, so it is checked before it becomes part of a path.
     if (folder === null || !FU_ID.test(String(item.id)) || item.bodyRef !== `local:${item.id}`) return false;
     try { return fsImpl.statSync(path.join(folder, `${item.id}.txt`)).isFile(); } catch { return false; }
@@ -77,8 +77,8 @@ function bodyChecker(root: string, { env = process.env, fsImpl = nodeFs }: any =
 }
 
 /** Reads at most `max` bytes from an open descriptor. */
-function readCapped(fsImpl: any, fd: number, max: number): Buffer {
-  const chunks: Buffer[] = [];
+function readCapped(fsImpl     , fd        , max        )         {
+  const chunks           = [];
   let total = 0;
   const chunk = Buffer.allocUnsafe(64 * 1024);
   while (total < max) {
@@ -96,24 +96,24 @@ function readCapped(fsImpl: any, fd: number, max: number): Buffer {
  * @param {{file?: string, stdin?: boolean, text?: string}} source
  * @returns {string}
  */
-function readReportText({ file, stdin: stdinFlag, text }: { file?: string; stdin?: boolean; text?: string }, { fsImpl = nodeFs }: any = {}): string {
+function readReportText({ file, stdin: stdinFlag, text }                                                   , { fsImpl = nodeFs }      = {})         {
   // `--file -` is stdin, as everywhere else a `-` stands for it.
   const stdin = Boolean(stdinFlag) || file === '-';
   if (file === '-') file = undefined;
   const given = [file !== undefined, Boolean(stdin), text !== undefined].filter(Boolean).length;
   if (given !== 1) throw new ReportInputError('give the report body with exactly one of --file <path>, --stdin or --text "<body>" (--file and --stdin also take text that starts with -)');
   if (text !== undefined) return String(text);
-  let bytes: Buffer;
+  let bytes        ;
   if (stdin) {
-    try { bytes = readCapped(fsImpl, 0, MAX_READ_BYTES); } catch (error: any) { throw new ReportInputError(`cannot read the report from stdin: ${error.message}`); }
+    try { bytes = readCapped(fsImpl, 0, MAX_READ_BYTES); } catch (error     ) { throw new ReportInputError(`cannot read the report from stdin: ${error.message}`); }
   } else {
-    const target = path.resolve(file as string);
-    let fd: number | undefined;
+    const target = path.resolve(file          );
+    let fd                    ;
     try {
       if (!fsImpl.statSync(target).isFile()) throw new ReportInputError(`--file ${file} is not a regular file`);
       fd = fsImpl.openSync(target, 'r');
-      bytes = readCapped(fsImpl, fd as number, MAX_READ_BYTES);
-    } catch (error: any) {
+      bytes = readCapped(fsImpl, fd          , MAX_READ_BYTES);
+    } catch (error     ) {
       if (error instanceof ReportInputError) throw error;
       throw new ReportInputError(`cannot read --file ${file}: ${error.code || error.message}`);
     } finally {
@@ -125,7 +125,7 @@ function readReportText({ file, stdin: stdinFlag, text }: { file?: string; stdin
 }
 
 /** The length of the longest prefix of `buffer` of at most `limit` bytes that ends on a UTF-8 boundary. */
-function boundary(buffer: Buffer, limit: number): number {
+function boundary(buffer        , limit        )         {
   let end = Math.min(limit, buffer.length);
   if (end === buffer.length) return end;
   while (end > 0 && (buffer[end] & 0xc0) === 0x80) end -= 1;
@@ -139,7 +139,7 @@ function boundary(buffer: Buffer, limit: number): number {
  * boundary; a token straddling the cut goes with the incomplete tail, never half-masked.
  * @returns {{text: string, cut: boolean}}
  */
-function boundMaskInput(raw: string): { text: string; cut: boolean } {
+function boundMaskInput(raw        )                                 {
   const stripped = raw.replace(ANSI, '');
   const whole = Buffer.from(stripped, 'utf8');
   if (whole.length <= MASK_INPUT_BYTES) return { text: stripped, cut: false };
@@ -157,9 +157,9 @@ function boundMaskInput(raw: string): { text: string; cut: boolean } {
  * @param {{home?: string}} [options] the home directory the mask replaces with `~`
  * @returns {{buffer: Buffer, masked: number, truncated: boolean}}
  */
-function prepareBody(raw: string, { home }: { home?: string } = {}): { buffer: Buffer; masked: number; truncated: boolean } {
+function prepareBody(raw        , { home }                    = {})                                                         {
   const { text: bounded, cut } = boundMaskInput(raw);
-  let result: any;
+  let result     ;
   try {
     result = mask.maskBody(bounded, home === undefined ? undefined : { home });
   } catch {
@@ -178,7 +178,7 @@ function prepareBody(raw: string, { home }: { home?: string } = {}): { buffer: B
  * @param {Buffer} body
  * @returns {string}
  */
-function excerptOf(body: Buffer): string {
+function excerptOf(body        )         {
   if (body.length <= EXCERPT_BYTES) return body.toString('utf8').replace(/\s+$/, '');
   const head = body.subarray(0, boundary(body, EXCERPT_BYTES));
   const lineEnd = head.lastIndexOf(0x0a);
@@ -189,7 +189,7 @@ function excerptOf(body: Buffer): string {
  * Writes the body once: exclusive create, file 0600, folders 0700, never inside the repository.
  * @returns {{ok: true, file: string}|{ok: false, reason: 'no-home'|'exists'|'error', message?: string}}
  */
-function writeBody(root: string, id: string, buffer: Buffer, { env = process.env, fsImpl = nodeFs }: any = {}): { ok: boolean; file?: string; reason?: string; message?: string } {
+function writeBody(root        , id        , buffer        , { env = process.env, fsImpl = nodeFs }      = {})                                                                    {
   const file = bodyPath(root, id, { env, fsImpl });
   if (file === null) return { ok: false, reason: 'no-home' };
   const folder = path.dirname(file);
@@ -200,18 +200,18 @@ function writeBody(root: string, id: string, buffer: Buffer, { env = process.env
     fsImpl.chmodSync(path.dirname(folder), 0o700);
     try {
       fsImpl.writeFileSync(path.join(folder, '.root'), `${realProjectRoot(root, fsImpl)}\n`, { flag: 'wx', mode: 0o600 });
-    } catch (error: any) {
+    } catch (error     ) {
       if (error.code !== 'EEXIST') throw error;
     }
     fsImpl.writeFileSync(file, buffer, { flag: 'wx', mode: 0o600 });
     return { ok: true, file };
-  } catch (error: any) {
+  } catch (error     ) {
     return error.code === 'EEXIST' ? { ok: false, reason: 'exists' } : { ok: false, reason: 'error', message: error.code || error.message };
   }
 }
 
 /** Removes a body this process just wrote, when the event that names it could not be written. */
-function removeBody(file: string, fsImpl: any = nodeFs): void {
+function removeBody(file        , fsImpl      = nodeFs)       {
   try { fsImpl.rmSync(file, { force: true }); } catch { /* the failure being reported stands */ }
 }
 

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

@@ -17,15 +17,15 @@
 
 const nodeFs = require('node:fs');
 const { isDeepStrictEqual } = require('node:util');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
-const { loadStorageRegistry } = require('../storage/registry.ts');
-const { resolveRoots, readPruneSetting } = require('../storage/roots.ts');
-const { foldInto, finalize } = require('./fold.ts');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+const { loadStorageRegistry } = require('../storage/registry.js');
+const { resolveRoots, readPruneSetting } = require('../storage/roots.js');
+const { foldInto, finalize } = require('./fold.js');
 
 const HOUR_MS = 3600000;
 
 /** @returns {{state: 'off'} | {state: 'on', hours: number, ms: number} | {state: 'invalid', raw: string}} */
-function parseWindow(env: Record<string, string | undefined> = process.env): { state: 'off' } | { state: 'on'; hours: number; ms: number } | { state: 'invalid'; raw: string } {
+function parseWindow(env                                     = process.env)                                                                                                    {
   const raw = env.DOFLOW_RETENTION_HOURS;
   if (raw === undefined || raw === '') return { state: 'off' };
   if (/^[1-9][0-9]*$/.test(raw) && Number.isSafeInteger(Number(raw))) {
@@ -36,11 +36,11 @@ function parseWindow(env: Record<string, string | undefined> = process.env): { s
 }
 
 /** Composes IC-013's explicit environment override with the declared lifecycle default. */
-function retentionWindow({ env = process.env, projectRoot, registry, fsImpl = nodeFs }: any = {}): any {
+function retentionWindow({ env = process.env, projectRoot, registry, fsImpl = nodeFs }      = {})      {
   const parsed = parseWindow(env);
   if (parsed.state === 'invalid') return parsed;
   if (parsed.state === 'on') return { ...parsed, source: 'env' };
-  let activeRegistry: any;
+  let activeRegistry     ;
   try {
     activeRegistry = registry || loadStorageRegistry({ repoRoot: REPO_ROOT, fsImpl });
   } catch {
@@ -48,23 +48,23 @@ function retentionWindow({ env = process.env, projectRoot, registry, fsImpl = no
   }
   const roots = resolveRoots({ registry: activeRegistry, projectRoot, env });
   if (readPruneSetting({ registry: activeRegistry, roots, rootId: 'project-state', fsImpl }).setting !== 'on') return { state: 'off' };
-  const lifecycleStore = activeRegistry.stores.find((store: any) => store.id === 'lifecycle-events');
+  const lifecycleStore = activeRegistry.stores.find((store     ) => store.id === 'lifecycle-events');
   if (!lifecycleStore) throw new Error('Storage registry has no lifecycle-events store');
   const hours = lifecycleStore.bound.defaultHours;
   return { state: 'on', hours, ms: hours * HOUR_MS, source: 'default' };
 }
 
-function isText(value: any): boolean { return typeof value === 'string' && value.trim() !== ''; }
+function isText(value     )          { return typeof value === 'string' && value.trim() !== ''; }
 
 /** The item keys an event names, or none when it is not about a follow-up or a goal. */
-function itemsOf(event: any): string[] {
+function itemsOf(event     )           {
   const d = event.data;
-  const ids = (list: any): string[] => (Array.isArray(list) && list.length > 0 && list.every(isText) ? list : []);
+  const ids = (list     )           => (Array.isArray(list) && list.length > 0 && list.every(isText) ? list : []);
   switch (event.type) {
     case 'followup.added': return isText(d.id) ? [`followup:${d.id}`] : [];
     case 'followup.taken':
-    case 'followup.promoted': return ids(d.ids).map((id: string) => `followup:${id}`);
-    case 'followup.settled': return (isText(d.id) ? [d.id] : ids(d.ids)).map((id: string) => `followup:${id}`);
+    case 'followup.promoted': return ids(d.ids).map((id        ) => `followup:${id}`);
+    case 'followup.settled': return (isText(d.id) ? [d.id] : ids(d.ids)).map((id        ) => `followup:${id}`);
     case 'goal.added':
     case 'goal.item-added':
     case 'goal.checked':
@@ -75,17 +75,17 @@ function itemsOf(event: any): string[] {
 }
 
 /** Groups the items into units: items named together by one event share a unit. */
-function unitsOf(events: any[], shouldStop?: () => boolean): any[] | null {
-  const parent = new Map<string, string>();
-  const find = (key: string): string | null => {
+function unitsOf(events       , shouldStop                )               {
+  const parent = new Map                ();
+  const find = (key        )                => {
     while (parent.get(key) !== key) {
       if (shouldStop?.()) return null;
-      parent.set(key, parent.get(parent.get(key) as string) as string);
-      key = parent.get(key) as string;
+      parent.set(key, parent.get(parent.get(key)          )          );
+      key = parent.get(key)          ;
     }
     return key;
   };
-  const named: Array<{ event: any; items: string[] }> = [];
+  const named                                         = [];
   for (const event of events) {
     if (shouldStop?.()) return null;
     named.push({ event, items: [...new Set(itemsOf(event))] });
@@ -99,7 +99,7 @@ function unitsOf(events: any[], shouldStop?: () => boolean): any[] | null {
       parent.set(root, head);
     }
   }
-  const units = new Map<string, any>();
+  const units = new Map             ();
   for (const { event, items } of named) {
     if (shouldStop?.()) return null;
     if (items.length === 0) continue;
@@ -113,7 +113,7 @@ function unitsOf(events: any[], shouldStop?: () => boolean): any[] | null {
   return [...units.values()];
 }
 
-function isSettled(state: any, key: string): boolean {
+function isSettled(state     , key        )          {
   const [kind, id] = [key.slice(0, key.indexOf(':')), key.slice(key.indexOf(':') + 1)];
   if (kind === 'followup') {
     const item = state.items.get(id);
@@ -124,15 +124,15 @@ function isSettled(state: any, key: string): boolean {
 }
 
 /** The parts of a fold that removing a unit must leave unchanged. */
-function comparable(result: any): any {
+function comparable(result     )      {
   const { followups, features, merged, goals, releases, conflicts } = result;
   return { followups, features, merged, goals, releases, conflicts };
 }
 
 /** Whether dropping `removed` units changes nothing but the removed items themselves. */
-function refoldEqual(events: any[], full: any, removed: any[], now: Date, shouldStop?: () => boolean): boolean | null {
+function refoldEqual(events       , full     , removed       , now      , shouldStop                )                 {
   if (shouldStop?.()) return null;
-  const gone = new Set<string>(), keys = new Set<string>();
+  const gone = new Set        (), keys = new Set        ();
   for (const unit of removed) {
     if (shouldStop?.()) return null;
     for (const event of unit.events) gone.add(event.id);
@@ -140,11 +140,11 @@ function refoldEqual(events: any[], full: any, removed: any[], now: Date, should
   }
   const expected = {
     ...full,
-    followups: full.followups.filter((f: any) => !keys.has(`followup:${f.id}`)),
-    goals: full.goals.filter((g: any) => !keys.has(`goal:${g.goal}`)),
-    conflicts: full.conflicts.filter((c: any) => !gone.has(c.event)),
+    followups: full.followups.filter((f     ) => !keys.has(`followup:${f.id}`)),
+    goals: full.goals.filter((g     ) => !keys.has(`goal:${g.goal}`)),
+    conflicts: full.conflicts.filter((c     ) => !gone.has(c.event)),
   };
-  const remaining: any[] = [];
+  const remaining        = [];
   for (const event of events) {
     if (shouldStop?.()) return null;
     if (!gone.has(event.id)) remaining.push(event);
@@ -160,23 +160,23 @@ function refoldEqual(events: any[], full: any, removed: any[], now: Date, should
  * @returns {{files: string[], units: Array<{items: string[], newestAt: string, files: string[]}>, incomplete?: true}}
  *   files: `<id>.json` names, sorted
  */
-function selectExpired(events: any[], { now, windowMs, shouldStop }: any = {}): any {
-  const incomplete = (): any => ({ files: [], units: [], incomplete: true });
+function selectExpired(events       , { now, windowMs, shouldStop }      = {})      {
+  const incomplete = ()      => ({ files: [], units: [], incomplete: true });
   if (shouldStop?.()) return incomplete();
   const state = foldInto(events, { now, shouldStop });
   if (state.incomplete || shouldStop?.()) return incomplete();
   const cutoff = now.getTime() - windowMs;
-  const served = new Set<string>();
+  const served = new Set        ();
   for (const feature of state.tracked.values()) {
     if (shouldStop?.()) return incomplete();
     if (feature.goal) served.add(feature.goal);
   }
   const named = unitsOf(events, shouldStop);
   if (!named || shouldStop?.()) return incomplete();
-  const candidates: any[] = [];
+  const candidates        = [];
   for (const unit of named) {
     if (shouldStop?.()) return incomplete();
-    const newest = unit.events.reduce((max: string, event: any) => (Date.parse(event.at) > Date.parse(max) ? event.at : max), unit.events[0].at);
+    const newest = unit.events.reduce((max        , event     ) => (Date.parse(event.at) > Date.parse(max) ? event.at : max), unit.events[0].at);
     if (shouldStop?.()) return incomplete();
     let eligible = Date.parse(newest) < cutoff;
     if (eligible) for (const key of unit.items) {
@@ -191,7 +191,7 @@ function selectExpired(events: any[], { now, windowMs, shouldStop }: any = {}):
   if (allSafe === null || shouldStop?.()) return incomplete();
   if (!allSafe) {
     selected = [];
-    const ordered = [...candidates].sort((a: any, b: any) => Date.parse(a.newestAt) - Date.parse(b.newestAt));
+    const ordered = [...candidates].sort((a     , b     ) => Date.parse(a.newestAt) - Date.parse(b.newestAt));
     if (shouldStop?.()) return incomplete();
     for (const unit of ordered) {
       if (shouldStop?.()) return incomplete();
@@ -200,13 +200,13 @@ function selectExpired(events: any[], { now, windowMs, shouldStop }: any = {}):
       if (safe) selected.push(unit);
     }
   }
-  const units: any[] = [];
+  const units        = [];
   for (const unit of selected) {
     if (shouldStop?.()) return incomplete();
-    units.push({ items: [...unit.items].sort(), newestAt: unit.newestAt, files: unit.events.map((event: any) => `${event.id}.json`).sort() });
+    units.push({ items: [...unit.items].sort(), newestAt: unit.newestAt, files: unit.events.map((event     ) => `${event.id}.json`).sort() });
   }
   if (shouldStop?.()) return incomplete();
-  return { files: units.flatMap((unit: any) => unit.files).sort(), units };
+  return { files: units.flatMap((unit     ) => unit.files).sort(), units };
 }
 
 module.exports = { parseWindow, retentionWindow, selectExpired };

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

@@ -11,19 +11,19 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
 
-interface WorktreeEntry { path: string; bare: boolean; prunable: boolean }
+                                                                          
 
-function git(cwd: string, args: string[]): string {
+function git(cwd        , args          )         {
   return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
 }
 
-function real(target: string): string {
+function real(target        )         {
   try { return fs.realpathSync(target); } catch { return path.resolve(target); }
 }
 
 /** The entries of `git worktree list --porcelain`: `{path, bare, prunable}`, in git's order. */
-function worktreeEntries(porcelain: string): WorktreeEntry[] {
-  const entries: WorktreeEntry[] = [];
+function worktreeEntries(porcelain        )                  {
+  const entries                  = [];
   for (const block of porcelain.split(/\n\s*\n/)) {
     const lines = block.split('\n').map((line) => line.replace(/\r$/, ''));
     const head = lines.find((line) => line.startsWith('worktree '));
@@ -39,12 +39,12 @@ function worktreeEntries(porcelain: string): WorktreeEntry[] {
 
 /** A working tree that exists and that git itself calls one: a submodule's or a separate git dir's
  * entry points at a git directory, where `--is-inside-work-tree` prints `false`. */
-function isRealWorkTree(entry: WorktreeEntry): boolean {
+function isRealWorkTree(entry               )          {
   if (entry.bare || entry.prunable || !fs.existsSync(entry.path)) return false;
   try { return git(entry.path, ['rev-parse', '--is-inside-work-tree']).trim() === 'true'; } catch { return false; }
 }
 
-function showToplevel(cwd: string): string | null {
+function showToplevel(cwd        )                {
   try {
     const top = git(cwd, ['rev-parse', '--show-toplevel']).trim();
     return top ? real(top) : null;
@@ -60,8 +60,8 @@ function showToplevel(cwd: string): string | null {
  * @param {string} [cwd] defaults to the process working directory
  * @returns {string} an absolute, real path
  */
-function projectRoot(cwd: string = process.cwd()): string {
-  let entries: WorktreeEntry[] = [];
+function projectRoot(cwd         = process.cwd())         {
+  let entries                  = [];
   try { entries = worktreeEntries(git(cwd, ['worktree', 'list', '--porcelain'])); } catch { /* not a repository */ }
   const first = entries[0];
   if (first && !first.bare && isRealWorkTree(first)) return real(first.path);