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

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',

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

@@ -20,7 +20,7 @@
 const SESSION_GAP_MS = 30 * 60 * 1000;
 
 /** Nearest-rank percentile over an unsorted numeric array. */
-function percentile(values: number[], fraction: number): number | null {
+function percentile(values          , fraction        )                {
   if (!values.length) return null;
   const sorted = [...values].sort((a, b) => a - b);
   const rank = Math.max(1, Math.ceil(fraction * sorted.length));
@@ -34,31 +34,31 @@ function percentile(values: number[], fraction: number): number | null {
  * @param {number} [options.gapMs=SESSION_GAP_MS]
  * @returns {{grouping: 'session-field'|'idle-gap', sessions: Array<{id: string, startedAt: string|null, endedAt: string|null, records: Object[]}>}}
  */
-function groupSessions(records: any[], { gapMs = SESSION_GAP_MS } = {}): any {
+function groupSessions(records       , { gapMs = SESSION_GAP_MS } = {})      {
   if (!records.length) return { grouping: 'idle-gap', sessions: [] };
 
   // An explicit session id is a recorded fact; an idle gap is an inference. Prefer the fact, and
   // only when every record carries one — a half-labelled history would mix the two silently.
   if (records.every((record) => record.session)) {
-    const order: string[] = [];
-    const byId = new Map<string, any[]>();
+    const order           = [];
+    const byId = new Map               ();
     for (const record of records) {
       if (!byId.has(record.session)) { byId.set(record.session, []); order.push(record.session); }
-      byId.get(record.session)!.push(record);
+      byId.get(record.session) .push(record);
     }
     return {
       grouping: 'session-field',
       sessions: order.map((id) => ({
         id,
-        startedAt: byId.get(id)![0].timestamp,
-        endedAt: byId.get(id)![byId.get(id)!.length - 1].timestamp,
-        records: byId.get(id)!,
+        startedAt: byId.get(id) [0].timestamp,
+        endedAt: byId.get(id) [byId.get(id) .length - 1].timestamp,
+        records: byId.get(id) ,
       })),
     };
   }
 
-  const sessions: any[] = [];
-  let current: any = null;
+  const sessions        = [];
+  let current      = null;
   for (const record of records) {
     const previous = current && current.records[current.records.length - 1];
     const contiguous = previous && record.at !== null && previous.at !== null && record.at - previous.at <= gapMs;
@@ -73,7 +73,7 @@ function groupSessions(records: any[], { gapMs = SESSION_GAP_MS } = {}): any {
 }
 
 /** The ledger provenance every view carries, so a reader can always tell what was actually read. */
-function ledgerSummary(read: any): any {
+function ledgerSummary(read     )      {
   return {
     dir: read.dir,
     exists: read.exists,
@@ -87,8 +87,8 @@ function ledgerSummary(read: any): any {
 
 /** How many records carry each optional field. Every view reports this, because the difference
  * between "no missed opportunities" and "no data to look for them in" is exactly this table. */
-function fieldCoverage(records: any[]): any {
-  const count = (predicate: (r: any) => boolean) => records.filter(predicate).length;
+function fieldCoverage(records       )      {
+  const count = (predicate                     ) => records.filter(predicate).length;
   return {
     capability: count((r) => Boolean(r.capability)),
     provider: count((r) => Boolean(r.provider)),
@@ -108,7 +108,7 @@ function fieldCoverage(records: any[]): any {
  * @param {number} [options.gapMs]
  * @returns {Object} view model
  */
-function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
+function buildTrace(read     , { gapMs = SESSION_GAP_MS } = {})      {
   const ledger = ledgerSummary(read);
   const { grouping, sessions } = groupSessions(read.records, { gapMs });
   if (!sessions.length) {
@@ -126,7 +126,7 @@ function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
   }
 
   const session = sessions[sessions.length - 1];
-  const steps = session.records.map((record: any, index: number) => ({
+  const steps = session.records.map((record     , index        ) => ({
     n: index + 1,
     timestamp: record.timestamp,
     verb: record.verb,
@@ -151,9 +151,9 @@ function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
       startedAt: session.startedAt,
       endedAt: session.endedAt,
       wallDurationMs: start !== null && end !== null ? Math.max(0, end - start) : null,
-      dispatchedMs: steps.reduce((total: number, step: any) => total + (step.durationMs ?? 0), 0),
+      dispatchedMs: steps.reduce((total        , step     ) => total + (step.durationMs ?? 0), 0),
       stepCount: steps.length,
-      failedSteps: steps.filter((step: any) => step.exitCode !== null && step.exitCode !== 0).length,
+      failedSteps: steps.filter((step     ) => step.exitCode !== null && step.exitCode !== 0).length,
       steps,
     },
   };
@@ -166,13 +166,13 @@ function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
  * @param {Object} read result of `RunLedger#read`
  * @returns {Object} view model
  */
-function buildStats(read: any): any {
-  const records: any[] = read.records;
+function buildStats(read     )      {
+  const records        = read.records;
   const ledger = ledgerSummary(read);
   const durations = records.map((r) => r.durationMs).filter((value) => typeof value === 'number');
 
-  const tally = (keyOf: (r: any) => any) => {
-    const map = new Map<string, any>();
+  const tally = (keyOf                 ) => {
+    const map = new Map             ();
     for (const record of records) {
       const key = keyOf(record);
       if (!key) continue;
@@ -221,7 +221,7 @@ function buildStats(read: any): any {
     byVerb: tally((r) => r.verb),
     byCapability: tally((r) => r.capability),
     byProvider: tally((r) => r.provider),
-    byDay: tally((r) => (r.timestamp ? r.timestamp.slice(0, 10) : null)).sort((a: any, b: any) => a.key.localeCompare(b.key)),
+    byDay: tally((r) => (r.timestamp ? r.timestamp.slice(0, 10) : null)).sort((a     , b     ) => a.key.localeCompare(b.key)),
     coverage: fieldCoverage(records),
   };
 }
@@ -230,7 +230,7 @@ function buildStats(read: any): any {
 
 /** Capability ids the opportunity analyses reason about, kept in one place so a registry rename
  * shows up as one edit rather than four scattered string literals. */
-const CAPABILITY: Record<string, string> = Object.freeze({
+const CAPABILITY                         = Object.freeze({
   exactSearch: 'code.exact-search',
   semanticSearch: 'code.semantic-search',
   relationships: 'code.relationships',
@@ -238,7 +238,7 @@ const CAPABILITY: Record<string, string> = Object.freeze({
   compress: 'command.compress',
 });
 
-const PROVIDER: Record<string, string> = Object.freeze({
+const PROVIDER                         = Object.freeze({
   semantic: 'semble.search',
   structural: 'graphify.query',
   compressor: 'rtk',
@@ -260,7 +260,7 @@ const FINDING = 'FINDING';
 const CLEAR = 'CLEAR';
 
 /** Health of a provider as this analysis needs it: only `HEALTHY` counts as "was available". */
-function providerAvailable(providerHealth: any, id: string): boolean | null {
+function providerAvailable(providerHealth     , id        )                 {
   const entry = providerHealth ? providerHealth[id] : undefined;
   if (!entry) return null; // unknown — not the same as unavailable
   return entry.status === 'HEALTHY';
@@ -281,8 +281,8 @@ function providerAvailable(providerHealth: any, id: string): boolean | null {
  * @param {number} [options.gapMs]
  * @returns {Object} view model
  */
-function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_MS } = {}): any {
-  const records: any[] = read.records;
+function buildDiscover(read     , { providerHealth = null, gapMs = SESSION_GAP_MS } = {})      {
+  const records        = read.records;
   const ledger = ledgerSummary(read);
   const coverage = fieldCoverage(records);
   const { grouping, sessions } = groupSessions(records, { gapMs });
@@ -296,7 +296,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
       + 'Capability-level records are written by runtime calls that resolve a capability to a provider.',
   };
 
-  const analyses: any[] = [];
+  const analyses        = [];
 
   // 1. A broad search that was really a semantic question.
   analyses.push((() => {
@@ -332,13 +332,13 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
     if (!available) return { ...base, status: NOT_APPLICABLE, detail: `\`${PROVIDER.structural}\` is not answering on this machine, so structural queries were not an available alternative.` };
 
     const offenders = sessions
-      .map((session: any) => ({
+      .map((session     ) => ({
         id: session.id,
         startedAt: session.startedAt,
-        searches: session.records.filter((r: any) => r.capability === CAPABILITY.exactSearch).length,
-        structural: session.records.filter((r: any) => r.capability === CAPABILITY.relationships || r.capability === CAPABILITY.impact).length,
+        searches: session.records.filter((r     ) => r.capability === CAPABILITY.exactSearch).length,
+        structural: session.records.filter((r     ) => r.capability === CAPABILITY.relationships || r.capability === CAPABILITY.impact).length,
       }))
-      .filter((session: any) => session.searches >= REPEATED_SEARCHES && session.structural === 0);
+      .filter((session     ) => session.searches >= REPEATED_SEARCHES && session.structural === 0);
     if (!offenders.length) return { ...base, status: CLEAR, detail: `no session ran ${REPEATED_SEARCHES}+ exact searches without also querying the code graph.` };
     return {
       ...base,
@@ -362,7 +362,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
 
     const bulky = records.filter((r) => (r.outputBytes ?? 0) >= LARGE_OUTPUT_BYTES && r.provider !== PROVIDER.compressor);
     if (!bulky.length) return { ...base, status: CLEAR, detail: `no uncompressed run returned ${LARGE_OUTPUT_BYTES} bytes or more.` };
-    const wasted = bulky.reduce((total: number, r: any) => total + r.outputBytes, 0);
+    const wasted = bulky.reduce((total        , r     ) => total + r.outputBytes, 0);
     return {
       ...base,
       status: FINDING,
@@ -379,14 +379,14 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
     const base = { id: 'retries-without-readiness', title: 'Implementation retries with no readiness check beforehand' };
     if (!records.length) return { ...base, status: NOT_DETERMINED, detail: 'the ledger holds no runs to analyse.' };
     const retrying = sessions
-      .map((session: any) => ({
+      .map((session     ) => ({
         id: session.id,
         startedAt: session.startedAt,
-        failedVerifications: session.records.filter((r: any) => r.verb === 'verify' && r.exitCode !== undefined && r.exitCode !== 0).length,
-        recoveries: session.records.filter((r: any) => r.verb === 'recover').length,
-        readinessCalls: session.records.filter((r: any) => r.verb === 'readiness').length,
+        failedVerifications: session.records.filter((r     ) => r.verb === 'verify' && r.exitCode !== undefined && r.exitCode !== 0).length,
+        recoveries: session.records.filter((r     ) => r.verb === 'recover').length,
+        readinessCalls: session.records.filter((r     ) => r.verb === 'readiness').length,
       }))
-      .filter((session: any) => session.failedVerifications >= RETRY_THRESHOLD || session.recoveries >= 1);
+      .filter((session     ) => session.failedVerifications >= RETRY_THRESHOLD || session.recoveries >= 1);
     if (!retrying.length) {
       // The retry signal is a `verify` that FAILED (non-zero exit_code) or a `recover` run. A
       // `verify` record with no exit_code carries neither, and that is the shape the shell
@@ -408,7 +408,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
           : 'no `verify` with a recorded exit code and no `recover` run appears in this window, so there is no retry behaviour to judge.',
       };
     }
-    const unguarded = retrying.filter((session: any) => session.readinessCalls === 0);
+    const unguarded = retrying.filter((session     ) => session.readinessCalls === 0);
     if (!unguarded.length) {
       return {
         ...base,
@@ -430,7 +430,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
   const undetermined = analyses.filter((analysis) => analysis.status === NOT_DETERMINED);
 
   // The verdict never claims a clean bill of health over data that could not answer the question.
-  let verdict: string;
+  let verdict        ;
   if (findings.length) verdict = 'findings';
   else if (undetermined.length === analyses.length) verdict = 'insufficient-data';
   else if (undetermined.length) verdict = 'no-findings-in-the-analyses-that-could-run';