fix(hot-runner): validate persisted registry state and add dispatcher safeguards

Validate runner entries when loading from hot-runners.json. Discard
corrupted entries with warnings. Add validateAndRepair() method for
runtime recovery. Validate data before persisting to prevent writing
corrupt state. Handle corrupt persistence files (invalid JSON)
gracefully. Rewrite executeWithTimeout using Promise.race to clean up
transport connections on timeout. Fix pre-existing ESLint violations
in dispatcher and test files.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

dist/index.js

@@ -9796,23 +9796,28 @@ class HotRunnerDispatcher {
     }
     /**
      * Execute a job on a transport with a timeout guard.
+     * On timeout, disconnects the transport to release the connection
+     * and prevent the orphaned sendJob promise from holding resources.
      */
     async executeWithTimeout(transport, request) {
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                reject(new Error(`[HotRunner] Job ${request.jobId} timed out after ${request.timeout}ms`));
+        const TIMEOUT_SENTINEL = Symbol('timeout');
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(() => {
+                resolve(TIMEOUT_SENTINEL);
             }, request.timeout);
-            transport
-                .sendJob(request)
-                .then((result) => {
-                clearTimeout(timer);
-                resolve(result);
-            })
-                .catch((error) => {
-                clearTimeout(timer);
-                reject(error);
-            });
         });
+        const result = await Promise.race([transport.sendJob(request), timeoutPromise]);
+        if (result === TIMEOUT_SENTINEL) {
+            // Disconnect the transport to clean up the orphaned sendJob call
+            try {
+                await transport.disconnect();
+            }
+            catch (disconnectError) {
+                orchestrator_logger_1.default.logWarning(`[HotRunner] Error disconnecting transport after timeout for job ${request.jobId}: ${disconnectError.message}`);
+            }
+            throw new Error(`[HotRunner] Job ${request.jobId} timed out after ${request.timeout}ms`);
+        }
+        return result;
     }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
@@ -10006,6 +10011,45 @@ const nanoid_1 = __nccwpck_require__(17592);
 const orchestrator_logger_1 = __importDefault(__nccwpck_require__(32549));
 const generateId = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz0123456789', 12);
 const PERSISTENCE_FILENAME = 'hot-runners.json';
+const VALID_RUNNER_STATES = new Set(['idle', 'busy', 'starting', 'stopping', 'unhealthy']);
+/**
+ * Validate that a restored runner entry has all required fields with correct types.
+ * Returns true if the entry is a valid HotRunnerStatus, false otherwise.
+ */
+function isValidRunnerStatus(entry) {
+    if (typeof entry !== 'object' || entry === null) {
+        return false;
+    }
+    const record = entry;
+    return (typeof record.id === 'string' &&
+        record.id.length > 0 &&
+        typeof record.state === 'string' &&
+        VALID_RUNNER_STATES.has(record.state) &&
+        typeof record.unityVersion === 'string' &&
+        typeof record.platform === 'string' &&
+        typeof record.uptime === 'number' &&
+        typeof record.jobsCompleted === 'number' &&
+        typeof record.lastHealthCheck === 'string' &&
+        typeof record.memoryUsageMB === 'number');
+}
+/**
+ * Validate that a restored config entry has all required fields with correct types.
+ * Returns true if the entry is a valid HotRunnerConfig, false otherwise.
+ */
+function isValidRunnerConfig(entry) {
+    if (typeof entry !== 'object' || entry === null) {
+        return false;
+    }
+    const record = entry;
+    return (typeof record.enabled === 'boolean' &&
+        typeof record.transport === 'string' &&
+        ['websocket', 'grpc', 'named-pipe'].includes(record.transport) &&
+        typeof record.host === 'string' &&
+        typeof record.port === 'number' &&
+        typeof record.healthCheckInterval === 'number' &&
+        typeof record.maxIdleTime === 'number' &&
+        typeof record.maxJobsBeforeRecycle === 'number');
+}
 class HotRunnerRegistry {
     constructor(persistenceDirectory) {
         this.runners = new Map();
@@ -10099,14 +10143,53 @@ class HotRunnerRegistry {
     get size() {
         return this.runners.size;
     }
+    /**
+     * Validate all runners in the registry and reset invalid ones to 'unhealthy'.
+     * Returns the number of runners that were repaired.
+     */
+    validateAndRepair() {
+        let repaired = 0;
+        for (const [id, status] of this.runners) {
+            // Cast to unknown to bypass the type guard narrowing to 'never',
+            // since the Map is typed as HotRunnerStatus but entries may have
+            // been corrupted via direct deserialization or unsafe casts.
+            const entry = status;
+            if (!isValidRunnerStatus(entry)) {
+                orchestrator_logger_1.default.logWarning(`[HotRunner] Runner ${id} has invalid state, marking as unhealthy`);
+                this.runners.set(id, {
+                    id,
+                    state: 'unhealthy',
+                    unityVersion: typeof entry.unityVersion === 'string' ? entry.unityVersion : 'unknown',
+                    platform: typeof entry.platform === 'string' ? entry.platform : 'unknown',
+                    uptime: typeof entry.uptime === 'number' ? entry.uptime : 0,
+                    jobsCompleted: typeof entry.jobsCompleted === 'number' ? entry.jobsCompleted : 0,
+                    lastHealthCheck: typeof entry.lastHealthCheck === 'string' ? entry.lastHealthCheck : new Date().toISOString(),
+                    memoryUsageMB: typeof entry.memoryUsageMB === 'number' ? entry.memoryUsageMB : 0,
+                });
+                repaired++;
+            }
+        }
+        if (repaired > 0) {
+            this.persist();
+        }
+        return repaired;
+    }
     /**
      * Persist current registry state to disk for crash recovery.
+     * Validates data before writing to prevent persisting corrupt state.
      */
     persist() {
         if (!this.persistencePath) {
             return;
         }
         try {
+            // Validate data before persisting
+            for (const [id, status] of this.runners) {
+                if (!isValidRunnerStatus(status)) {
+                    orchestrator_logger_1.default.logWarning(`[HotRunner] Skipping persistence -- runner ${id} has invalid state`);
+                    return;
+                }
+            }
             const data = {
                 runners: Object.fromEntries(this.runners),
                 configs: Object.fromEntries(this.configs),
@@ -10123,31 +10206,57 @@ class HotRunnerRegistry {
     }
     /**
      * Load registry state from disk. Returns the number of runners restored.
+     * Validates each restored entry and discards corrupt entries with warnings.
+     * If the persistence file itself is corrupt (invalid JSON), starts with
+     * an empty registry.
      */
     loadFromDisk() {
         if (!this.persistencePath || !node_fs_1.default.existsSync(this.persistencePath)) {
             return 0;
         }
+        let data;
         try {
             const raw = node_fs_1.default.readFileSync(this.persistencePath, 'utf8');
-            const data = JSON.parse(raw);
-            if (data.runners) {
-                for (const [id, status] of Object.entries(data.runners)) {
-                    this.runners.set(id, status);
-                }
-            }
-            if (data.configs) {
-                for (const [id, config] of Object.entries(data.configs)) {
-                    this.configs.set(id, config);
-                }
-            }
-            orchestrator_logger_1.default.log(`[HotRunner] Restored ${this.runners.size} runner(s) from disk`);
-            return this.runners.size;
+            data = JSON.parse(raw);
         }
         catch (error) {
-            orchestrator_logger_1.default.logWarning(`[HotRunner] Failed to load registry from disk: ${error.message}`);
+            orchestrator_logger_1.default.logWarning(`[HotRunner] Persistence file is corrupt, starting with empty registry: ${error.message}`);
             return 0;
         }
+        if (typeof data !== 'object' || data === null) {
+            orchestrator_logger_1.default.logWarning('[HotRunner] Persistence file has invalid structure, starting with empty registry');
+            return 0;
+        }
+        let discarded = 0;
+        if (data.runners && typeof data.runners === 'object') {
+            for (const [id, status] of Object.entries(data.runners)) {
+                if (isValidRunnerStatus(status)) {
+                    this.runners.set(id, status);
+                }
+                else {
+                    orchestrator_logger_1.default.logWarning(`[HotRunner] Discarding invalid runner entry '${id}' from persistence file`);
+                    discarded++;
+                }
+            }
+        }
+        if (data.configs && typeof data.configs === 'object') {
+            for (const [id, config] of Object.entries(data.configs)) {
+                // Only restore configs for runners that were successfully restored
+                if (this.runners.has(id)) {
+                    if (isValidRunnerConfig(config)) {
+                        this.configs.set(id, config);
+                    }
+                    else {
+                        orchestrator_logger_1.default.logWarning(`[HotRunner] Discarding invalid config entry '${id}' from persistence file`);
+                    }
+                }
+            }
+        }
+        if (discarded > 0) {
+            orchestrator_logger_1.default.logWarning(`[HotRunner] Discarded ${discarded} invalid runner(s) from persistence file`);
+        }
+        orchestrator_logger_1.default.log(`[HotRunner] Restored ${this.runners.size} runner(s) from disk`);
+        return this.runners.size;
     }
 }
 exports.HotRunnerRegistry = HotRunnerRegistry;

src/model/orchestrator/services/hot-runner/hot-runner-dispatcher.ts

@@ -4,7 +4,8 @@ import { HotRunnerJobRequest, HotRunnerJobResult, HotRunnerStatus, HotRunnerTran
 
 const POLL_INTERVAL_MS = 1000;
 
-export type OutputCallback = (chunk: string) => void;
+// eslint-disable-next-line no-unused-vars
+export type OutputCallback = (output: string) => void;
 
 export class HotRunnerDispatcher {
   private transports: Map<string, HotRunnerTransport>;
@@ -119,27 +120,37 @@ export class HotRunnerDispatcher {
 
   /**
    * Execute a job on a transport with a timeout guard.
+   * On timeout, disconnects the transport to release the connection
+   * and prevent the orphaned sendJob promise from holding resources.
    */
   private async executeWithTimeout(
     transport: HotRunnerTransport,
     request: HotRunnerJobRequest,
   ): Promise<HotRunnerJobResult> {
-    return new Promise<HotRunnerJobResult>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`[HotRunner] Job ${request.jobId} timed out after ${request.timeout}ms`));
-      }, request.timeout);
+    const TIMEOUT_SENTINEL = Symbol('timeout');
 
-      transport
-        .sendJob(request)
-        .then((result) => {
-          clearTimeout(timer);
-          resolve(result);
-        })
-        .catch((error) => {
-          clearTimeout(timer);
-          reject(error);
-        });
+    const timeoutPromise = new Promise<typeof TIMEOUT_SENTINEL>((resolve) => {
+      setTimeout(() => {
+        resolve(TIMEOUT_SENTINEL);
+      }, request.timeout);
     });
+
+    const result = await Promise.race([transport.sendJob(request), timeoutPromise]);
+
+    if (result === TIMEOUT_SENTINEL) {
+      // Disconnect the transport to clean up the orphaned sendJob call
+      try {
+        await transport.disconnect();
+      } catch (disconnectError: any) {
+        OrchestratorLogger.logWarning(
+          `[HotRunner] Error disconnecting transport after timeout for job ${request.jobId}: ${disconnectError.message}`,
+        );
+      }
+
+      throw new Error(`[HotRunner] Job ${request.jobId} timed out after ${request.timeout}ms`);
+    }
+
+    return result;
   }
 
   private sleep(ms: number): Promise<void> {

src/model/orchestrator/services/hot-runner/hot-runner-registry.ts

@@ -8,12 +8,62 @@ const generateId = customAlphabet('abcdefghijklmnopqrstuvwxyz0123456789', 12);
 
 const PERSISTENCE_FILENAME = 'hot-runners.json';
 
+const VALID_RUNNER_STATES: ReadonlySet<string> = new Set(['idle', 'busy', 'starting', 'stopping', 'unhealthy']);
+
 export interface HotRunnerFilter {
   platform?: string;
   state?: string;
   unityVersion?: string;
 }
 
+/**
+ * Validate that a restored runner entry has all required fields with correct types.
+ * Returns true if the entry is a valid HotRunnerStatus, false otherwise.
+ */
+function isValidRunnerStatus(entry: unknown): entry is HotRunnerStatus {
+  if (typeof entry !== 'object' || entry === null) {
+    return false;
+  }
+
+  const record = entry as Record<string, unknown>;
+
+  return (
+    typeof record.id === 'string' &&
+    record.id.length > 0 &&
+    typeof record.state === 'string' &&
+    VALID_RUNNER_STATES.has(record.state) &&
+    typeof record.unityVersion === 'string' &&
+    typeof record.platform === 'string' &&
+    typeof record.uptime === 'number' &&
+    typeof record.jobsCompleted === 'number' &&
+    typeof record.lastHealthCheck === 'string' &&
+    typeof record.memoryUsageMB === 'number'
+  );
+}
+
+/**
+ * Validate that a restored config entry has all required fields with correct types.
+ * Returns true if the entry is a valid HotRunnerConfig, false otherwise.
+ */
+function isValidRunnerConfig(entry: unknown): entry is HotRunnerConfig {
+  if (typeof entry !== 'object' || entry === null) {
+    return false;
+  }
+
+  const record = entry as Record<string, unknown>;
+
+  return (
+    typeof record.enabled === 'boolean' &&
+    typeof record.transport === 'string' &&
+    ['websocket', 'grpc', 'named-pipe'].includes(record.transport) &&
+    typeof record.host === 'string' &&
+    typeof record.port === 'number' &&
+    typeof record.healthCheckInterval === 'number' &&
+    typeof record.maxIdleTime === 'number' &&
+    typeof record.maxJobsBeforeRecycle === 'number'
+  );
+}
+
 export class HotRunnerRegistry {
   private runners: Map<string, HotRunnerStatus> = new Map();
   private configs: Map<string, HotRunnerConfig> = new Map();
@@ -128,8 +178,45 @@ export class HotRunnerRegistry {
     return this.runners.size;
   }
 
+  /**
+   * Validate all runners in the registry and reset invalid ones to 'unhealthy'.
+   * Returns the number of runners that were repaired.
+   */
+  validateAndRepair(): number {
+    let repaired = 0;
+
+    for (const [id, status] of this.runners) {
+      // Cast to unknown to bypass the type guard narrowing to 'never',
+      // since the Map is typed as HotRunnerStatus but entries may have
+      // been corrupted via direct deserialization or unsafe casts.
+      const entry = status as unknown as Record<string, unknown>;
+
+      if (!isValidRunnerStatus(entry)) {
+        OrchestratorLogger.logWarning(`[HotRunner] Runner ${id} has invalid state, marking as unhealthy`);
+        this.runners.set(id, {
+          id,
+          state: 'unhealthy',
+          unityVersion: typeof entry.unityVersion === 'string' ? entry.unityVersion : 'unknown',
+          platform: typeof entry.platform === 'string' ? entry.platform : 'unknown',
+          uptime: typeof entry.uptime === 'number' ? entry.uptime : 0,
+          jobsCompleted: typeof entry.jobsCompleted === 'number' ? entry.jobsCompleted : 0,
+          lastHealthCheck: typeof entry.lastHealthCheck === 'string' ? entry.lastHealthCheck : new Date().toISOString(),
+          memoryUsageMB: typeof entry.memoryUsageMB === 'number' ? entry.memoryUsageMB : 0,
+        });
+        repaired++;
+      }
+    }
+
+    if (repaired > 0) {
+      this.persist();
+    }
+
+    return repaired;
+  }
+
   /**
    * Persist current registry state to disk for crash recovery.
+   * Validates data before writing to prevent persisting corrupt state.
    */
   private persist(): void {
     if (!this.persistencePath) {
@@ -137,6 +224,15 @@ export class HotRunnerRegistry {
     }
 
     try {
+      // Validate data before persisting
+      for (const [id, status] of this.runners) {
+        if (!isValidRunnerStatus(status)) {
+          OrchestratorLogger.logWarning(`[HotRunner] Skipping persistence -- runner ${id} has invalid state`);
+
+          return;
+        }
+      }
+
       const data = {
         runners: Object.fromEntries(this.runners),
         configs: Object.fromEntries(this.configs),
@@ -145,6 +241,7 @@ export class HotRunnerRegistry {
       if (!fs.existsSync(directory)) {
         fs.mkdirSync(directory, { recursive: true });
       }
+
       fs.writeFileSync(this.persistencePath, JSON.stringify(data, undefined, 2));
     } catch (error: any) {
       OrchestratorLogger.logWarning(`[HotRunner] Failed to persist registry: ${error.message}`);
@@ -153,35 +250,66 @@ export class HotRunnerRegistry {
 
   /**
    * Load registry state from disk. Returns the number of runners restored.
+   * Validates each restored entry and discards corrupt entries with warnings.
+   * If the persistence file itself is corrupt (invalid JSON), starts with
+   * an empty registry.
    */
   loadFromDisk(): number {
     if (!this.persistencePath || !fs.existsSync(this.persistencePath)) {
       return 0;
     }
 
+    let data: any;
+
     try {
       const raw = fs.readFileSync(this.persistencePath, 'utf8');
-      const data = JSON.parse(raw);
-
-      if (data.runners) {
-        for (const [id, status] of Object.entries(data.runners)) {
-          this.runners.set(id, status as HotRunnerStatus);
-        }
-      }
-
-      if (data.configs) {
-        for (const [id, config] of Object.entries(data.configs)) {
-          this.configs.set(id, config as HotRunnerConfig);
-        }
-      }
-
-      OrchestratorLogger.log(`[HotRunner] Restored ${this.runners.size} runner(s) from disk`);
-
-      return this.runners.size;
+      data = JSON.parse(raw);
     } catch (error: any) {
-      OrchestratorLogger.logWarning(`[HotRunner] Failed to load registry from disk: ${error.message}`);
+      OrchestratorLogger.logWarning(
+        `[HotRunner] Persistence file is corrupt, starting with empty registry: ${error.message}`,
+      );
 
       return 0;
     }
+
+    if (typeof data !== 'object' || data === null) {
+      OrchestratorLogger.logWarning('[HotRunner] Persistence file has invalid structure, starting with empty registry');
+
+      return 0;
+    }
+
+    let discarded = 0;
+
+    if (data.runners && typeof data.runners === 'object') {
+      for (const [id, status] of Object.entries(data.runners)) {
+        if (isValidRunnerStatus(status)) {
+          this.runners.set(id, status);
+        } else {
+          OrchestratorLogger.logWarning(`[HotRunner] Discarding invalid runner entry '${id}' from persistence file`);
+          discarded++;
+        }
+      }
+    }
+
+    if (data.configs && typeof data.configs === 'object') {
+      for (const [id, config] of Object.entries(data.configs)) {
+        // Only restore configs for runners that were successfully restored
+        if (this.runners.has(id)) {
+          if (isValidRunnerConfig(config)) {
+            this.configs.set(id, config);
+          } else {
+            OrchestratorLogger.logWarning(`[HotRunner] Discarding invalid config entry '${id}' from persistence file`);
+          }
+        }
+      }
+    }
+
+    if (discarded > 0) {
+      OrchestratorLogger.logWarning(`[HotRunner] Discarded ${discarded} invalid runner(s) from persistence file`);
+    }
+
+    OrchestratorLogger.log(`[HotRunner] Restored ${this.runners.size} runner(s) from disk`);
+
+    return this.runners.size;
   }
 }

src/model/orchestrator/services/hot-runner/hot-runner.test.ts

@@ -34,7 +34,9 @@ function createMockConfig(overrides?: Partial<HotRunnerConfig>): HotRunnerConfig
 
 function createMockTransport(overrides?: Partial<HotRunnerTransport>): HotRunnerTransport {
   return {
+    // eslint-disable-next-line unicorn/no-useless-undefined
     connect: jest.fn().mockResolvedValue(undefined),
+    // eslint-disable-next-line unicorn/no-useless-undefined
     disconnect: jest.fn().mockResolvedValue(undefined),
     sendJob: jest.fn().mockResolvedValue({
       jobId: 'test-job',
@@ -140,10 +142,11 @@ describe('HotRunnerRegistry', () => {
 
   it('should filter runners by state', () => {
     const id1 = registry.registerRunner(createMockConfig());
-    const id2 = registry.registerRunner(createMockConfig());
+    registry.registerRunner(createMockConfig());
 
     registry.updateRunner(id1, { state: 'idle' });
-    // id2 remains in 'starting' state
+
+    // second runner remains in 'starting' state
 
     const idle = registry.listRunners({ state: 'idle' });
     expect(idle).toHaveLength(1);
@@ -200,6 +203,7 @@ describe('HotRunnerRegistry', () => {
     const runner = registry.getRunner(id);
     expect(runner!.state).toBe('idle');
     expect(runner!.memoryUsageMB).toBe(2048);
+
     // ID should not be overridden by the update
     expect(runner!.id).toBe(id);
   });
@@ -246,6 +250,131 @@ describe('HotRunnerRegistry', () => {
     expect(count).toBe(1);
     expect(persistenceRegistry.getRunner('hr-restored')).toBeDefined();
   });
+
+  it('should discard invalid runner entries when loading from disk', () => {
+    const persistenceRegistry = new HotRunnerRegistry('/tmp/test');
+    const storedData = {
+      runners: {
+        'hr-valid': {
+          id: 'hr-valid',
+          state: 'idle',
+          unityVersion: '2022.3.0f1',
+          platform: 'StandaloneWindows64',
+          uptime: 100,
+          jobsCompleted: 3,
+          lastHealthCheck: new Date().toISOString(),
+          memoryUsageMB: 512,
+        },
+        'hr-invalid': {
+          // Missing required fields like state, unityVersion
+          id: 'hr-invalid',
+        },
+        'hr-bad-state': {
+          id: 'hr-bad-state',
+          state: 'nonexistent-state',
+          unityVersion: '2022.3.0f1',
+          platform: 'StandaloneWindows64',
+          uptime: 0,
+          jobsCompleted: 0,
+          lastHealthCheck: new Date().toISOString(),
+          memoryUsageMB: 0,
+        },
+      },
+      configs: {
+        'hr-valid': createMockConfig(),
+        'hr-invalid': createMockConfig(),
+        'hr-bad-state': createMockConfig(),
+      },
+    };
+
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.readFileSync.mockReturnValue(JSON.stringify(storedData));
+
+    const count = persistenceRegistry.loadFromDisk();
+    expect(count).toBe(1);
+    expect(persistenceRegistry.getRunner('hr-valid')).toBeDefined();
+    expect(persistenceRegistry.getRunner('hr-invalid')).toBeUndefined();
+    expect(persistenceRegistry.getRunner('hr-bad-state')).toBeUndefined();
+  });
+
+  it('should handle corrupt JSON persistence file gracefully', () => {
+    const persistenceRegistry = new HotRunnerRegistry('/tmp/test');
+
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.readFileSync.mockReturnValue('{ invalid json !!!');
+
+    const count = persistenceRegistry.loadFromDisk();
+    expect(count).toBe(0);
+    expect(persistenceRegistry.size).toBe(0);
+  });
+
+  it('should handle persistence file with invalid top-level structure', () => {
+    const persistenceRegistry = new HotRunnerRegistry('/tmp/test');
+
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.readFileSync.mockReturnValue('"just a string"');
+
+    const count = persistenceRegistry.loadFromDisk();
+    expect(count).toBe(0);
+  });
+
+  it('should handle persistence file with null runners', () => {
+    const persistenceRegistry = new HotRunnerRegistry('/tmp/test');
+
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.readFileSync.mockReturnValue('{"runners": null, "configs": null}');
+
+    const count = persistenceRegistry.loadFromDisk();
+    expect(count).toBe(0);
+  });
+
+  it('should validate and repair invalid runners', () => {
+    const persistenceRegistry = new HotRunnerRegistry('/tmp/test');
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.writeFileSync.mockImplementation(() => {});
+    mockFs.mkdirSync.mockImplementation(() => '' as any);
+
+    // Register a valid runner first
+    const id = persistenceRegistry.registerRunner(createMockConfig());
+    persistenceRegistry.updateRunner(id, { state: 'idle' });
+
+    // Manually corrupt the runner's state by setting an invalid state
+    // (we access via the public API -- updateRunner with a cast)
+    persistenceRegistry.updateRunner(id, { state: 'invalid-state' as any });
+
+    const repaired = persistenceRegistry.validateAndRepair();
+    expect(repaired).toBe(1);
+
+    const runner = persistenceRegistry.getRunner(id);
+    expect(runner!.state).toBe('unhealthy');
+  });
+
+  it('should not discard configs for valid runners when loading from disk', () => {
+    const persistenceRegistry = new HotRunnerRegistry('/tmp/test');
+    const storedData = {
+      runners: {
+        'hr-valid': {
+          id: 'hr-valid',
+          state: 'idle',
+          unityVersion: '2022.3.0f1',
+          platform: 'StandaloneWindows64',
+          uptime: 100,
+          jobsCompleted: 3,
+          lastHealthCheck: new Date().toISOString(),
+          memoryUsageMB: 512,
+        },
+      },
+      configs: {
+        'hr-valid': createMockConfig(),
+      },
+    };
+
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.readFileSync.mockReturnValue(JSON.stringify(storedData));
+
+    persistenceRegistry.loadFromDisk();
+    expect(persistenceRegistry.getConfig('hr-valid')).toBeDefined();
+  });
 });
 
 // --- Health Monitor Tests ---
@@ -335,6 +464,7 @@ describe('HotRunnerHealthMonitor', () => {
 
   it('should recycle idle runner when max idle time exceeded', async () => {
     const id = registry.registerRunner(createMockConfig({ maxIdleTime: 60 }));
+
     // Set lastHealthCheck to 120 seconds ago
     const oldDate = new Date(Date.now() - 120 * 1000).toISOString();
     registry.updateRunner(id, { state: 'idle', lastHealthCheck: oldDate });
@@ -367,6 +497,7 @@ describe('HotRunnerHealthMonitor', () => {
 
   it('should return false when no transport exists for runner', async () => {
     const id = registry.registerRunner(createMockConfig());
+
     // Do not set any transport for this runner
     monitor.startMonitoring(registry, 30, transports);
 
@@ -408,7 +539,7 @@ describe('HotRunnerDispatcher', () => {
     const id = registry.registerRunner(createMockConfig());
     registry.updateRunner(id, { state: 'idle' });
 
-    let statesDuringJob: string[] = [];
+    const statesDuringJob: string[] = [];
     const transport = createMockTransport({
       sendJob: jest.fn().mockImplementation(async () => {
         const runner = registry.getRunner(id);
@@ -428,6 +559,7 @@ describe('HotRunnerDispatcher', () => {
     await dispatcher.dispatchJob(createMockJobRequest(), registry, '2022.3.0f1');
 
     expect(statesDuringJob).toContain('busy');
+
     // After completion, should be idle again
     const runner = registry.getRunner(id);
     expect(runner!.state).toBe('idle');
@@ -456,6 +588,7 @@ describe('HotRunnerDispatcher', () => {
   it('should throw when runner has no transport', async () => {
     const id = registry.registerRunner(createMockConfig());
     registry.updateRunner(id, { state: 'idle' });
+
     // No transport set for this runner
 
     const request = createMockJobRequest();
@@ -497,6 +630,25 @@ describe('HotRunnerDispatcher', () => {
     await expect(dispatcher.dispatchJob(request, registry, '2022.3.0f1')).rejects.toThrow(/timed out/);
   });
 
+  it('should disconnect transport on job timeout', async () => {
+    const id = registry.registerRunner(createMockConfig());
+    registry.updateRunner(id, { state: 'idle' });
+
+    const transport = createMockTransport({
+      sendJob: jest.fn().mockImplementation(
+        () => new Promise((resolve) => setTimeout(resolve, 60000)), // never resolves within timeout
+      ),
+    });
+    transports.set(id, transport);
+
+    const request = createMockJobRequest({ timeout: 50 });
+
+    await expect(dispatcher.dispatchJob(request, registry, '2022.3.0f1')).rejects.toThrow(/timed out/);
+
+    // Transport should have been disconnected to clean up orphaned connection
+    expect(transport.disconnect).toHaveBeenCalled();
+  });
+
   it('should call output callback with job output', async () => {
     const id = registry.registerRunner(createMockConfig());
     registry.updateRunner(id, { state: 'idle' });
@@ -512,6 +664,7 @@ describe('HotRunnerDispatcher', () => {
 
   it('should wait for runner to become available', async () => {
     const id = registry.registerRunner(createMockConfig());
+
     // Runner starts in 'starting' state, not idle
 
     const transport = createMockTransport();