feat: Add async result streaming with progress callbacks

ARCH-003: Async Result Streaming

Implemented real-time progress reporting system for long-running validations,
providing better UX with live updates as validators complete.

Features:
- Progress callbacks via LintConfig.execution.onProgress
- ProgressEvent type system (validator-start, validator-complete, validator-error)
- ProgressReporter class for structured progress tracking
- Live statistics tracking (running, completed, passed, failed, errors)
- Verbose and silent modes for flexible output control
- Duration tracking and formatting (ms/s)
- Final summary with validation results

Implementation Details:
- types/index.ts: Added ProgressEvent, ProgressCallback, onProgress to LintConfig
- linter.ts: Enhanced runValidatorsSequential and runValidatorsParallel to emit progress events
- progress-reporter.ts: Full ProgressReporter implementation with stats tracking
- tests/progress-reporter.test.ts: 20 comprehensive test cases covering all scenarios

Benefits:
- Better visibility into validation progress for long-running sessions
- Statistics tracking even in silent mode (testable, scriptable)
- Non-blocking - events are emitted asynchronously
- Backward compatible - onProgress is optional

Tests: 324/324 passing (100%)
Build: ✅ Passing (0 TypeScript errors)

Author: d3xter666

plugins/ui5/skill-lint/src/core/linter.ts

@@ -84,24 +84,44 @@ export class SkillLinter {
   }
 
   /**
-   * Run validators sequentially with error boundaries
+   * Run validators sequentially with error boundaries and progress reporting
    */
   private async runValidatorsSequential(
     skill: Skill,
     config: LintConfig,
   ): Promise<ValidationResult[]> {
     const results: ValidationResult[] = [];
+    const onProgress = config.execution.onProgress;
 
     for (const validator of this.validators) {
+      // Emit start event
+      if (onProgress) {
+        onProgress({
+          type: 'validator-start',
+          validator: validator.name,
+          timestamp: Date.now(),
+        });
+      }
+
       try {
         const result = await validator.validate(skill, config);
         results.push(result);
+
+        // Emit complete event with result
+        if (onProgress) {
+          onProgress({
+            type: 'validator-complete',
+            validator: validator.name,
+            timestamp: Date.now(),
+            result,
+          });
+        }
       } catch (error) {
         // Don't let one validator crash bring down the entire tool
         const errorMessage = error instanceof Error ? error.message : String(error);
         console.error(`[SkillLinter] Validator "${validator.name}" crashed:`, errorMessage);
 
-        results.push({
+        const errorResult: ValidationResult = {
           validator: validator.name,
           passed: false,
           duration: 0,
@@ -111,29 +131,65 @@ export class SkillLinter {
             message: `Validator "${validator.name}" crashed: ${errorMessage}`,
             suggestion: 'This is likely a bug in the validator. Please report this issue.',
           }],
-        });
+        };
+        
+        results.push(errorResult);
+
+        // Emit error event
+        if (onProgress) {
+          onProgress({
+            type: 'validator-error',
+            validator: validator.name,
+            timestamp: Date.now(),
+            error: errorMessage,
+            result: errorResult,
+          });
+        }
       }
     }
 
     return results;
   }
 
   /**
-   * Run validators in parallel with error boundaries and concurrency control
+   * Run validators in parallel with error boundaries, concurrency control, and progress reporting
    */
   private async runValidatorsParallel(
     skill: Skill,
     config: LintConfig,
   ): Promise<ValidationResult[]> {
+    const onProgress = config.execution.onProgress;
+
     const tasks = this.validators.map(validator => async (): Promise<ValidationResult> => {
+      // Emit start event
+      if (onProgress) {
+        onProgress({
+          type: 'validator-start',
+          validator: validator.name,
+          timestamp: Date.now(),
+        });
+      }
+
       try {
-        return await validator.validate(skill, config);
+        const result = await validator.validate(skill, config);
+
+        // Emit complete event with result
+        if (onProgress) {
+          onProgress({
+            type: 'validator-complete',
+            validator: validator.name,
+            timestamp: Date.now(),
+            result,
+          });
+        }
+
+        return result;
       } catch (error) {
         // Don't let one validator crash bring down the entire tool
         const errorMessage = error instanceof Error ? error.message : String(error);
         console.error(`[SkillLinter] Validator "${validator.name}" crashed:`, errorMessage);
 
-        return {
+        const errorResult: ValidationResult = {
           validator: validator.name,
           passed: false,
           duration: 0,
@@ -144,6 +200,19 @@ export class SkillLinter {
             suggestion: 'This is likely a bug in the validator. Please report this issue.',
           }],
         };
+
+        // Emit error event
+        if (onProgress) {
+          onProgress({
+            type: 'validator-error',
+            validator: validator.name,
+            timestamp: Date.now(),
+            error: errorMessage,
+            result: errorResult,
+          });
+        }
+
+        return errorResult;
       }
     });
 

plugins/ui5/skill-lint/src/types/index.ts

@@ -132,6 +132,16 @@ export interface HealthCheckResult {
   readonly timestamp: number;
 }
 
+export interface ProgressEvent {
+  readonly type: 'validator-start' | 'validator-complete' | 'validator-error';
+  readonly validator: string;
+  readonly timestamp: number;
+  readonly result?: ValidationResult;
+  readonly error?: string;
+}
+
+export type ProgressCallback = (event: ProgressEvent) => void;
+
 // ── Config ──
 
 export interface LintConfig {
@@ -160,6 +170,7 @@ export interface LintConfig {
     readonly maxRetries: number;
     readonly parallel: boolean;
     readonly maxConcurrency?: number;
+    readonly onProgress?: ProgressCallback;
   };
   readonly formatters: {
     readonly default: string;