@veraxhq/verax 0.3.0 → 0.4.0

package/src/cli/util/trust-integration-hooks.js

@@ -0,0 +1,164 @@
+/**
+ * PHASE 6B: ACTIVATION
+ * 
+ * Activates Phase 6A by enforcing it as MANDATORY for all scan paths.
+ * 
+ * This module wraps Phase 6A and integrates it with run.js to ensure:
+ * 1. All scans use Phase 6A (no bypass possible)
+ * 2. Artifacts can only be written to staging
+ * 3. Integrity is verified before commit
+ * 4. Poison markers prevent reading corrupted runs
+ */
+
+import { initPhase6A as phase6aInit, completePhase6A as phase6aComplete, rollbackPhase6A as phase6aRollback, checkPoisonMarker } from './trust-activation-integration.js';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * Initialize Phase 6A (poison marker + staging directory)
+ * MANDATORY at run start - called before any artifact writing
+ * 
+ * @param {string} runDir - Run directory (e.g., .verax/runs/<runId>)
+ * @returns {Promise<{ success: boolean, error?: Error }>}
+ */
+export async function initializePhase6A(runDir) {
+  try {
+    const result = await phase6aInit(runDir);
+    return result;
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+/**
+ * Get paths with staging directory redirection
+ * MANDATORY - replaces all artifact paths to point to staging directory
+ * 
+ * This ensures ALL artifact writes go to staging instead of final location.
+ * 
+ * @param {Object} paths - Original paths from getRunPaths()
+ * @returns {Object} Modified paths with staging redirection
+ */
+export function getStagingRedirectedPaths(paths) {
+  const stagingDir = join(paths.baseDir, '.staging');
+  
+  const redirected = { ...paths };
+  
+  // List of artifact path keys that should be redirected to staging
+  const artifactKeys = [
+    'summary', 'findings', 'ledger', 'learn', 'observe',
+    'summaryJson', 'findingsJson', 'learnJson', 'observeJson', 'ledgerJson'
+  ];
+  
+  for (const key of artifactKeys) {
+    if (redirected[key] && typeof redirected[key] === 'string') {
+      // Extract just the filename from the path (works on Windows and Unix)
+      // Split by both / and \ to handle any path separator
+      const parts = redirected[key].replace(/\\/g, '/').split('/');
+      const filename = parts[parts.length - 1];
+      
+      if (filename) {
+        // Place in staging directory
+        redirected[key] = join(stagingDir, filename);
+      }
+    }
+  }
+  
+  return redirected;
+}
+
+/**
+ * Complete Phase 6A - verify integrity and commit artifacts
+ * MANDATORY on success - generates manifest, verifies, commits staging to final
+ * 
+ * @param {string} runDir - Run directory (base, not staging)
+ * @returns {Promise<{ success: boolean, verification?: any, error?: Error }>}
+ */
+export async function completePhase6A(runDir) {
+  try {
+    const result = await phase6aComplete(runDir);
+    return result;
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+/**
+ * Rollback Phase 6A on error
+ * MANDATORY in catch block - cleans staging but KEEPS poison marker
+ * 
+ * @param {string} runDir - Run directory (base, not staging)
+ * @returns {Promise<{ success: boolean, error?: Error }>}
+ */
+export async function rollbackPhase6A(runDir) {
+  try {
+    // Pass generic error - the phase6a module will record it
+    const error = new Error('Scan execution failed or was interrupted');
+    const result = await phase6aRollback(runDir, error);
+    return result;
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+/**
+ * Enforce poison marker check before reading a run
+ * MANDATORY before inspect, before loading artifacts, etc
+ * 
+ * Prevents reading from incomplete/corrupted previous runs.
+ * 
+ * @param {string} runDir - Run directory
+ * @throws {Error} If poison marker exists
+ */
+export function enforcePoisonCheckBeforeRead(runDir) {
+  const poisonCheck = checkPoisonMarker(runDir);
+  
+  if (poisonCheck.hasPoisonMarker) {
+    throw new Error(
+      `Cannot read from this run: poison marker present (incomplete/corrupted run). ` +
+      `The previous scan did not complete successfully. ` +
+      `Artifacts may be incomplete or corrupted. ` +
+      `Run 'verax doctor' to diagnose.`
+    );
+  }
+  return { safe: true };
+}
+
+/**
+ * Verify artifacts before reading (check integrity manifest)
+ * RECOMMENDED before loading summary.json, findings.json, etc
+ * 
+ * @param {string} runDir - Run directory
+ * @returns {{ ok: boolean, error?: string }}
+ */
+export function verifyArtifactsBeforeRead(runDir) {
+  try {
+    // Check that integrity manifest exists (in staging directory)
+    const stagingDir = join(runDir, '.staging');
+    const manifestPath = join(stagingDir, 'integrity.manifest.json');
+    
+    if (!existsSync(manifestPath)) {
+      return {
+        ok: false,
+        error: 'Integrity manifest missing - run may be incomplete or from older version'
+      };
+    }
+    
+    // In future: verify checksums match manifest
+    
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+/**
+ * Check budget compliance during execution
+ * Placeholder for Phase 6C
+ * 
+ * @returns {{ ok: boolean, violations?: string[] }}
+ */
+export function checkBudgetCompliance() {
+  // Placeholder for Phase 6C
+  return { ok: true };
+}

package/src/cli/util/types.js

@@ -0,0 +1,153 @@
+/**
+ * PHASE 2: Canonical Type System for VERAX
+ * 
+ * Single source of truth for all valid types in the analysis pipeline:
+ * - EXPECTATION_TYPE: Types of expectations extracted from source code
+ * - FINDING_TYPE: Types of findings detected during analysis
+ * - SKIP_REASON: Structured reasons why expectations were skipped
+ * 
+ * Validation happens at CREATION TIME, not at enforcement time.
+ * No object may be created with an invalid type.
+ */
+
+/**
+ * Valid expectation types extracted from source code.
+ * These represent what the code is expected to do.
+ */
+export const EXPECTATION_TYPE = Object.freeze({
+  // Navigation: Expects a URL change or page navigation
+  NAVIGATION: 'navigation',
+  
+  // Network: Expects a network call to be made
+  NETWORK: 'network',
+  
+  // State: Expects a state change or promise fulfillment
+  STATE: 'state',
+});
+
+/**
+ * Valid finding types detected during analysis.
+ * These represent what the code is NOT doing that it should be.
+ */
+export const FINDING_TYPE = Object.freeze({
+  // Silent Failures: Expectation not met with no observable effect
+  SILENT_FAILURE: 'silent_failure',
+  NETWORK_SILENT_FAILURE: 'network_silent_failure',
+  VALIDATION_SILENT_FAILURE: 'validation_silent_failure',
+  FLOW_SILENT_FAILURE: 'flow_silent_failure',
+  DYNAMIC_ROUTE_SILENT_FAILURE: 'dynamic_route_silent_failure',
+  
+  // Observable Breaks: Expectation not met with visible effects
+  OBSERVED_BREAK: 'observed_break',
+  
+  // UI Feedback: Missing user feedback after action
+  MISSING_FEEDBACK_FAILURE: 'missing_feedback_failure',
+  CSS_LOADING_FEEDBACK_FAILURE: 'css_loading_feedback_failure',
+  
+  // Route Issues: Problems with dynamic route detection
+  DYNAMIC_ROUTE_MISMATCH: 'dynamic_route_mismatch',
+  
+  // Interactive: Issues with interactive elements
+  NAVIGATION_SILENT_FAILURE: 'navigation_silent_failure',
+  JOURNEY_STALL_SILENT_FAILURE: 'journey_stall_silent_failure',
+  
+  // Network: Issues with network calls
+  MISSING_NETWORK_ACTION: 'missing_network_action',
+  NETWORK_SUCCESS_NO_FEEDBACK: 'network_success_no_feedback',
+});
+
+/**
+ * Structured reasons why expectations were skipped (not analyzed).
+ * Distinguish between systemic failures and intentional filtering.
+ */
+export const SKIP_REASON = Object.freeze({
+  // Systemic Failures: Pipeline cannot continue (force INCOMPLETE state)
+  NO_EXPECTATIONS_EXTRACTED: 'NO_EXPECTATIONS_EXTRACTED',
+  TIMEOUT_OBSERVE: 'TIMEOUT_OBSERVE',
+  TIMEOUT_DETECT: 'TIMEOUT_DETECT',
+  TIMEOUT_TOTAL: 'TIMEOUT_TOTAL',
+  BUDGET_EXCEEDED: 'BUDGET_EXCEEDED',
+  MISSING_SOURCE_DIR: 'MISSING_SOURCE_DIR',
+  UNREACHABLE_URL: 'UNREACHABLE_URL',
+  
+  // Intentional Filtering: Skips that don't indicate truncation (COMPLETE is allowed)
+  DYNAMIC_ROUTE_UNSUPPORTED: 'DYNAMIC_ROUTE_UNSUPPORTED',
+  EXTERNAL_URL_SKIPPED: 'EXTERNAL_URL_SKIPPED',
+  PARSE_ERROR: 'PARSE_ERROR',
+  UNSUPPORTED_FILE: 'UNSUPPORTED_FILE',
+  OBSERVATION_FAILED: 'OBSERVATION_FAILED',
+  CONTRACT_VIOLATION: 'CONTRACT_VIOLATION',
+});
+
+/**
+ * Validate that a type string is a valid expectation type.
+ * @param {string} type - The type to validate
+ * @returns {boolean} True if valid
+ * @throws {Error} If invalid
+ */
+export function validateExpectationType(type) {
+  // @ts-expect-error - Runtime string comparison against enum values
+  if (!Object.values(EXPECTATION_TYPE).includes(type)) {
+    throw new Error(
+      `Invalid expectation type: "${type}". Must be one of: ${Object.values(EXPECTATION_TYPE).join(', ')}`
+    );
+  }
+  return true;
+}
+
+/**
+ * Validate that a type string is a valid finding type.
+ * @param {string} type - The type to validate
+ * @returns {boolean} True if valid
+ * @throws {Error} If invalid
+ */
+export function validateFindingType(type) {
+  // @ts-expect-error - Runtime string comparison against enum values
+  if (!Object.values(FINDING_TYPE).includes(type)) {
+    throw new Error(
+      `Invalid finding type: "${type}". Must be one of: ${Object.values(FINDING_TYPE).join(', ')}`
+    );
+  }
+  return true;
+}
+
+/**
+ * Validate that a reason is a valid skip reason.
+ * @param {string} reason - The reason to validate
+ * @returns {string} Normalized valid skip reason
+ * @throws {Error} If invalid and cannot be normalized
+ */
+export function validateSkipReason(reason) {
+  // CRASH GUARD: Normalize undefined/invalid reasons instead of throwing
+  if (reason === undefined || reason === null || reason === 'undefined') {
+    console.warn(`[VERAX] Invalid skip reason "${reason}" normalized to OBSERVATION_FAILED`);
+    return SKIP_REASON.OBSERVATION_FAILED;
+  }
+  
+  // @ts-expect-error - Runtime string comparison against enum values
+  if (!Object.values(SKIP_REASON).includes(reason)) {
+    console.warn(`[VERAX] Unknown skip reason "${reason}" normalized to OBSERVATION_FAILED`);
+    return SKIP_REASON.OBSERVATION_FAILED;
+  }
+  return reason;
+}
+
+/**
+ * Check if a skip reason is a systemic failure.
+ * Systemic failures force analysis state to INCOMPLETE.
+ * @param {string} reason - The skip reason
+ * @returns {boolean} True if this is a systemic failure
+ */
+export function isSystemicFailure(reason) {
+  const systemicFailures = [
+    SKIP_REASON.NO_EXPECTATIONS_EXTRACTED,
+    SKIP_REASON.TIMEOUT_OBSERVE,
+    SKIP_REASON.TIMEOUT_DETECT,
+    SKIP_REASON.TIMEOUT_TOTAL,
+    SKIP_REASON.BUDGET_EXCEEDED,
+    SKIP_REASON.MISSING_SOURCE_DIR,
+    SKIP_REASON.UNREACHABLE_URL,
+  ];
+  // @ts-expect-error - Runtime string comparison against enum values
+  return systemicFailures.includes(reason);
+}

package/src/cli/util/url-validation.js

@@ -0,0 +1,40 @@
+/**
+ * URL Validation Utilities
+ * Ensures strict URL format validation to prevent false greens
+ */
+
+export function validateUrl(urlString) {
+  if (!urlString || typeof urlString !== 'string') {
+    throw new Error('URL must be a non-empty string');
+  }
+  
+  try {
+    const url = new URL(urlString);
+    
+    // Require http or https
+    if (!['http:', 'https:'].includes(url.protocol)) {
+      throw new Error(`Invalid protocol: ${url.protocol} (must be http or https)`);
+    }
+    
+    // Require hostname
+    if (!url.hostname) {
+      throw new Error('URL must include a hostname');
+    }
+    
+    // Check for localhost without port (common misconfiguration)
+    if (url.hostname === 'localhost' && !url.port) {
+      // This is OK - localhost defaults to port 80/443
+    }
+    
+    return { valid: true, url };
+  } catch (error) {
+    throw new Error(`Invalid URL: ${error.message}`);
+  }
+}
+
+export function validateFlags(flags, allowed) {
+  const invalidFlags = flags.filter(flag => !allowed.includes(flag));
+  if (invalidFlags.length > 0) {
+    throw new Error(`Unknown flag(s): ${invalidFlags.join(', ')}`);
+  }
+}

package/src/cli/util/vue-navigation-detector.js

@@ -17,11 +17,12 @@ const traverse = _traverse.default || _traverse;
  * @param {string} scriptContent - Script block content
  * @param {string} filePath - File path
  * @param {string} relPath - Relative path
- * @param {Object} scriptBlock - Script block metadata
- * @param {Object} templateBindings - Template bindings (optional)
+ * @param {Object} _scriptBlock - Script block metadata
+ * @param {Object} _templateBindings - Template bindings (optional)
+ * @ts-expect-error - JSDoc params documented but unused
  * @returns {Array} Navigation promises
  */
-export function detectVueNavigationPromises(scriptContent, filePath, relPath, scriptBlock, templateBindings) {
+export function detectVueNavigationPromises(scriptContent, filePath, relPath, _scriptBlock, _templateBindings) {
   const promises = [];
   
   try {

package/src/cli/util/vue-sfc-extractor.js

@@ -9,7 +9,6 @@
  * PHASE 20: Extract Vue SFC blocks
  * 
  * @param {string} content - Full .vue file content
- * @param {string} filePath - Path to the .vue file (for context)
  * @returns {Object} { scriptBlocks: [{content, lang, startLine}], template: {content, startLine} }
  */
 export function extractVueSFC(content) {
@@ -19,7 +18,7 @@ export function extractVueSFC(content) {
   // Extract <script> blocks (including <script setup>)
   const scriptRegex = /<script(?:\s+setup)?(?:\s+lang=["']([^"']+)["'])?[^>]*>([\s\S]*?)<\/script>/gi;
   let scriptMatch;
-  let lineOffset = 1;
+  let _lineOffset = 1;
   
   while ((scriptMatch = scriptRegex.exec(content)) !== null) {
     const isSetup = scriptMatch[0].includes('setup');

package/src/cli/util/vue-state-detector.js

@@ -108,7 +108,7 @@ export function detectVueStatePromises(scriptContent, filePath, relPath, scriptB
           const varName = left.object.name;
           
           if (refDeclarations.has(varName) && templateVars.has(varName)) {
-            const decl = refDeclarations.get(varName);
+            const _decl = refDeclarations.get(varName);
             const loc = node.loc;
             const line = loc ? loc.start.line : 1;
             const column = loc ? loc.start.column : 0;

package/src/types/fs-augment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Type augmentation for Node.js fs module
+ * Provides more precise return types for readFileSync with encoding
+ */
+
+declare module 'fs' {
+  import { PathLike } from 'fs';
+  
+  /**
+   * Augment readFileSync to return string when encoding is specified
+   */
+  export function readFileSync(
+    path: PathLike | number,
+    options?: { encoding?: null; flag?: string } | null
+  ): Buffer;
+  
+  export function readFileSync(
+    path: PathLike | number,
+    options: { encoding: BufferEncoding; flag?: string } | BufferEncoding
+  ): string;
+}
+
+export {};

package/src/types/global.d.ts

@@ -24,5 +24,142 @@ import type { Page as PlaywrightPage } from 'playwright';
 // Re-export for use in JS files
 export type Page = PlaywrightPage;
 
+// Node.js built-in module declarations
+declare module 'fs' {
+  export interface Stats {
+    isDirectory(): boolean;
+    isFile(): boolean;
+    size: number;
+    mtime: Date;
+  }
+
+  export interface WriteFileOptions {
+    encoding?: BufferEncoding;
+    mode?: number;
+    flag?: string;
+  }
+
+  export interface ReadFileOptions {
+    encoding?: BufferEncoding | string;
+    flag?: string;
+  }
+
+  export interface RmOptions {
+    force?: boolean;
+    recursive?: boolean;
+    maxRetries?: number;
+  }
+
+  export interface MkdirOptions {
+    recursive?: boolean;
+    mode?: number;
+  }
+
+  export interface ReaddirOptions {
+    encoding?: BufferEncoding | string;
+    withFileTypes?: boolean;
+  }
+
+  export function readFileSync(path: string | Buffer, encoding?: string | ReadFileOptions): string | Buffer;
+  export function writeFileSync(path: string, data: string | Buffer, options?: WriteFileOptions | string): void;
+  export function existsSync(path: string | Buffer): boolean;
+  export function mkdirSync(path: string, options?: MkdirOptions): string | undefined;
+  export function rmSync(path: string, options?: RmOptions): void;
+  export function readdirSync(path: string, options?: ReaddirOptions | string): string[] | any[];
+  export function statSync(path: string): Stats;
+  export function renameSync(oldPath: string, newPath: string): void;
+  export function unlinkSync(path: string): void;
+  export function mkdtempSync(prefix: string): string;
+  export function appendFileSync(path: string, data: string | Buffer, options?: WriteFileOptions | string): void;
+  export function createWriteStream(path: string, options?: any): any;
+}
+
+declare module 'path' {
+  export function resolve(...paths: string[]): string;
+  export function join(...paths: string[]): string;
+  export function dirname(p: string): string;
+  export function basename(p: string, ext?: string): string;
+  export function extname(p: string): string;
+  export function relative(from: string, to: string): string;
+  export function normalize(p: string): string;
+  export const sep: string;
+  export const delimiter: string;
+  export const posix: {
+    resolve: typeof resolve;
+    join: typeof join;
+    dirname: typeof dirname;
+    basename: typeof basename;
+  };
+  export const win32: {
+    resolve: typeof resolve;
+    join: typeof join;
+    dirname: typeof dirname;
+    basename: typeof basename;
+  };
+}
+
+declare module 'crypto' {
+  export interface Hash {
+    update(data: string | Buffer, encoding?: string): Hash;
+    digest(encoding?: string): string | Buffer;
+  }
+
+  export function createHash(algorithm: string): Hash;
+  export function randomBytes(size: number): Buffer;
+  export function createHmac(algorithm: string, key: string | Buffer): {
+    update(data: string | Buffer, encoding?: string): any;
+    digest(encoding?: string): string;
+  };
+}
+
+declare module 'os' {
+  export function tmpdir(): string;
+  export function cwd(): string;
+}
+
+declare module 'url' {
+  export function fileURLToPath(url: string | URL): string;
+  export class URL {
+    constructor(input: string, base?: string | URL);
+    href: string;
+    protocol: string;
+    host: string;
+    pathname: string;
+  }
+}
+
+declare module 'http' {
+  export interface Server {
+    close(callback?: () => void): void;
+    listen(port?: number, host?: string, callback?: () => void): void;
+  }
+
+  export function createServer(requestListener?: (req: any, res: any) => void): Server;
+}
+
+declare global {
+  class Buffer {
+    static from(data: string, encoding?: string): Buffer;
+    static isBuffer(obj: any): obj is Buffer;
+    toString(encoding?: string): string;
+  }
+
+  namespace NodeJS {
+    interface ProcessEnv {
+      [key: string]: string | undefined;
+    }
+
+    interface Process {
+      env: ProcessEnv;
+      argv: string[];
+      cwd(): string;
+      exit(code?: number): never;
+      on(event: string, listener: (...args: any[]) => void): void;
+    }
+  }
+
+  const process: NodeJS.Process;
+}
+
 export {};
 

package/src/types/internal-types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Internal type definitions for VERAX
+ * Minimal types to satisfy TypeScript checking
+ * 
+ * @typedef {Object} ObserveContext
+ * @property {string} url
+ * @property {string} projectDir
+ * @property {string} runId
+ * @property {SilenceTracker} silenceTracker
+ * @property {*} decisionRecorder
+ * @property {*} scanBudget
+ * 
+ * @typedef {Object} RunState
+ * @property {number} totalInteractions
+ * @property {number} totalPages
+ * @property {number} startTime
+ * 
+ * @typedef {Object} SilenceTracker
+ * @property {function(*): void} record
+ * @property {function(): *} getSilenceReport
+ * 
+ * @typedef {Object} PageFrontier
+ * @property {function(string, *=): void} addPage
+ * @property {function(): *} getNextPage
+ * @property {function(): boolean} hasPages
+ * 
+ * @typedef {Object} Observation
+ * @property {string} type
+ * @property {*} data
+ * @property {number=} timestamp
+ */
+
+// Export as module
+export {};
+

package/src/verax/cli/finding-explainer.js

@@ -14,22 +14,11 @@
 export function formatFinding(finding, expectation = null) {
   const lines = [];
   
-  // PHASE 15: Finding type and unified confidence
-  const confidenceLevel = finding.confidenceLevel || finding.confidence?.level || 'UNPROVEN';
-  const confidenceScore = finding.confidence !== undefined 
-    ? (finding.confidence <= 1 ? Math.round(finding.confidence * 100) : finding.confidence)
-    : (finding.confidence?.score || 0);
-  const confidenceReasons = finding.confidenceReasons || [];
-  
+  // Finding type and confidence
+  const confidenceLevel = finding.confidence?.level || 'UNKNOWN';
+  const confidenceScore = finding.confidence?.score || 0;
   lines.push(`  [${confidenceLevel} (${confidenceScore}%)] ${finding.type || 'unknown'}`);
   
-  // PHASE 15: Show top confidence reasons
-  if (confidenceReasons.length > 0) {
-    const topReasons = confidenceReasons.slice(0, 3);
-    const reasonText = topReasons.join(', ');
-    lines.push(`  └─ Confidence: ${reasonText}`);
-  }
-  
   // Expectation (what was promised)
   if (expectation) {
     let expectationDesc = '';
@@ -95,48 +84,6 @@ export function formatFinding(finding, expectation = null) {
     lines.push(`  └─ Source: ${expectation.source.file}${sourceLine}`);
   }
   
-  // PHASE 16: Show evidence completeness
-  if (finding.evidencePackage) {
-    if (finding.evidencePackage.isComplete) {
-      lines.push(`  └─ Evidence: Complete`);
-    } else {
-      lines.push(`  └─ Evidence: Incomplete (missing: ${finding.evidencePackage.missingEvidence.join(', ')})`);
-    }
-  }
-  
-  // PHASE 16: Show downgrade reason if evidence was incomplete
-  if (finding.evidenceCompleteness?.downgraded) {
-    lines.push(`  └─ Downgraded: ${finding.evidenceCompleteness.downgradeReason}`);
-  }
-  
-  // PHASE 17/23: Show guardrails applied and reconciliation
-  if (finding.guardrails) {
-    const guardrails = finding.guardrails;
-    if (guardrails.appliedRules && guardrails.appliedRules.length > 0) {
-      const ruleCodes = guardrails.appliedRules.map(r => r.code || r.ruleId).filter(Boolean);
-      if (ruleCodes.length > 0) {
-        lines.push(`  └─ Final status due to guardrails: ${ruleCodes.join(', ')}`);
-      }
-    }
-    if (guardrails.contradictions && guardrails.contradictions.length > 0) {
-      lines.push(`  └─ Contradiction: ${guardrails.contradictions[0].message}`);
-    }
-    
-    // PHASE 23: Show confidence reconciliation if present
-    if (guardrails.reconciliation) {
-      const recon = guardrails.reconciliation;
-      if (recon.confidenceBefore !== recon.confidenceAfter) {
-        const beforePercent = Math.round(recon.confidenceBefore * 100);
-        const afterPercent = Math.round(recon.confidenceAfter * 100);
-        lines.push(`  └─ Confidence: ${beforePercent}% → ${afterPercent}% (${recon.confidenceLevelBefore} → ${recon.confidenceLevelAfter})`);
-      }
-      if (recon.reconciliationReasons && recon.reconciliationReasons.length > 0) {
-        const topReasons = recon.reconciliationReasons.slice(0, 2);
-        lines.push(`  └─ Reconciliation: ${topReasons.join(', ')}`);
-      }
-    }
-  }
-  
   return lines.join('\n');
 }