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

package/src/runtime/{task-scope.ts → task-scope.js}

@@ -4,7 +4,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { resolveActiveFeature } = require('./feature-resolve.ts');
+const { resolveActiveFeature } = require('./feature-resolve.js');
 
 // Which feature a task record belongs to (feature 045, IC-001/IC-002).
 //
@@ -19,7 +19,7 @@ const SAFE_SLUG = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const SLUG_RULE = 'use letters, digits, dot, underscore or dash, start with a letter or digit, and no ".."';
 
 /** The one shape check for a feature slug (IC-009); do-paths.sh applies the same rule in bash. */
-function isSafeSlug(slug: any): boolean {
+function isSafeSlug(slug     )          {
   return typeof slug === 'string' && SAFE_SLUG.test(slug) && !slug.includes('..');
 }
 
@@ -29,31 +29,31 @@ function isSafeSlug(slug: any): boolean {
  * @param {*} slug
  * @returns {{error: 'invalid-slug', message: string, hint: string}|null}
  */
-function invalidSlugRefusal(slug: any): { error: 'invalid-slug'; message: string; hint: string } | null {
+function invalidSlugRefusal(slug     )                                                                  {
   if (typeof slug !== 'string' || slug === '' || isSafeSlug(slug)) return null;
   return { error: 'invalid-slug', message: `slug "${slug}" is not a valid feature slug: ${SLUG_RULE}`, hint: SLUG_RULE };
 }
 
 /** (projectRoot, slug) -> { slug, hasRegister } | { reason }. One resolver spawn per key per process. */
-const featureCache = new Map<string, any>();
+const featureCache = new Map             ();
 
 /** A slug the CLI named explicitly (`--slug`), applied to every store call in this process that was
  * not given its own. The dispatcher sets it once so the verbs whose handlers build their ledger
  * internally (readiness, evidence) route the same way as the ones that take `slug` directly. */
-let defaultSlug: string | null = null;
+let defaultSlug                = null;
 
-function setDefaultSlug(slug: any): void {
+function setDefaultSlug(slug     )       {
   defaultSlug = typeof slug === 'string' && slug !== '' ? slug : null;
 }
 
-function clearTaskScopeCache(): void {
+function clearTaskScopeCache()       {
   featureCache.clear();
 }
 
 /** The resolver reports the git top level, which is the project root or one of its ancestors, and
  * the feature folders live directly under it — so no `agent-docs/doflow` on the way up means there
  * is nothing to resolve and the spawn is skipped. */
-function hasFeatureFolderAbove(projectRoot: string): boolean {
+function hasFeatureFolderAbove(projectRoot        )          {
   let dir = path.resolve(projectRoot);
   for (;;) {
     try {
@@ -65,10 +65,10 @@ function hasFeatureFolderAbove(projectRoot: string): boolean {
   }
 }
 
-function featureFor(projectRoot: string, slug: string | null | undefined): any {
+function featureFor(projectRoot        , slug                           )      {
   const key = `${path.resolve(projectRoot)}\0${slug || ''}`;
   if (featureCache.has(key)) return featureCache.get(key);
-  let value: any = { reason: 'no-feature' };
+  let value      = { reason: 'no-feature' };
   try {
     if (hasFeatureFolderAbove(projectRoot)) {
       const found = resolveActiveFeature({ projectRoot, slug: slug || null });
@@ -90,7 +90,7 @@ function featureFor(projectRoot: string, slug: string | null | undefined): any {
  *   `reason` is `namespaced` when a namespace applies, else `no-feature`, `no-register` or
  *   `feature-level-id`.
  */
-function resolveTaskScope({ projectRoot, taskId, slug = null }: { projectRoot: string; taskId: string; slug?: string | null }): { namespace: string | null; slug: string | null; reason: string } {
+function resolveTaskScope({ projectRoot, taskId, slug = null }                                                               )                                                                    {
   const feature = featureFor(projectRoot, slug || defaultSlug);
   if (feature.reason) return { namespace: null, slug: null, reason: feature.reason };
   if (!feature.hasRegister) return { namespace: null, slug: feature.slug, reason: 'no-register' };
@@ -107,7 +107,7 @@ function resolveTaskScope({ projectRoot, taskId, slug = null }: { projectRoot: s
  * @param {string} options.slug
  * @returns {boolean}
  */
-function slugNamesNoFeature({ projectRoot, slug }: { projectRoot: string; slug: string }): boolean {
+function slugNamesNoFeature({ projectRoot, slug }                                       )          {
   const feature = featureFor(projectRoot, slug);
   return Boolean(feature.reason) || feature.exists === false;
 }
@@ -121,7 +121,7 @@ function slugNamesNoFeature({ projectRoot, slug }: { projectRoot: string; slug:
  * @param {string|null} [options.slug]
  * @returns {string}
  */
-function taskStoreDir({ projectRoot, store, taskId, slug = null }: { projectRoot: string; store: string; taskId: string; slug?: string | null }): string {
+function taskStoreDir({ projectRoot, store, taskId, slug = null }                                                                              )         {
   const base = path.join(projectRoot, '.doflow', 'state', store);
   const { namespace } = resolveTaskScope({ projectRoot, taskId, slug });
   return namespace ? path.join(base, namespace) : base;

package/src/runtime/{task-state.ts → task-state.js}

@@ -28,8 +28,8 @@ const { isDeepStrictEqual } = require('node:util');
 
 /** Three-way merge against the reader's snapshot. Unchanged local records never overwrite a
  * newer disk version; concurrent edits to the same record must be retried after an explicit read. */
-function mergeRecords(local: any[], disk: any[], baseline: Map<any, any>): any[] {
-  const merged = new Map(disk.map((item: any) => [item.id, item]));
+function mergeRecords(local       , disk       , baseline               )        {
+  const merged = new Map(disk.map((item     ) => [item.id, item]));
   for (const item of local) {
     const previous = baseline.get(item.id);
     const current = merged.get(item.id);
@@ -48,7 +48,7 @@ const LOCK_RETRIES = 250;
 const LOCK_WAIT_MS = 20;
 
 /** Synchronous sleep without spinning: Atomics.wait on a throwaway buffer. */
-function sleep(ms: number): void {
+function sleep(ms        )       {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
@@ -59,28 +59,28 @@ function sleep(ms: number): void {
  * @param {string} file
  * @returns {(() => void)|null}
  */
-function tryAcquireLock(fsImpl: any, file: string): (() => void) | null {
+function tryAcquireLock(fsImpl     , file        )                      {
   const lockDir = `${file}.lock`;
   const release = () => { try { fsImpl.rmdirSync(lockDir); } catch { /* released is released */ } };
   try {
     fsImpl.mkdirSync(lockDir);
     return release;
-  } catch (error: any) {
+  } catch (error     ) {
     if (error.code !== 'EEXIST') throw error;
   }
-  let lock: any;
-  try { lock = fsImpl.statSync(lockDir); } catch (error: any) {
+  let lock     ;
+  try { lock = fsImpl.statSync(lockDir); } catch (error     ) {
     if (error.code !== 'ENOENT') return null;
-    try { fsImpl.mkdirSync(lockDir); return release; } catch (retryError: any) {
+    try { fsImpl.mkdirSync(lockDir); return release; } catch (retryError     ) {
       if (retryError.code === 'EEXIST') return null;
       throw retryError;
     }
   }
   if (Date.now() - lock.mtimeMs <= LOCK_STALE_MS) return null;
-  try { fsImpl.rmdirSync(lockDir); } catch (error: any) {
+  try { fsImpl.rmdirSync(lockDir); } catch (error     ) {
     if (error.code !== 'ENOENT') return null;
   }
-  try { fsImpl.mkdirSync(lockDir); return release; } catch (error: any) {
+  try { fsImpl.mkdirSync(lockDir); return release; } catch (error     ) {
     if (error.code === 'EEXIST') return null;
     throw error;
   }
@@ -93,7 +93,7 @@ function tryAcquireLock(fsImpl: any, file: string): (() => void) | null {
  * @param {string} file
  * @returns {() => void}
  */
-function acquireLock(fsImpl: any, file: string): () => void {
+function acquireLock(fsImpl     , file        )             {
   const lockDir = `${file}.lock`;
   // The stale rule below is wall-clock, so the wait must be too: on a host where each attempt costs
   // real time, counting attempts alone would outlive a live holder's staleness window and then
@@ -123,12 +123,12 @@ function acquireLock(fsImpl: any, file: string): () => void {
  * @param {string} file
  * @returns {Object|null} the parsed payload
  */
-function readTaskState(fsImpl: any, file: string): any {
+function readTaskState(fsImpl     , file        )      {
   if (!fsImpl.existsSync(file)) return null;
-  let data: any;
+  let data     ;
   try {
     data = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
-  } catch (error: any) {
+  } catch (error     ) {
     throw new Error(`Failed to load state file '${file}': ${error.message}. The write path is atomic `
       + '(tmp + rename), so a torn file means outside interference; recover it from version control '
       + 'or move it aside and re-record the task\'s items.');
@@ -153,7 +153,7 @@ function readTaskState(fsImpl: any, file: string): any {
  *   that must inspect or set aside what is there under the same exclusion as the write
  * @returns {string} the file path written
  */
-function updateTaskState({ fsImpl, file, build, prepare }: { fsImpl: any; file: string; build: (disk: any) => any; prepare?: () => void }): string {
+function updateTaskState({ fsImpl, file, build, prepare }                                                                                )         {
   fsImpl.mkdirSync(path.dirname(file), { recursive: true });
   const release = acquireLock(fsImpl, file);
   try {

package/src/runtime/trace/{indicators.ts → indicators.js}

@@ -26,16 +26,16 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { formatMs, finish } = require('./render.ts');
+const { formatMs, finish } = require('./render.js');
 
 const ORCHESTRATION_DIRNAME = 'orchestration';
 
 /** Mirrors resolveRunsLocation's shape, for the sibling state directory this reads. */
-function orchestrationDir(root: string): string {
+function orchestrationDir(root        )         {
   return path.join(root, '.doflow', 'state', ORCHESTRATION_DIRNAME);
 }
 
-function parseAt(value: any): number | null {
+function parseAt(value     )                {
   const ms = Date.parse(value);
   return Number.isNaN(ms) ? null : ms;
 }
@@ -43,10 +43,10 @@ function parseAt(value: any): number | null {
 /** Every record in a directory, plus the names of the ones that did not parse. A file that cannot be
  * read is counted and named rather than skipped: a report that quietly drops what it could not read
  * overstates its own coverage, which is the defect `malformedLines` already guards against for runs. */
-function readRecords(dir: string, fsImpl: any = fs): any {
+function readRecords(dir        , fsImpl      = fs)      {
   if (!fsImpl.existsSync(dir)) return { records: [], unreadable: [], exists: false };
-  const records: any[] = [];
-  const unreadable: any[] = [];
+  const records        = [];
+  const unreadable        = [];
   for (const name of fsImpl.readdirSync(dir).sort()) {
     if (!name.endsWith('.json')) continue;
     try {
@@ -56,7 +56,7 @@ function readRecords(dir: string, fsImpl: any = fs): any {
         continue;
       }
       records.push(parsed);
-    } catch (err: any) {
+    } catch (err     ) {
       unreadable.push({ file: name, reason: err.message });
     }
   }
@@ -65,11 +65,11 @@ function readRecords(dir: string, fsImpl: any = fs): any {
 
 /** A stage row is "not work done" when the orchestrator backfilled it or imported it rather than
  * executing it. Its duration measures when the record was written, so it is listed but never averaged. */
-function isSynthetic(entry: any): boolean {
+function isSynthetic(entry     )          {
   return Boolean(entry.backfilled) || (entry.executionStatus && entry.executionStatus !== 'completed');
 }
 
-function median(values: number[]): number | null {
+function median(values          )                {
   if (!values.length) return null;
   const sorted = [...values].sort((a, b) => a - b);
   const mid = Math.floor(sorted.length / 2);
@@ -77,11 +77,11 @@ function median(values: number[]): number | null {
 }
 
 /** One run's rows, walking history in recorded order with a cursor so no interval is counted twice. */
-function runRows(record: any): any {
+function runRows(record     )      {
   const history = Array.isArray(record.history) ? record.history : [];
   let cursor = parseAt(record.startedAt);
-  const stages: any[] = [];
-  const gates: any[] = [];
+  const stages        = [];
+  const gates        = [];
   let reruns = 0;
 
   for (const entry of history) {
@@ -131,13 +131,13 @@ function runRows(record: any): any {
 /** Median elapsed per stage id across runs of one class. Synthetic rows are excluded here and still
  * listed in their run: averaging the moment a file was written into the figure most likely to be
  * quoted would corrupt it. */
-function aggregateStages(runs: any[]): any[] {
-  const perStage = new Map<string, number[]>();
+function aggregateStages(runs       )        {
+  const perStage = new Map                  ();
   for (const run of runs) {
     for (const row of run.stages) {
       if (row.synthetic || row.elapsedMs === null || !row.stage) continue;
       if (!perStage.has(row.stage)) perStage.set(row.stage, []);
-      perStage.get(row.stage)!.push(row.elapsedMs);
+      perStage.get(row.stage) .push(row.elapsedMs);
     }
   }
   return [...perStage.entries()].map(([stage, values]) => ({
@@ -146,14 +146,14 @@ function aggregateStages(runs: any[]): any[] {
 }
 
 /** Pure. Reads nothing and writes nothing; takes already-parsed records. */
-function buildIndicators({ records = [], unreadable = [], exists = true } = {}): any {
-  const runs = (records as any[]).map(runRows);
-  const byClass = new Map<string, any>();
+function buildIndicators({ records = [], unreadable = [], exists = true } = {})      {
+  const runs = (records         ).map(runRows);
+  const byClass = new Map             ();
 
   for (const run of runs) {
     const key = run.taskClass || '(unclassified)';
     if (!byClass.has(key)) byClass.set(key, { taskClass: key, runs: [], stageAggregate: [] });
-    byClass.get(key)!.runs.push(run);
+    byClass.get(key) .runs.push(run);
   }
 
   for (const group of byClass.values()) group.stageAggregate = aggregateStages(group.runs);
@@ -176,7 +176,7 @@ function buildIndicators({ records = [], unreadable = [], exists = true } = {}):
 }
 
 /** One class block: its runs, each run's stage and gate rows, then the class median. */
-function printClass(group: any): void {
+function printClass(group     )       {
   console.log('─'.repeat(78));
   console.log(`CLASS: ${group.taskClass}   (${group.runs.length} run(s))`);
   for (const run of group.runs) {
@@ -195,7 +195,7 @@ function printClass(group: any): void {
   }
 }
 
-function handleIndicatorsCommand({ json = false, projectRoot = process.cwd() } = {}): number {
+function handleIndicatorsCommand({ json = false, projectRoot = process.cwd() } = {})         {
   const dir = orchestrationDir(projectRoot);
   const read = readRecords(dir);
   const view = buildIndicators(read);
@@ -220,7 +220,7 @@ function handleIndicatorsCommand({ json = false, projectRoot = process.cwd() } =
 
   console.log(`Runs:      ${view.runCount} across ${view.byClass.length} task class(es)`);
   if (view.unreadable.length) {
-    console.log(`Unreadable: ${view.unreadable.length} record(s) — ${view.unreadable.map((u: any) => u.file).join(', ')}`);
+    console.log(`Unreadable: ${view.unreadable.length} record(s) — ${view.unreadable.map((u     ) => u.file).join(', ')}`);
   }
 
   for (const group of view.byClass) printClass(group);

package/src/runtime/trace/{ledger.ts → ledger.js}

@@ -12,7 +12,7 @@ const {
   buildStats,
   buildDiscover,
   PROVIDER,
-} = require('./views.ts');
+} = require('./views.js');
 const {
   shortTime,
   formatMs,
@@ -20,7 +20,7 @@ const {
   integrityNote,
   printEmptyLedgerNotice,
   DISCOVER_MARK,
-} = require('./render.ts');
+} = require('./render.js');
 
 /**
  * Task-run telemetry — the JavaScript port of
@@ -49,7 +49,7 @@ const {
  * They price one specific model; a trace naming a different one gets a cost only if the caller
  * supplies its rates, because inventing a price for an unpriced model is inventing a metric.
  */
-const DEFAULT_TOKEN_RATES: Readonly<{ inputPerToken: number; outputPerToken: number }> = Object.freeze({
+const DEFAULT_TOKEN_RATES                                                              = Object.freeze({
   inputPerToken: 0.000003,
   outputPerToken: 0.000015,
 });
@@ -60,20 +60,20 @@ const COST_DECIMALS = 6;
  * @param {number} value
  * @returns {number} rounded to six decimals, matching the Python's `round(x, 6)`
  */
-function roundCost(value: number): number {
+function roundCost(value        )         {
   const factor = 10 ** COST_DECIMALS;
   return Math.round(value * factor) / factor;
 }
 
 class TaskRunTelemetry {
-  taskId: string;
-  agent: string;
-  model: string;
-  rates: { inputPerToken: number; outputPerToken: number } | null;
-  events: any[];
-  clock: () => number;
-  startedAtMs: number;
-  startedAt: string;
+  taskId        ;
+  agent        ;
+  model        ;
+  rates                                                          ;
+  events       ;
+  clock              ;
+  startedAtMs        ;
+  startedAt        ;
 
   /**
    * @param {string} taskId
@@ -84,7 +84,7 @@ class TaskRunTelemetry {
    * @param {{inputPerToken: number, outputPerToken: number}|null} [options.rates]
    * @param {Function} [options.clock] injection seam for tests; returns elapsed milliseconds
    */
-  constructor(taskId: string, options: any = {}) {
+  constructor(taskId        , options      = {}) {
     const opts = typeof options === 'string' ? { agent: options } : options;
     this.taskId = taskId;
     this.agent = opts.agent || 'codex';
@@ -105,7 +105,7 @@ class TaskRunTelemetry {
    * @param {Object} [details={}]
    * @returns {Object} the recorded event
    */
-  recordEvent(eventType: string, details: any = {}): any {
+  recordEvent(eventType        , details      = {})      {
     const event = {
       timestamp: new Date().toISOString(),
       type: eventType,
@@ -119,7 +119,7 @@ class TaskRunTelemetry {
    * Milliseconds elapsed since the recorder was constructed.
    * @returns {number}
    */
-  elapsedMs(): number {
+  elapsedMs()         {
     return Math.max(0, this.clock() - this.startedAtMs);
   }
 
@@ -130,7 +130,7 @@ class TaskRunTelemetry {
    * @param {number} [outputTokens=0]
    * @returns {Object} trace record
    */
-  exportTrace(success: boolean, inputTokens: number = 0, outputTokens: number = 0): any {
+  exportTrace(success         , inputTokens         = 0, outputTokens         = 0)      {
     // Defect fix (2): cost is only reported when rates are known for this run. The default rates
     // reproduce the Python's number exactly; a caller that clears them (`rates: null`) gets `null`
     // rather than a confident figure derived from another model's price list.
@@ -180,7 +180,7 @@ const LEDGER_FILE_RE = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
  * `wire` is the on-disk key: snake_case, matching the five fields `doflow-run` already writes, so
  * one file never mixes two naming conventions.
  */
-const RUN_FIELDS: Readonly<Array<{ key: string; wire: string; type: string }>> = Object.freeze([
+const RUN_FIELDS                                                               = Object.freeze([
   { key: 'verb', wire: 'verb', type: 'token' },
   { key: 'kind', wire: 'kind', type: 'token' },
   { key: 'capability', wire: 'capability', type: 'token' },
@@ -215,7 +215,7 @@ const ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$/;
  * @param {string} configDir an install root, e.g. `<project>/.doflow` or `~/.doflow`
  * @returns {string}
  */
-function runsDir(configDir: string): string {
+function runsDir(configDir        )         {
   return path.join(configDir, 'state', RUNS_DIRNAME);
 }
 
@@ -234,8 +234,8 @@ function runsDir(configDir: string): string {
  *   subdirectory, so a project with state but no guidance tree falls through to the home install
  * @returns {{dir: string, configDir: string, origin: string, searched: string[]}}
  */
-function resolveRunsLocation({ start, global: forceGlobal = false, env = process.env, homeDir = os.homedir(), fsImpl = fs, containing = '' }: any = {}): any {
-  const searched: string[] = [];
+function resolveRunsLocation({ start, global: forceGlobal = false, env = process.env, homeDir = os.homedir(), fsImpl = fs, containing = '' }      = {})      {
+  const searched           = [];
   const home = path.resolve(homeDir || '.');
   if (forceGlobal) {
     const configDir = path.join(home, '.doflow');
@@ -274,14 +274,14 @@ function resolveRunsLocation({ start, global: forceGlobal = false, env = process
  *   fields and never carries their values — a rejection report that echoed the value would leak
  *   exactly the content the rejection exists to keep out.
  */
-function sanitizeRunEvent(input: any, { now = new Date() } = {}): any {
+function sanitizeRunEvent(input     , { now = new Date() } = {})      {
   if (!input || typeof input !== 'object' || Array.isArray(input)) {
     return { record: null, dropped: [], reason: 'event must be an object' };
   }
   const byKey = new Map(RUN_FIELDS.map((field) => [field.key, field]));
   const byWire = new Map(RUN_FIELDS.map((field) => [field.wire, field]));
-  const record: any = {};
-  const dropped: string[] = [];
+  const record      = {};
+  const dropped           = [];
 
   const timestamp = typeof input.timestamp === 'string' && ISO_TIMESTAMP.test(input.timestamp)
     ? input.timestamp
@@ -317,9 +317,9 @@ function sanitizeRunEvent(input: any, { now = new Date() } = {}): any {
  * @param {*} raw parsed JSON value
  * @returns {Object|null} null when the line is not a usable record
  */
-function normalizeRunRecord(raw: any): any | null {
+function normalizeRunRecord(raw     )             {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
-  const out: any = { timestamp: typeof raw.timestamp === 'string' ? raw.timestamp : null };
+  const out      = { timestamp: typeof raw.timestamp === 'string' ? raw.timestamp : null };
   for (const field of RUN_FIELDS) {
     const value = raw[field.wire] !== undefined ? raw[field.wire] : raw[field.key];
     if (value === undefined || value === null) continue;
@@ -337,9 +337,9 @@ function normalizeRunRecord(raw: any): any | null {
 }
 
 class RunLedger {
-  fsImpl: any;
-  clock: () => Date;
-  dir: string;
+  fsImpl     ;
+  clock            ;
+  dir        ;
 
   /**
    * @param {Object} [options]
@@ -348,7 +348,7 @@ class RunLedger {
    * @param {Object} [options.fsImpl=fs]
    * @param {Function} [options.clock] returns the current Date; injection seam for tests
    */
-  constructor({ dir, configDir, fsImpl = fs, clock = () => new Date() }: any = {}) {
+  constructor({ dir, configDir, fsImpl = fs, clock = () => new Date() }      = {}) {
     this.fsImpl = fsImpl;
     this.clock = clock;
     if (dir) this.dir = path.resolve(dir);
@@ -362,7 +362,7 @@ class RunLedger {
    * @param {Object} event
    * @returns {{written: boolean, file?: string, record?: Object, dropped: string[], reason?: string}}
    */
-  append(event: any): any {
+  append(event     )      {
     const { record, dropped, reason } = sanitizeRunEvent(event, { now: this.clock() });
     if (!record) return { written: false, dropped, reason };
     try {
@@ -370,7 +370,7 @@ class RunLedger {
       const file = path.join(this.dir, `${record.timestamp.slice(0, 10)}.jsonl`);
       this.fsImpl.appendFileSync(file, `${JSON.stringify(record)}\n`, 'utf8');
       return { written: true, file, record, dropped };
-    } catch (error: any) {
+    } catch (error     ) {
       return { written: false, record, dropped, reason: error.message };
     }
   }
@@ -383,8 +383,8 @@ class RunLedger {
    * @param {number} [options.days] keep only partitions dated within the last N calendar days
    * @returns {{dir: string, exists: boolean, files: string[], records: Object[], malformedLines: number, unreadableFiles: string[], days: number|null}}
    */
-  read({ days = null }: any = {}): any {
-    const result: any = {
+  read({ days = null }      = {})      {
+    const result      = {
       dir: this.dir,
       exists: false,
       files: [],
@@ -394,7 +394,7 @@ class RunLedger {
       days: days && days > 0 ? days : null,
     };
 
-    let entries: string[];
+    let entries          ;
     try {
       entries = this.fsImpl.readdirSync(this.dir);
     } catch {
@@ -402,7 +402,7 @@ class RunLedger {
     }
     result.exists = true;
 
-    let names: string[] = entries.filter((name) => LEDGER_FILE_RE.test(name)).sort();
+    let names           = entries.filter((name) => LEDGER_FILE_RE.test(name)).sort();
     if (result.days) {
       // Calendar days, not "the last N files": a quiet week must not silently widen the window.
       const cutoff = new Date(this.clock().getTime() - (result.days - 1) * 24 * 60 * 60 * 1000)
@@ -412,7 +412,7 @@ class RunLedger {
     result.files = names;
 
     for (const name of names) {
-      let text: string;
+      let text        ;
       try {
         text = this.fsImpl.readFileSync(path.join(this.dir, name), 'utf8');
       } catch {
@@ -421,7 +421,7 @@ class RunLedger {
       }
       for (const line of text.split('\n')) {
         if (line.trim() === '') continue;
-        let parsed: any;
+        let parsed     ;
         try {
           parsed = JSON.parse(line);
         } catch {
@@ -436,7 +436,7 @@ class RunLedger {
     }
 
     // Undated records sort last rather than being dropped: they still count toward usage.
-    result.records.sort((a: any, b: any) => (a.at ?? Number.MAX_SAFE_INTEGER) - (b.at ?? Number.MAX_SAFE_INTEGER));
+    result.records.sort((a     , b     ) => (a.at ?? Number.MAX_SAFE_INTEGER) - (b.at ?? Number.MAX_SAFE_INTEGER));
     return result;
   }
 }
@@ -455,7 +455,7 @@ class RunLedger {
  * @param {string} [options.projectRoot]
  * @returns {number} process exit code
  */
-function handleTraceCommand({ json = false, days = null, global: useGlobal = false, projectRoot }: any = {}): number {
+function handleTraceCommand({ json = false, days = null, global: useGlobal = false, projectRoot }      = {})         {
   const location = resolveRunsLocation({ start: projectRoot, global: useGlobal });
   const view = buildTrace(new RunLedger({ dir: location.dir }).read({ days }));
   view.origin = location.origin;
@@ -503,7 +503,7 @@ function handleTraceCommand({ json = false, days = null, global: useGlobal = fal
  * @param {Object} options
  * @returns {number} process exit code
  */
-function handleStatsCommand({ json = false, days = null, global: useGlobal = false, projectRoot }: any = {}): number {
+function handleStatsCommand({ json = false, days = null, global: useGlobal = false, projectRoot }      = {})         {
   const location = resolveRunsLocation({ start: projectRoot, global: useGlobal });
   const view = buildStats(new RunLedger({ dir: location.dir }).read({ days }));
   view.origin = location.origin;
@@ -556,7 +556,7 @@ function handleStatsCommand({ json = false, days = null, global: useGlobal = fal
  * @param {Object} [options.providerHealth] injected for tests; probed from `health.ts` otherwise
  * @returns {number} process exit code — 1 when there is a finding to act on
  */
-function handleDiscoverCommand({ json = false, days = null, global: useGlobal = false, projectRoot, providerHealth }: any = {}): number {
+function handleDiscoverCommand({ json = false, days = null, global: useGlobal = false, projectRoot, providerHealth }      = {})         {
   const location = resolveRunsLocation({ start: projectRoot, global: useGlobal });
   const read = new RunLedger({ dir: location.dir }).read({ days });
 
@@ -565,7 +565,7 @@ function handleDiscoverCommand({ json = false, days = null, global: useGlobal =
   let health = providerHealth;
   if (health === undefined) {
     try {
-      health = require('../health.ts').probeProviders({ ids: Object.values(PROVIDER) });
+      health = require('../health.js').probeProviders({ ids: Object.values(PROVIDER) });
     } catch {
       health = null;
     }

package/src/runtime/trace/{render.ts → render.js}

@@ -12,12 +12,12 @@
 
 /** ISO timestamp to a compact local-independent `MM-DD HH:MM:SS`. Keeps columns narrow without
  * inventing a timezone the record does not carry. */
-function shortTime(timestamp: any): string {
+function shortTime(timestamp     )         {
   if (typeof timestamp !== 'string' || timestamp.length < 19) return '(undated)';
   return `${timestamp.slice(5, 10)} ${timestamp.slice(11, 19)}`;
 }
 
-function formatMs(value: any): string {
+function formatMs(value     )         {
   if (typeof value !== 'number') return '-';
   if (value < 1000) return `${value}ms`;
   return `${(value / 1000).toFixed(1)}s`;
@@ -33,7 +33,7 @@ function formatMs(value: any): string {
  * @param {number} code
  * @returns {number}
  */
-function finish(code: number): number {
+function finish(code        )         {
   process.exitCode = code;
   return code;
 }
@@ -44,22 +44,22 @@ function finish(code: number): number {
  * @param {Object} ledger
  * @returns {string|null}
  */
-function integrityNote(ledger: any): string | null {
-  const parts: string[] = [];
+function integrityNote(ledger     )                {
+  const parts           = [];
   if (ledger.malformedLines) parts.push(`${ledger.malformedLines} unreadable ledger line(s) skipped`);
   if (ledger.unreadableFiles.length) parts.push(`${ledger.unreadableFiles.length} unreadable partition(s): ${ledger.unreadableFiles.join(', ')}`);
   return parts.length ? `Note: ${parts.join('; ')}.` : null;
 }
 
 /** One place that turns a resolved location into the sentence an empty ledger deserves. */
-function printEmptyLedgerNotice(ledger: any, reason: any): void {
+function printEmptyLedgerNotice(ledger     , reason     )       {
   console.log(`  ${reason}`);
   console.log(`  Location: ${ledger.dir}`);
   console.log('  An empty ledger is a normal state for a fresh install. It is not evidence that');
   console.log('  nothing ran, and no conclusion about usage can be drawn from it.');
 }
 
-const DISCOVER_MARK: Record<string, string> = Object.freeze({
+const DISCOVER_MARK                         = Object.freeze({
   FINDING: '! FINDING',
   CLEAR: '✓ CLEAR',
   NOT_DETERMINED: '? UNKNOWN',