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

package/src/runtime/failure/{capture.ts → capture.js}

@@ -17,10 +17,10 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
-const { normaliseMessage, maskLine } = require('../mask.ts');
-const { isProgrammingError, errorKind } = require('./classifier.ts');
-const { failureHome, captureIsOff, eventsPath } = require('./home.ts');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
+const { normaliseMessage, maskLine } = require('../mask.js');
+const { isProgrammingError, errorKind } = require('./classifier.js');
+const { failureHome, captureIsOff, eventsPath } = require('./home.js');
 
 const MAX_LINE_BYTES = 2048;
 const MAX_RAW_MESSAGE = 4096;
@@ -33,24 +33,24 @@ const COMMAND_NAME = /^[a-z][a-z0-9-]{0,39}$/;
 /** Errors already recorded in this process, so one error caught at two points counts once. */
 const recorded = new WeakSet();
 
-let cachedVersion: string | null = null;
+let cachedVersion                = null;
 /** The package version; the projected runtime ships no package.json, so a tolerant read. */
-function packageVersion(): string {
+function packageVersion()         {
   if (cachedVersion === null) {
     try { cachedVersion = String(require('../../../package.json').version); } catch { cachedVersion = 'unknown'; }
   }
   return cachedVersion;
 }
 
-function harnessName(env: any): string {
+function harnessName(env     )         {
   const raw = env.DOFLOW_AGENT;
   return typeof raw === 'string' && /^[A-Za-z0-9._-]{1,40}$/.test(raw) ? raw : 'none';
 }
 
 /** The absolute, non-root homes to compare a working directory with: HOME as given, its real path, and `os.homedir()`. */
-function homeCandidates(env: any): string[] {
-  const out: string[] = [];
-  const add = (value: any) => {
+function homeCandidates(env     )           {
+  const out           = [];
+  const add = (value     ) => {
     if (typeof value !== 'string' || !path.isAbsolute(value)) return;
     const home = value.replace(/\/+$/, '');
     if (home.length > 1 && !out.includes(home)) out.push(home);
@@ -67,8 +67,8 @@ function homeCandidates(env: any): string[] {
  * directory under no known home, when `HOME` itself is not usable, is stored as its folder name only,
  * so an absolute path with a user name in it never reaches the file.
  */
-function projectName(env: any): string {
-  let cwd: string;
+function projectName(env     )         {
+  let cwd        ;
   try { cwd = process.cwd(); } catch { return ''; }
   const home = homeCandidates(env).find((h) => cwd === h || cwd.startsWith(`${h}/`));
   if (home) return maskLine(`~${cwd.slice(home.length)}`, { home: null }).text.slice(0, 200);
@@ -77,7 +77,7 @@ function projectName(env: any): string {
   return maskLine(cwd, { home: env.HOME }).text.slice(0, 200);
 }
 
-function commandName(command: any): string {
+function commandName(command     )         {
   return typeof command === 'string' && COMMAND_NAME.test(command) ? command : 'unknown';
 }
 
@@ -88,8 +88,8 @@ function commandName(command: any): string {
  * @param {*} error
  * @returns {string|null}
  */
-function doflowFrame(error: any): string | null {
-  let stack: string;
+function doflowFrame(error     )                {
+  let stack        ;
   try { stack = typeof error.stack === 'string' ? error.stack : ''; } catch { return null; }
   const root = REPO_ROOT + path.sep;
   for (const line of stack.split('\n')) {
@@ -97,15 +97,15 @@ function doflowFrame(error: any): string | null {
     if (!match) continue;
     const file = match[2].replace(/^file:\/\//, '');
     if (!file.startsWith(root) || file.includes(`${path.sep}node_modules${path.sep}`)) continue;
-    const fn = (match[1] || '').replace(/^new /, '').split('.').pop()!.replace(/\s.*$/, '') || '<anonymous>';
+    const fn = (match[1] || '').replace(/^new /, '').split('.').pop() .replace(/\s.*$/, '') || '<anonymous>';
     return `${path.relative(REPO_ROOT, file).split(path.sep).join('/')}:${fn}`;
   }
   return null;
 }
 
 /** One line at or under MAX_LINE_BYTES including the newline: shorten `message`, then `project`. */
-function buildLine(record: any): string | null {
-  const bytes = (r: any) => Buffer.byteLength(JSON.stringify(r), 'utf8') + 1;
+function buildLine(record     )                {
+  const bytes = (r     ) => Buffer.byteLength(JSON.stringify(r), 'utf8') + 1;
   const out = { ...record };
   for (const field of ['message', 'project']) {
     while (bytes(out) > MAX_LINE_BYTES && out[field].length > 0) {
@@ -115,23 +115,23 @@ function buildLine(record: any): string | null {
   return bytes(out) > MAX_LINE_BYTES ? null : `${JSON.stringify(out)}\n`;
 }
 
-const stamp = (date: Date): string => date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
+const stamp = (date      )         => date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
 
 /** Rotated files with their size and modification time, oldest last-modified first (names alone tie inside one second). */
-function rotatedFiles(home: string): Array<{ name: string; size: number; mtime: number }> {
-  return fs.readdirSync(home).filter((name: string) => ROTATED.test(name)).map((name: string) => {
+function rotatedFiles(home        )                                                       {
+  return fs.readdirSync(home).filter((name        ) => ROTATED.test(name)).map((name        ) => {
     let size = 0;
     let mtime = 0;
     try { const st = fs.statSync(path.join(home, name)); size = st.size; mtime = st.mtimeMs; } catch { /* gone */ }
     return { name, size, mtime };
-  }).sort((a: any, b: any) => a.mtime - b.mtime || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  }).sort((a     , b     ) => a.mtime - b.mtime || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
 
 /**
  * Removes rotated files beyond the newest four full ones, and partial ones (see rotateIfDue) once
  * they are an hour old. A partial file never counts toward the four, so it cannot push a real one out.
  */
-function prune(home: string, now = Date.now()): void {
+function prune(home        , now = Date.now())       {
   const files = rotatedFiles(home);
   const full = files.filter((f) => f.size >= ROTATE_AT_BYTES);
   const doomed = [
@@ -157,7 +157,7 @@ function prune(home: string, now = Date.now()): void {
  * @param {string} home the failure home
  * @returns {boolean} whether this call rotated a full file
  */
-function rotateIfDue(home: string): boolean {
+function rotateIfDue(home        )          {
   const live = eventsPath(home);
   try {
     if (fs.statSync(live).size < ROTATE_AT_BYTES) return false;
@@ -188,9 +188,9 @@ function rotateIfDue(home: string): boolean {
  * descriptor is checked before the write, so a file swapped in after any earlier check is still safe.
  * @returns {boolean} whether the line was written
  */
-function appendRegular(file: string, line: string): boolean {
+function appendRegular(file        , line        )          {
   const c = fs.constants;
-  let fd: number | undefined;
+  let fd                    ;
   try {
     fd = fs.openSync(file, c.O_WRONLY | c.O_APPEND | c.O_CREAT | (c.O_NOFOLLOW || 0) | (c.O_NONBLOCK || 0), 0o600);
     if (!fs.fstatSync(fd).isFile()) return false;
@@ -208,7 +208,7 @@ function appendRegular(file: string, line: string): boolean {
  * @param {Object} [env] defaults to process.env
  * @returns {boolean} whether a line was written
  */
-function captureFailure(fields: any, env = process.env): boolean {
+function captureFailure(fields     , env = process.env)          {
   try {
     const home = failureHome(env);
     if (!home || captureIsOff(home, env)) return false;
@@ -235,7 +235,7 @@ function captureFailure(fields: any, env = process.env): boolean {
 }
 
 /** The error's message cut to 4096 characters before any masking, so no input makes the rules do unbounded work. */
-function rawMessage(error: any): string {
+function rawMessage(error     )         {
   try {
     const message = error.message;
     return typeof message === 'string' ? message.slice(0, MAX_RAW_MESSAGE) : '';
@@ -251,7 +251,7 @@ function rawMessage(error: any): string {
  * @param {Object} [env]
  * @returns {boolean} whether a line was written
  */
-function captureError(error: any, context: any = {}, env = process.env): boolean {
+function captureError(error     , context      = {}, env = process.env)          {
   try {
     if (!isProgrammingError(error) || recorded.has(error)) return false;
     recorded.add(error);

package/src/runtime/failure/{classifier.ts → classifier.js}

@@ -14,12 +14,12 @@
 const CLASS_NAMES = new Set(['TypeError', 'RangeError', 'ReferenceError']);
 
 /** Reads one property without ever throwing: a throwing getter reads as undefined. */
-function read(error: any, key: string): any {
+function read(error     , key        )      {
   try { return error[key]; } catch { return undefined; }
 }
 
 /** `error instanceof Class`, never throwing. */
-function isA(error: any, Class: any): boolean {
+function isA(error     , Class     )          {
   try { return error instanceof Class; } catch { return false; }
 }
 
@@ -29,7 +29,7 @@ function isA(error: any, Class: any): boolean {
  * @param {*} error
  * @returns {boolean}
  */
-function isProgrammingError(error: any): boolean {
+function isProgrammingError(error     )          {
   try {
     if (error === null || typeof error !== 'object') return false;
     const code = read(error, 'code');
@@ -53,7 +53,7 @@ function isProgrammingError(error: any): boolean {
  * @param {*} error
  * @returns {string}
  */
-function errorKind(error: any): string {
+function errorKind(error     )         {
   for (const Class of [TypeError, RangeError, ReferenceError]) {
     if (isA(error, Class)) return Class.name;
   }

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

@@ -12,14 +12,14 @@
  */
 
 const fs = require('node:fs');
-const { finishRuntime, usageError } = require('../cli-result.ts');
-const { maskLine, printSafe } = require('../mask.ts');
-const { failureHome, captureSwitch, sentinelPath } = require('./home.ts');
-const { rotateIfDue } = require('./capture.ts');
-const store = require('./store.ts');
-const { projectRoot } = require('../lifecycle/root.ts');
-const { appendEvents, readFold, randomChars, StoreUnsafeError, StoreLockedError } = require('../lifecycle/event-store.ts');
-const { prepareStore } = require('../lifecycle/store-upkeep.ts');
+const { finishRuntime, usageError } = require('../cli-result.js');
+const { maskLine, printSafe } = require('../mask.js');
+const { failureHome, captureSwitch, sentinelPath } = require('./home.js');
+const { rotateIfDue } = require('./capture.js');
+const store = require('./store.js');
+const { projectRoot } = require('../lifecycle/root.js');
+const { appendEvents, readFold, randomChars, StoreUnsafeError, StoreLockedError } = require('../lifecycle/event-store.js');
+const { prepareStore } = require('../lifecycle/store-upkeep.js');
 
 const ACTIONS = ['list', 'settle', 'capture'];
 const STATEMENT_MAX = 280;
@@ -29,10 +29,10 @@ const CONTROL = /[\u0000-\u001F\u007F-\u009F\u2028\u2029\u202A-\u202E\u2066-\u20
 /** A caller mistake (exit 2). */
 class FailureUsageError extends Error {}
 
-const refusal = (action: string, finding: string, message: string) => ({ ok: false, action, finding, message });
+const refusal = (action        , finding        , message        ) => ({ ok: false, action, finding, message });
 
 /** A one-line reason, masked like any other free text, or null when none was given. */
-function cleanReason(raw: any): string | null {
+function cleanReason(raw     )                {
   if (raw === undefined) return null;
   const rawLength = String(raw).length;
   if (rawLength > STATEMENT_MAX * 4) throw new FailureUsageError(`--reason is ${rawLength} characters; the limit is ${STATEMENT_MAX}`);
@@ -44,19 +44,19 @@ function cleanReason(raw: any): string | null {
 }
 
 /** `DoFlow <command> <kind>: <message>`, built only from stored fields, masked and cut to 280 characters. */
-function importedStatement(entry: any): string {
+function importedStatement(entry     )         {
   const raw = `DoFlow ${entry.command} ${entry.kind}${entry.message ? `: ${entry.message}` : ''}`;
   return maskLine(raw.replace(CONTROL, ' ')).text.replace(/\s+/g, ' ').trim().slice(0, STATEMENT_MAX);
 }
 
 // ── list ───────────────────────────────────────────────────────────────────────────────────────
 
-function listFailures({ all = false, env = process.env } = {}): any {
+function listFailures({ all = false, env = process.env } = {})      {
   const home = failureHome(env);
   if (home) rotateIfDue(home);
   const loaded = store.loadEntries({ env });
-  const shown = loaded.entries.filter((entry: any) => all || store.SHOWN_BY_DEFAULT.has(entry.status)).map(store.listedEntry);
-  const result: any = { ok: true, action: 'list', capture: loaded.capture };
+  const shown = loaded.entries.filter((entry     ) => all || store.SHOWN_BY_DEFAULT.has(entry.status)).map(store.listedEntry);
+  const result      = { ok: true, action: 'list', capture: loaded.capture };
   if (loaded.home === null) result.home = null;
   result.entries = shown;
   result.counts = loaded.counts;
@@ -70,7 +70,7 @@ function listFailures({ all = false, env = process.env } = {}): any {
 
 // ── settle ─────────────────────────────────────────────────────────────────────────────────────
 
-function settleFailure({ fp, as, reason, cwd, env = process.env, now = new Date() }: any): any {
+function settleFailure({ fp, as, reason, cwd, env = process.env, now = new Date() }     )      {
   if (typeof fp !== 'string' || !FP.test(fp)) throw new FailureUsageError('--fp is required: the 16 hex characters of an entry from `failure --action list`');
   if (!store.SETTLE_AS.includes(as)) throw new FailureUsageError(`--as must be one of ${store.SETTLE_AS.join(', ')}${as ? ` (got '${as}')` : ''}`);
   const cleaned = cleanReason(reason);
@@ -88,7 +88,7 @@ function settleFailure({ fp, as, reason, cwd, env = process.env, now = new Date(
     for (const text of prepared.lines) console.error(printSafe(`doflow failure: ${text}`));
     if (!prepared.ok) return refusal('settle', prepared.finding, prepared.message);
   }
-  const entry = store.loadEntries({ env }).entries.find((e: any) => e.fp === fp);
+  const entry = store.loadEntries({ env }).entries.find((e     ) => e.fp === fp);
   if (!entry) return refusal('settle', 'unknown-fp', `${fp} is not a failure entry on this machine; list them with doflow-run failure --action list. Nothing was written.`);
 
   if (as !== 'imported') {
@@ -98,10 +98,10 @@ function settleFailure({ fp, as, reason, cwd, env = process.env, now = new Date(
   // Deduplicated on the project's own follow-ups, whatever the settlements say: a follow-up that
   // already comes from this fingerprint is never created twice, even after a noise or fixed settlement.
   const followups = readFold(root, { now }).followups;
-  const existing = followups.find((f: any) => f.source && f.source.kind === 'failure' && f.source.ref === fp);
+  const existing = followups.find((f     ) => f.source && f.source.kind === 'failure' && f.source.ref === fp);
   if (existing) return refusal('settle', 'already-imported', `${fp} was already imported as ${existing.id}. Nothing was written.`);
-  const taken = new Set(followups.map((f: any) => f.id));
-  let id: string;
+  const taken = new Set(followups.map((f     ) => f.id));
+  let id        ;
   do { id = `FU-${randomChars(6)}`; } while (taken.has(id));
   const statement = importedStatement(entry);
   const source = { kind: 'failure', ref: fp };
@@ -113,13 +113,13 @@ function settleFailure({ fp, as, reason, cwd, env = process.env, now = new Date(
   return {
     ok: true, action: 'settle', fp, as,
     followup: { id, statement, source, state: 'open' },
-    events: out.written.map((w: any) => w.file),
+    events: out.written.map((w     ) => w.file),
   };
 }
 
 // ── capture ────────────────────────────────────────────────────────────────────────────────────
 
-function captureState({ set, env = process.env, now = new Date() }: any = {}): any {
+function captureState({ set, env = process.env, now = new Date() }      = {})      {
   if (set !== undefined && set !== 'on' && set !== 'off') throw new FailureUsageError(`--set must be on or off (got '${set}')`);
   const home = failureHome(env);
   if (home !== null && set === 'off') {
@@ -130,21 +130,21 @@ function captureState({ set, env = process.env, now = new Date() }: any = {}): a
   }
   const state = captureSwitch(home, env);
   // With no failure home nothing is captured, whatever the switch says.
-  const result: any = { ok: true, action: 'capture', effective: home === null ? 'off' : state.effective, sentinel: state.sentinel, env: state.env };
+  const result      = { ok: true, action: 'capture', effective: home === null ? 'off' : state.effective, sentinel: state.sentinel, env: state.env };
   if (home === null) result.home = null;
   return result;
 }
 
 // ── verb ───────────────────────────────────────────────────────────────────────────────────────
 
-function lines(result: any): string[] {
+function lines(result     )           {
   if (result.home === null) return ['home: none (capture skipped)', 'capture: off'];
   if (result.action === 'list') {
     const out = [`capture ${result.capture}: ${result.entries.length} entr${result.entries.length === 1 ? 'y' : 'ies'} listed (new ${result.counts.new}, regressed ${result.counts.regressed}, noise ${result.counts.noise}, fixed ${result.counts.fixed}, imported ${result.counts.imported})`];
     for (const e of result.entries) out.push(`${e.fp}  ${e.status}  x${e.count}  ${e.command} ${e.kind}${e.message ? `: ${e.message}` : ''}  (last seen ${e.lastSeen}, ${e.lastVersion})`);
     if (result.unreadable.length) out.push(`unreadable failure files (not read): ${result.unreadable.join(', ')}`);
     if (result.skippedLines) out.push(`${result.skippedLines} unreadable line${result.skippedLines === 1 ? '' : 's'} skipped`);
-    return [...out, ...result.next.map((n: string) => `next: ${n}`)];
+    return [...out, ...result.next.map((n        ) => `next: ${n}`)];
   }
   if (result.action === 'settle') return [`${result.fp} settled as ${result.as}${result.followup ? `, follow-up ${result.followup.id}` : ''}`];
   return [`capture ${result.effective}${result.sentinel ? ' (switched off on this machine)' : ''}${result.env ? ` (DOFLOW_FAILURE_CAPTURE=${result.env})` : ''}`];
@@ -157,17 +157,17 @@ function lines(result: any): string[] {
  * @param {boolean} [options.all] `list`: every status, not just new and regressed
  * @param {Object} [options.flags] fp, as, reason, set
  */
-function handleFailureCommand({ action, cwd, json = false, all = false, flags = {} }: any = {}): any {
-  let result: any;
+function handleFailureCommand({ action, cwd, json = false, all = false, flags = {} }      = {})      {
+  let result     ;
   try {
     if (!ACTIONS.includes(action)) throw new FailureUsageError(`--action is required: one of ${ACTIONS.join(', ')}${action ? ` (got '${action}')` : ''}`);
     if (action === 'list') result = listFailures({ all });
-    else if (action === 'settle') result = settleFailure({ fp: (flags as any).fp, as: (flags as any).as, reason: (flags as any).reason, cwd });
-    else result = captureState({ set: (flags as any).set });
+    else if (action === 'settle') result = settleFailure({ fp: (flags       ).fp, as: (flags       ).as, reason: (flags       ).reason, cwd });
+    else result = captureState({ set: (flags       ).set });
   } catch (error) {
-    if (error instanceof FailureUsageError || error instanceof StoreUnsafeError) return usageError('failure', (error as Error).message, json);
+    if (error instanceof FailureUsageError || error instanceof StoreUnsafeError) return usageError('failure', (error         ).message, json);
     if (!(error instanceof StoreLockedError)) throw error;
-    result = refusal(action, 'store-locked', (error as Error).message);
+    result = refusal(action, 'store-locked', (error         ).message);
   }
   if (json) console.log(JSON.stringify(result, null, 2));
   else if (result.ok === false) console.log(printSafe(`${result.finding}: ${result.message}`));

package/src/runtime/failure/{home.ts → home.js}

@@ -18,7 +18,7 @@ const OFF_VALUES = new Set(['off', '0', 'false', 'no']);
 
 /** @param {Object} [env] defaults to process.env
  * @returns {string|null} the failure home, an absolute path, or null when none can be resolved */
-function failureHome(env: any = process.env): string | null {
+function failureHome(env      = process.env)                {
   const xdg = env.XDG_CONFIG_HOME;
   if (typeof xdg === 'string' && xdg !== '') {
     return path.isAbsolute(xdg) ? path.join(xdg, 'doflow', 'failures') : null;
@@ -28,11 +28,11 @@ function failureHome(env: any = process.env): string | null {
   return null;
 }
 
-const sentinelPath = (home: string): string => path.join(home, 'off');
-const eventsPath = (home: string): string => path.join(home, 'events.jsonl');
+const sentinelPath = (home        )         => path.join(home, 'off');
+const eventsPath = (home        )         => path.join(home, 'events.jsonl');
 
 /** The value of `DOFLOW_FAILURE_CAPTURE` when it is set to anything, else null. */
-function envSetting(env: any = process.env): string | null {
+function envSetting(env      = process.env)                {
   const raw = env.DOFLOW_FAILURE_CAPTURE;
   return typeof raw === 'string' && raw !== '' ? raw : null;
 }
@@ -44,7 +44,7 @@ function envSetting(env: any = process.env): string | null {
  * @param {Object} [env]
  * @returns {{effective: 'on'|'off', sentinel: boolean, env: string|null}}
  */
-function captureSwitch(home: string | null, env: any = process.env): { effective: 'on' | 'off'; sentinel: boolean; env: string | null } {
+function captureSwitch(home               , env      = process.env)                                                                     {
   let sentinel = false;
   if (home) {
     try { sentinel = fs.statSync(sentinelPath(home)).isFile(); } catch { sentinel = false; }
@@ -55,7 +55,7 @@ function captureSwitch(home: string | null, env: any = process.env): { effective
 }
 
 /** The hot-path check a writer makes: the environment first, then one `stat` of the sentinel. */
-function captureIsOff(home: string, env: any = process.env): boolean {
+function captureIsOff(home        , env      = process.env)          {
   const setting = envSetting(env);
   if (setting !== null && OFF_VALUES.has(setting.trim().toLowerCase())) return true;
   try { return fs.statSync(sentinelPath(home)).isFile(); } catch { return false; }

package/src/runtime/failure/{store.ts → store.js}

@@ -18,8 +18,8 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { failureHome, captureSwitch, eventsPath } = require('./home.ts');
-const { printSafe } = require('../mask.ts');
+const { failureHome, captureSwitch, eventsPath } = require('./home.js');
+const { printSafe } = require('../mask.js');
 
 const ROTATED = /^events-\d{8}T\d{6}Z-\d+\.jsonl$/;
 const SETTLEMENTS = 'settlements.jsonl';
@@ -29,18 +29,18 @@ const STATUSES = ['new', 'regressed', 'noise', 'fixed', 'imported'];
 const SHOWN_BY_DEFAULT = new Set(['new', 'regressed']);
 const PROJECTS_KEPT = 5;
 
-const settlementsPath = (home: string): string => path.join(home, SETTLEMENTS);
+const settlementsPath = (home        )         => path.join(home, SETTLEMENTS);
 
 /** @param {{source: string, command: string, kind: string, message: string, frame: string|null}} event */
-function fingerprint(event: any): string {
+function fingerprint(event     )         {
   const text = [event.source, event.command, event.kind, event.message, event.frame || ''].join('\n');
   return crypto.createHash('sha256').update(text).digest('hex').slice(0, 16);
 }
 
 /** One IC-011 line, or null. Only the fields a fold reads are checked. */
-function asEvent(value: any): any {
+function asEvent(value     )      {
   if (!value || typeof value !== 'object' || value.v !== 1) return null;
-  const text = (x: any) => typeof x === 'string';
+  const text = (x     ) => typeof x === 'string';
   if (!text(value.at) || !SOURCES.has(value.source) || !text(value.command) || !text(value.kind)) return null;
   return {
     at: value.at,
@@ -61,20 +61,20 @@ function asEvent(value: any): any {
  * not a regular file (a FIFO would block the read, a device never ends, a symlink may leave the folder)
  * or cannot be read is `unreadable`, and nothing is read from it.
  */
-function readLines(file: string, accept: (v: any) => any): { rows: any[]; skipped: number; unreadable: boolean } {
+function readLines(file        , accept                 )                                                        {
   const c = fs.constants;
-  let text: string;
-  let fd: number | undefined;
+  let text        ;
+  let fd                    ;
   try {
     fd = fs.openSync(file, c.O_RDONLY | (c.O_NOFOLLOW || 0) | (c.O_NONBLOCK || 0));
     if (!fs.fstatSync(fd).isFile()) return { rows: [], skipped: 0, unreadable: true };
     text = fs.readFileSync(fd, 'utf8');
-  } catch (error: any) {
+  } catch (error     ) {
     return { rows: [], skipped: 0, unreadable: error.code !== 'ENOENT' };
   } finally {
     if (fd !== undefined) { try { fs.closeSync(fd); } catch { /* read already done */ } }
   }
-  const rows: any[] = [];
+  const rows        = [];
   let skipped = 0;
   for (const line of text.split('\n')) {
     if (line.trim() === '') continue;
@@ -90,13 +90,13 @@ function readLines(file: string, accept: (v: any) => any): { rows: any[]; skippe
  * @param {string} home
  * @returns {{events: Object[], skippedLines: number, unreadable: string[]}} `unreadable` names the files that were not read
  */
-function readEvents(home: string): { events: any[]; skippedLines: number; unreadable: string[] } {
-  let rotated: string[] = [];
-  try { rotated = fs.readdirSync(home).filter((name: string) => ROTATED.test(name)).sort(); } catch { /* no folder yet */ }
-  const events: any[] = [];
+function readEvents(home        )                                                                {
+  let rotated           = [];
+  try { rotated = fs.readdirSync(home).filter((name        ) => ROTATED.test(name)).sort(); } catch { /* no folder yet */ }
+  const events        = [];
   let skippedLines = 0;
-  const unreadable: string[] = [];
-  for (const file of [...rotated.map((name: string) => path.join(home, name)), eventsPath(home)]) {
+  const unreadable           = [];
+  for (const file of [...rotated.map((name        ) => path.join(home, name)), eventsPath(home)]) {
     const read = readLines(file, asEvent);
     events.push(...read.rows);
     skippedLines += read.skipped;
@@ -105,20 +105,20 @@ function readEvents(home: string): { events: any[]; skippedLines: number; unread
   return { events, skippedLines, unreadable };
 }
 
-function asSettlement(value: any): any {
+function asSettlement(value     )      {
   if (!value || typeof value !== 'object' || value.v !== 1) return null;
   if (typeof value.at !== 'string' || !/^[0-9a-f]{16}$/.test(value.fp) || !SETTLE_AS.includes(value.as)) return null;
   return { at: value.at, fp: value.fp, as: value.as, reason: typeof value.reason === 'string' ? value.reason : null, followup: typeof value.followup === 'string' ? value.followup : null };
 }
 
 /** @returns {{settlements: Object[], skippedLines: number, unreadable: string[]}} in file order, which is time order */
-function readSettlements(home: string): { settlements: any[]; skippedLines: number; unreadable: string[] } {
+function readSettlements(home        )                                                                     {
   const read = readLines(settlementsPath(home), asSettlement);
   return { settlements: read.rows, skippedLines: read.skipped, unreadable: read.unreadable ? [SETTLEMENTS] : [] };
 }
 
 /** The IC-013 status of an entry from its latest settlement and the events seen after it. */
-function statusOf(settlement: any, sinceSettlement: number): string {
+function statusOf(settlement     , sinceSettlement        )         {
   if (!settlement) return 'new';
   if (settlement.as === 'fixed') return sinceSettlement > 0 ? 'regressed' : 'fixed';
   return settlement.as;
@@ -130,7 +130,7 @@ function statusOf(settlement: any, sinceSettlement: number): string {
  * @param {Object[]} settlements
  * @returns {Object[]}
  */
-function foldEntries(events: any[], settlements: any[]): any[] {
+function foldEntries(events       , settlements       )        {
   const latest = new Map();
   for (const s of settlements) latest.set(s.fp, s);
   const groups = new Map();
@@ -139,14 +139,14 @@ function foldEntries(events: any[], settlements: any[]): any[] {
     if (!groups.has(fp)) groups.set(fp, []);
     groups.get(fp).push(event);
   }
-  const entries: any[] = [];
+  const entries        = [];
   for (const [fp, group] of groups) {
-    const ordered = (group as any[]).map((event: any, index: number) => ({ event, index })).sort((a: any, b: any) => (a.event.at < b.event.at ? -1 : a.event.at > b.event.at ? 1 : a.index - b.index)).map((x: any) => x.event);
+    const ordered = (group         ).map((event     , index        ) => ({ event, index })).sort((a     , b     ) => (a.event.at < b.event.at ? -1 : a.event.at > b.event.at ? 1 : a.index - b.index)).map((x     ) => x.event);
     const first = ordered[0];
     const last = ordered[ordered.length - 1];
     const settlement = latest.get(fp) || null;
-    const since = settlement ? ordered.filter((e: any) => e.at > settlement.at).length : ordered.length;
-    const projects: string[] = [];
+    const since = settlement ? ordered.filter((e     ) => e.at > settlement.at).length : ordered.length;
+    const projects           = [];
     for (let i = ordered.length - 1; i >= 0 && projects.length < PROJECTS_KEPT; i--) {
       if (ordered[i].project && !projects.includes(ordered[i].project)) projects.push(ordered[i].project);
     }
@@ -168,16 +168,16 @@ function foldEntries(events: any[], settlements: any[]): any[] {
       message: first.message,
       frame: first.frame,
       projects,
-      harnesses: [...new Set(ordered.map((e: any) => e.harness))].sort(),
-      exitCodes: [...new Set(ordered.map((e: any) => e.exit).filter((x: any) => x !== null))].sort((a: any, b: any) => a - b),
+      harnesses: [...new Set(ordered.map((e     ) => e.harness))].sort(),
+      exitCodes: [...new Set(ordered.map((e     ) => e.exit).filter((x     ) => x !== null))].sort((a     , b     ) => a - b),
       settlement: settlement && { as: settlement.as, at: settlement.at, reason: settlement.reason, followup: settlement.followup },
     }));
   }
-  return entries.sort((a: any, b: any) => (a.lastSeen < b.lastSeen ? 1 : a.lastSeen > b.lastSeen ? -1 : a.fp < b.fp ? -1 : 1));
+  return entries.sort((a     , b     ) => (a.lastSeen < b.lastSeen ? 1 : a.lastSeen > b.lastSeen ? -1 : a.fp < b.fp ? -1 : 1));
 }
 
 /** The shape a listing shows (IC-019). */
-function listedEntry(entry: any): any {
+function listedEntry(entry     )      {
   return {
     fp: entry.fp, status: entry.status, count: entry.count, command: entry.command, kind: entry.kind,
     message: entry.message, lastSeen: entry.lastSeen, lastVersion: entry.lastVersion,
@@ -190,7 +190,7 @@ function listedEntry(entry: any): any {
  * @param {Object} [options.env] defaults to process.env
  * @returns {{home: string|null, capture: 'on'|'off', entries: Object[], counts: Object, skippedLines: number, unreadable: string[]}}
  */
-function loadEntries({ env = process.env } = {}): any {
+function loadEntries({ env = process.env } = {})      {
   const home = failureHome(env);
   const counts = Object.fromEntries(STATUSES.map((status) => [status, 0]));
   // With no failure home nothing is captured, whatever the switch says.
@@ -207,7 +207,7 @@ function loadEntries({ env = process.env } = {}): any {
  * @param {string} home
  * @param {{fp: string, as: string, reason?: string|null, followup?: string|null, now?: Date}} settlement
  */
-function appendSettlement(home: string, { fp, as, reason = null, followup = null, now = new Date() }: any): void {
+function appendSettlement(home        , { fp, as, reason = null, followup = null, now = new Date() }     )       {
   fs.mkdirSync(home, { recursive: true, mode: 0o700 });
   const line = JSON.stringify({ v: 1, at: now.toISOString(), fp, as, reason, followup });
   fs.appendFileSync(settlementsPath(home), `${line}\n`, { flag: 'a', mode: 0o600 });
@@ -216,7 +216,7 @@ function appendSettlement(home: string, { fp, as, reason = null, followup = null
 const DOFLOW_PACKAGE = '@khoavu882/doflow';
 
 /** Whether `root` is the DoFlow repository itself: its `package.json` is named `@khoavu882/doflow`. */
-function isDoflowRepo(root: string): boolean {
+function isDoflowRepo(root        )          {
   try { return JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).name === DOFLOW_PACKAGE; } catch { return false; }
 }
 

package/src/runtime/{feature-resolve.ts → feature-resolve.js}

@@ -4,7 +4,7 @@
 
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { resolveBashHelper } = require('../helper/bash-helper.ts');
+const { resolveBashHelper } = require('../helper/bash-helper.js');
 
 // `resolveActiveFeature` was moved here from `scaffold/generate.js` (which had it from
 // bin/doflow.js) so the scaffold and the decision register ask the same resolver. The root comes
@@ -31,18 +31,18 @@ const PATHS_HELPER = resolveBashHelper('do-paths.sh');
  *   `paths` is the resolver's own parsed JSON (repo-root-relative artifact paths and has_* flags),
  *   so a caller needs no second resolver call.
  */
-function resolveActiveFeature({ projectRoot, slug = null }: { projectRoot: string; slug?: string | null }): any {
+function resolveActiveFeature({ projectRoot, slug = null }                                               )      {
   const helper = resolveBashHelper('do-paths.sh');
   if (!helper) {
     return { error: 'resolver-missing', message: 'the feature resolver (do-paths.sh) is missing from this install' };
   }
-  const args: string[] = [helper, '--json', '--require', 'feature'];
+  const args           = [helper, '--json', '--require', 'feature'];
   if (slug) args.push(`--slug=${slug}`);
 
-  let stdout: string;
+  let stdout        ;
   try {
     stdout = execFileSync('bash', args, { cwd: projectRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-  } catch (error: any) {
+  } catch (error     ) {
     // Exit 2 is the resolver's one non-zero path (no active feature, or an ambiguous one) and it
     // still prints its error object on stdout — that object carries the hint the user needs, so
     // it is read rather than replaced with a generic message. Anything else (no bash, NFR-003)
@@ -56,7 +56,7 @@ function resolveActiveFeature({ projectRoot, slug = null }: { projectRoot: strin
     }
   }
 
-  let paths: any;
+  let paths     ;
   try {
     paths = JSON.parse(stdout);
   } catch {