@adhdev/daemon-core 0.6.72 → 0.6.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.72",
+  "version": "0.6.73",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,6 +33,7 @@
     "@agentclientprotocol/sdk": "^0.16.1",
     "@xterm/xterm": "^6.0.0",
     "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
     "conf": "^13.0.0",
     "node-pty": "^1.1.0",
     "ws": "^8.19.0"

package/src/boot/daemon-lifecycle.ts

@@ -18,6 +18,7 @@ import { AgentStreamPoller } from '../agent-stream/poller.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import { VersionArchive, detectAllVersions } from '../providers/version-archive.js';
 import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { DevServer } from '../daemon/dev-server.js';
 import { detectIDEs } from '../detection/ide-detector.js';
 import { installGlobalInterceptor, LOG } from '../logging/logger.js';
 import { loadConfig } from '../config/config.js';
@@ -73,6 +74,11 @@ export interface DaemonComponents {
     detectedIdes: { value: any[] };
 }
 
+export interface DaemonDevSupportOptions {
+    components: DaemonComponents;
+    logFn?: (msg: string) => void;
+}
+
 // ─── Init ───
 
 /**
@@ -240,6 +246,24 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     };
 }
 
+/**
+ * Start shared dev-only helpers:
+ * - DevServer on port 19280
+ * - Provider hot-reload watcher
+ */
+export async function startDaemonDevSupport(options: DaemonDevSupportOptions): Promise<DevServer> {
+    const devServer = new DevServer({
+        providerLoader: options.components.providerLoader,
+        cdpManagers: options.components.cdpManagers,
+        instanceManager: options.components.instanceManager,
+        cliManager: options.components.cliManager,
+        logFn: options.logFn,
+    });
+    await devServer.start();
+    options.components.providerLoader.watch();
+    return devServer;
+}
+
 // ─── Shutdown ───
 
 /**

package/src/cli-adapters/provider-cli-adapter.ts

@@ -355,6 +355,8 @@ export class ProviderCliAdapter implements CliAdapter {
 
  // PTY I/O
     private onPtyDataCallback: ((data: string) => void) | null = null;
+    private pendingOutputParseBuffer = '';
+    private pendingOutputParseTimer: NodeJS.Timeout | null = null;
     private ptyOutputBuffer = '';
     private ptyOutputFlushTimer: NodeJS.Timeout | null = null;
 
@@ -516,6 +518,17 @@ export class ProviderCliAdapter implements CliAdapter {
         this.onPtyDataCallback = callback;
     }
 
+    private flushPendingOutputParse(): void {
+        if (this.pendingOutputParseTimer) {
+            clearTimeout(this.pendingOutputParseTimer);
+            this.pendingOutputParseTimer = null;
+        }
+        if (!this.pendingOutputParseBuffer) return;
+        const rawData = this.pendingOutputParseBuffer;
+        this.pendingOutputParseBuffer = '';
+        this.handleOutput(rawData);
+    }
+
     async spawn(): Promise<void> {
         if (this.ptyProcess) return;
         if (!pty) throw new Error('node-pty is not installed');
@@ -576,7 +589,21 @@ export class ProviderCliAdapter implements CliAdapter {
         }
 
         this.ptyProcess.onData((data: string) => {
-            this.handleOutput(data);
+            if (Date.now() < this.resizeSuppressUntil) return;
+
+            if (data.includes('\x1b[6n') || data.includes('\x1b[?6n')) {
+                // Some TUIs probe cursor position during startup; reply quickly even when batching parsing.
+                this.ptyProcess?.write('\x1b[1;1R');
+            }
+
+            this.pendingOutputParseBuffer += data;
+            if (!this.pendingOutputParseTimer) {
+                this.pendingOutputParseTimer = setTimeout(() => {
+                    this.pendingOutputParseTimer = null;
+                    this.flushPendingOutputParse();
+                }, this.timeouts.ptyFlush);
+            }
+
             if (this.onPtyDataCallback) {
                 this.ptyOutputBuffer += data;
                 if (!this.ptyOutputFlushTimer) {
@@ -593,6 +620,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
         this.ptyProcess.onExit(({ exitCode }: { exitCode: number }) => {
             LOG.info('CLI', `[${this.cliType}] Exit code ${exitCode}`);
+            this.flushPendingOutputParse();
             this.ptyProcess = null;
             this.setStatus('stopped', 'pty_exit');
             this.ready = false;
@@ -615,13 +643,6 @@ export class ProviderCliAdapter implements CliAdapter {
  // ─── Output Handling ────────────────────────────
 
     private handleOutput(rawData: string): void {
-        if (Date.now() < this.resizeSuppressUntil) return;
-
-        if (rawData.includes('\x1b[6n') || rawData.includes('\x1b[?6n')) {
-            // Some TUIs probe cursor position during startup; node-pty does not answer automatically.
-            this.ptyProcess?.write('\x1b[1;1R');
-        }
-
         this.terminalScreen.write(rawData);
         this.terminalHistory = mergeTerminalHistory(this.terminalHistory, this.terminalScreen.getText());
         const cleanData = stripAnsi(rawData);
@@ -1136,6 +1157,10 @@ export class ProviderCliAdapter implements CliAdapter {
         if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
         if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
         if (this.submitRetryTimer) { clearTimeout(this.submitRetryTimer); this.submitRetryTimer = null; }
+        if (this.pendingOutputParseTimer) { clearTimeout(this.pendingOutputParseTimer); this.pendingOutputParseTimer = null; }
+        this.pendingOutputParseBuffer = '';
+        if (this.ptyOutputFlushTimer) { clearTimeout(this.ptyOutputFlushTimer); this.ptyOutputFlushTimer = null; }
+        this.ptyOutputBuffer = '';
         if (this.ptyProcess) {
             this.ptyProcess.write('\x03');
             setTimeout(() => {
@@ -1159,6 +1184,10 @@ export class ProviderCliAdapter implements CliAdapter {
         this.currentTurnScope = null;
         this.submitRetryUsed = false;
         this.submitRetryPromptSnippet = '';
+        if (this.pendingOutputParseTimer) { clearTimeout(this.pendingOutputParseTimer); this.pendingOutputParseTimer = null; }
+        this.pendingOutputParseBuffer = '';
+        if (this.ptyOutputFlushTimer) { clearTimeout(this.ptyOutputFlushTimer); this.ptyOutputFlushTimer = null; }
+        this.ptyOutputBuffer = '';
         this.terminalScreen.reset();
         this.onStatusChange?.();
     }
@@ -1236,6 +1265,8 @@ export class ProviderCliAdapter implements CliAdapter {
             scriptNames: Object.keys(this.cliScripts).filter(k => typeof (this.cliScripts as any)[k] === 'function'),
             statusHistory: this.statusHistory.slice(-30),
             timeouts: this.timeouts,
+            pendingOutputParseBufferLength: this.pendingOutputParseBuffer.length,
+            pendingOutputParseScheduled: !!this.pendingOutputParseTimer,
             ptyAlive: !!this.ptyProcess,
         };
     }

package/src/daemon/dev-server.ts

@@ -1876,26 +1876,78 @@ export class DevServer {
     if (ref?.category === category) return desired;
 
     const all = this.providerLoader.getAll();
-    const fallback = all.find((p: any) => p.category === category && p.type !== targetType);
+    const fallback = all
+      .filter((p: any) => p.category === category && p.type !== targetType)
+      .sort((a: any, b: any) => String(a.type || '').localeCompare(String(b.type || ''), undefined, { numeric: true, sensitivity: 'base' }))[0];
     return fallback?.type || null;
   }
 
-  private loadAutoImplReferenceScripts(category: ProviderCategory, referenceType: string | null): Record<string, string> {
+  private getLatestScriptVersionDir(scriptsDir: string): string | null {
+    if (!fs.existsSync(scriptsDir)) return null;
+
+    const versions = fs.readdirSync(scriptsDir)
+      .filter((d: string) => {
+        try { return fs.statSync(path.join(scriptsDir, d)).isDirectory(); } catch { return false; }
+      })
+      .sort((a: string, b: string) => b.localeCompare(a, undefined, { numeric: true, sensitivity: 'base' }));
+
+    if (versions.length === 0) return null;
+    return path.join(scriptsDir, versions[0]);
+  }
+
+  private resolveAutoImplWritableProviderDir(category: ProviderCategory, type: string, requestedDir?: string): string | null {
+    const canonicalUserDir = path.resolve(this.providerLoader.getUserProviderDir(category, type));
+    const desiredDir = requestedDir ? path.resolve(requestedDir) : canonicalUserDir;
+
+    if (desiredDir !== canonicalUserDir) {
+      return null;
+    }
+
+    const userRoot = path.resolve(this.providerLoader.getUserDir());
+    if (desiredDir !== userRoot && !desiredDir.startsWith(`${userRoot}${path.sep}`)) {
+      return null;
+    }
+
+    const sourceDir = this.findProviderDir(type);
+    if (!sourceDir) {
+      return null;
+    }
+
+    if (!fs.existsSync(desiredDir)) {
+      fs.mkdirSync(path.dirname(desiredDir), { recursive: true });
+      fs.cpSync(sourceDir, desiredDir, { recursive: true });
+      this.log(`Auto-implement writable copy created: ${desiredDir}`);
+    }
+
+    const providerJson = path.join(desiredDir, 'provider.json');
+    if (!fs.existsSync(providerJson)) {
+      return null;
+    }
+
+    try {
+      const providerData = JSON.parse(fs.readFileSync(providerJson, 'utf-8'));
+      if (providerData.disableUpstream !== true) {
+        providerData.disableUpstream = true;
+        fs.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
+      }
+    } catch {
+      return null;
+    }
+
+    return desiredDir;
+  }
+
+  private loadAutoImplReferenceScripts(referenceType: string | null): Record<string, string> {
     if (!referenceType) return {};
 
-    const refDir = this.providerLoader.getUpstreamProviderDir(category, referenceType);
-    if (!fs.existsSync(refDir)) return {};
+    const refDir = this.findProviderDir(referenceType);
+    if (!refDir || !fs.existsSync(refDir)) return {};
 
     const referenceScripts: Record<string, string> = {};
     const scriptsDir = path.join(refDir, 'scripts');
-    if (!fs.existsSync(scriptsDir)) return referenceScripts;
+    const latestDir = this.getLatestScriptVersionDir(scriptsDir);
+    if (!latestDir) return referenceScripts;
 
-    const versions = fs.readdirSync(scriptsDir).filter((d: string) => {
-      try { return fs.statSync(path.join(scriptsDir, d)).isDirectory(); } catch { return false; }
-    }).sort().reverse();
-    if (versions.length === 0) return referenceScripts;
-
-    const latestDir = path.join(scriptsDir, versions[0]);
     for (const file of fs.readdirSync(latestDir)) {
       if (!file.endsWith('.js')) continue;
       try {
@@ -1909,7 +1961,7 @@ export class DevServer {
 
   private async handleAutoImplement(type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     const body = await this.readBody(req);
-    const { agent = 'claude-cli', functions, reference = 'antigravity', model, comment } = body;
+    const { agent = 'claude-cli', functions, reference, model, comment, providerDir: requestedProviderDir } = body;
     if (!functions || !Array.isArray(functions) || functions.length === 0) {
       this.json(res, 400, { error: 'functions[] is required (e.g. ["readChat", "sendMessage"])' });
       return;
@@ -1923,8 +1975,13 @@ export class DevServer {
     const provider = this.providerLoader.resolve(type);
     if (!provider) { this.json(res, 404, { error: `Provider not found: ${type}` }); return; }
 
-    const providerDir = this.findProviderDir(type);
-    if (!providerDir) { this.json(res, 404, { error: `Provider directory not found: ${type}` }); return; }
+    const providerDir = this.resolveAutoImplWritableProviderDir(provider.category, type, requestedProviderDir);
+    if (!providerDir) {
+      this.json(res, 409, {
+        error: `Auto-implement only writes to the canonical user provider directory for '${type}'.`,
+      });
+      return;
+    }
 
     try {
       // 1. Collect DOM context
@@ -1952,7 +2009,7 @@ export class DevServer {
         }
       });
 
-      const referenceScripts = this.loadAutoImplReferenceScripts(provider.category, resolvedReference);
+      const referenceScripts = this.loadAutoImplReferenceScripts(resolvedReference);
 
       // 3. Build the prompt
       const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference);
@@ -2339,25 +2396,20 @@ export class DevServer {
     lines.push('');
 
     const scriptsDir = path.join(providerDir, 'scripts');
-    if (fs.existsSync(scriptsDir)) {
-      const versions = fs.readdirSync(scriptsDir).filter((d: string) => {
-        try { return fs.statSync(path.join(scriptsDir, d)).isDirectory(); } catch { return false; }
-      }).sort().reverse();
-      if (versions.length > 0) {
-        const vDir = path.join(scriptsDir, versions[0]);
-        lines.push(`Scripts version directory: \`${vDir}\``);
-        lines.push('');
-        for (const file of fs.readdirSync(vDir)) {
-          if (file.endsWith('.js')) {
-            try {
-              const content = fs.readFileSync(path.join(vDir, file), 'utf-8');
-              lines.push(`### \`${file}\``);
-              lines.push('```javascript');
-              lines.push(content);
-              lines.push('```');
-              lines.push('');
-            } catch { /* skip */ }
-          }
+    const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
+    if (latestScriptsDir) {
+      lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
+      lines.push('');
+      for (const file of fs.readdirSync(latestScriptsDir)) {
+        if (file.endsWith('.js')) {
+          try {
+            const content = fs.readFileSync(path.join(latestScriptsDir, file), 'utf-8');
+            lines.push(`### \`${file}\``);
+            lines.push('```javascript');
+            lines.push(content);
+            lines.push('```');
+            lines.push('');
+          } catch { /* skip */ }
         }
       }
     }
@@ -2442,7 +2494,7 @@ export class DevServer {
     lines.push('## Rules');
     lines.push('1. **Scripts WITHOUT params** → IIFE: `(() => { ... })()`');
     lines.push('2. **Scripts WITH params** → arrow: `(params) => { ... }` — router calls `(${script})(${JSON.stringify(params)})`');
-    lines.push('3. Use CSS selectors from the DOM analysis above');
+    lines.push('3. If live DOM analysis is included above, use it. Otherwise, discover selectors yourself via CDP before coding.');
     lines.push('4. Always wrap in try-catch, return `JSON.stringify(result)`');
     lines.push('5. Do NOT modify `scripts.js` router — only edit individual `*.js` files');
     lines.push('6. All scripts run in the browser (CDP evaluate) — use DOM APIs only');
@@ -2498,8 +2550,12 @@ export class DevServer {
     lines.push('');
 
     // ── DevConsole API for verification ──
-    lines.push('## YOU MUST EXPLORE THE DOM YOURSELF!');
-    lines.push('I have NOT provided you with the DOM snapshot. You MUST use your command-line tools to discover the IDE structure dynamically!');
+    lines.push('## DOM Exploration');
+    if (domContext) {
+      lines.push('A lightweight DOM snapshot is included above, but you MUST still verify selectors yourself before finalizing the scripts.');
+    } else {
+      lines.push('No DOM snapshot is included here. You MUST use your command-line tools to discover the IDE structure dynamically.');
+    }
     lines.push('');
     lines.push('### 1. Evaluate JS to explore IDE DOM');
     lines.push('Use cURL to run JavaScript inside the IDE:');
@@ -2604,26 +2660,21 @@ export class DevServer {
     lines.push('');
 
     const scriptsDir = path.join(providerDir, 'scripts');
-    if (fs.existsSync(scriptsDir)) {
-      const versions = fs.readdirSync(scriptsDir).filter((d: string) => {
-        try { return fs.statSync(path.join(scriptsDir, d)).isDirectory(); } catch { return false; }
-      }).sort().reverse();
-      if (versions.length > 0) {
-        const vDir = path.join(scriptsDir, versions[0]);
-        lines.push(`Scripts version directory: \`${vDir}\``);
-        lines.push('');
-        for (const file of fs.readdirSync(vDir)) {
-          if (!file.endsWith('.js')) continue;
-          try {
-            const content = fs.readFileSync(path.join(vDir, file), 'utf-8');
-            lines.push(`### \`${file}\``);
-            lines.push('```javascript');
-            lines.push(content);
-            lines.push('```');
-            lines.push('');
-          } catch {
-            // ignore
-          }
+    const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
+    if (latestScriptsDir) {
+      lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
+      lines.push('');
+      for (const file of fs.readdirSync(latestScriptsDir)) {
+        if (!file.endsWith('.js')) continue;
+        try {
+          const content = fs.readFileSync(path.join(latestScriptsDir, file), 'utf-8');
+          lines.push(`### \`${file}\``);
+          lines.push('```javascript');
+          lines.push(content);
+          lines.push('```');
+          lines.push('');
+        } catch {
+          // ignore
         }
       }
     }

package/src/index.ts

@@ -123,5 +123,5 @@ export { getAIExtensions, installExtensions, launchIDE, isExtensionInstalled } f
 export type { ExtensionInfo as InstallerExtensionInfo } from './installer.js';
 
 // ── Boot / Lifecycle ──
-export { initDaemonComponents, shutdownDaemonComponents } from './boot/daemon-lifecycle.js';
-export type { DaemonInitConfig, DaemonComponents } from './boot/daemon-lifecycle.js';
+export { initDaemonComponents, startDaemonDevSupport, shutdownDaemonComponents } from './boot/daemon-lifecycle.js';
+export type { DaemonInitConfig, DaemonComponents, DaemonDevSupportOptions } from './boot/daemon-lifecycle.js';

package/src/providers/provider-loader.ts

@@ -16,6 +16,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import * as chokidar from 'chokidar';
 import { registerIDEDefinition } from '../detection/ide-detector.js';
 import { LOG } from '../logging/logger.js';
 import { VersionArchive } from './version-archive.js';
@@ -29,11 +30,10 @@ import type {
 
 export class ProviderLoader {
   private providers = new Map<string, ProviderModule>();
-  private builtinDirs: string[];
   private userDir: string;
   private upstreamDir: string;
   private disableUpstream: boolean;
-  private watchers: fs.FSWatcher[] = [];
+  private watchers: any[] = [];
   private logFn: (msg: string) => void;
   private versionArchive: VersionArchive | null = null;
   private scriptsCache = new Map<string, Record<string, any>>();
@@ -47,28 +47,34 @@ export class ProviderLoader {
   private static readonly META_FILE = '.meta.json';
 
   constructor(options?: {
-    builtinDir?: string | string[];
     userDir?: string;
     logFn?: (msg: string) => void;
     /** Disable upstream auto-download (for dev/testing/OSS) */
     disableUpstream?: boolean;
   }) {
- // Legacy builtin directories (no longer shipped; providers come from upstream auto-download)
-    if (options?.builtinDir) {
-        this.builtinDirs = Array.isArray(options.builtinDir) ? options.builtinDir : [options.builtinDir];
-    } else {
-        this.builtinDirs = [];
-    }
- // Default directory for auto-downloads
+    this.logFn = options?.logFn || LOG.forComponent('Provider').asLogFn();
+
+    // Default directory for auto-downloads
     const defaultProvidersDir = path.join(os.homedir(), '.adhdev', 'providers');
 
- // User custom directory: ~/.adhdev/providers/ or custom via config
-    this.userDir = options?.userDir || defaultProvidersDir;
+    if (options?.userDir) {
+        this.userDir = options.userDir;
+        this.log(`Config 'providerDir' applied: ${this.userDir}`);
+    } else {
+        // Local dev overrides: Auto-detect local adhdev-providers repo for speed
+        const localRepoPath = path.resolve(__dirname, '../../../../../adhdev-providers');
+        if (fs.existsSync(localRepoPath)) {
+            this.userDir = localRepoPath;
+            this.log(`Auto-detected local public repository: ${this.userDir} (Dev workspace speedup)`);
+        } else {
+            this.userDir = defaultProvidersDir;
+            this.log(`Using default user providers directory: ${this.userDir}`);
+        }
+    }
 
- // Upstream auto-download directory is always in the default location to avoid polluting custom dirs
+    // Upstream auto-download directory is always in the default location
     this.upstreamDir = path.join(defaultProvidersDir, '.upstream');
     this.disableUpstream = options?.disableUpstream ?? false;
-    this.logFn = options?.logFn || LOG.forComponent('Provider').asLogFn();
   }
 
   private log(msg: string): void {
@@ -77,23 +83,9 @@ export class ProviderLoader {
 
  // ─── Public API ────────────────────────────────
 
- /**
- * Ordered builtin roots used for local fallback/reference data.
- */
-  getBuiltinDirs(): string[] {
-    return [...this.builtinDirs];
-  }
-
- /**
- * Primary builtin root used for local scaffolding/reference flows.
- */
-  getPrimaryBuiltinDir(): string {
-    return this.builtinDirs[0];
-  }
-
- /**
- * User override root (~/.adhdev/providers by default).
- */
+  /**
+   * User override root (~/.adhdev/providers by default).
+   */
   getUserDir(): string {
     return this.userDir;
   }
@@ -105,12 +97,12 @@ export class ProviderLoader {
     return this.upstreamDir;
   }
 
- /**
- * Provider search order for on-disk lookups.
- * Highest-priority editable overrides come first.
- */
+  /**
+   * Provider search order for on-disk lookups.
+   * Highest-priority editable overrides come first.
+   */
   getProviderRoots(): string[] {
-    return [this.userDir, this.upstreamDir, ...this.builtinDirs];
+    return [this.userDir, this.upstreamDir];
   }
 
  /**
@@ -135,17 +127,9 @@ export class ProviderLoader {
   }
 
   /**
-   * Canonical builtin directory for a provider.
+   * Find the on-disk directory for a provider by type.
+   * Search order: user override → upstream.
    */
-  getBuiltinProviderDir(category: ProviderCategory, type: string): string {
-    const builtinRoot = this.getPrimaryBuiltinDir();
-    return builtinRoot ? this.getProviderDir(builtinRoot, category, type) : '';
-  }
-
- /**
- * Find the on-disk directory for a provider by type.
- * Search order: user override → upstream → builtin fallback.
- */
   findProviderDir(type: string): string | null {
     return this.findProviderDirInternal(type);
   }
@@ -571,34 +555,42 @@ export class ProviderLoader {
 
     // Fallback: build from individual .js files
     const result = this.buildScriptWrappersFromDir(dir) as Record<string, any>;
-    this.log(`  [loadScriptsFromDir] ${type}: built wrappers from ${dir} (${Object.keys(result).length} scripts)`);
     this.scriptsCache.set(dir, result);
     return result;
   }
 
- /**
- * Hot-reload: start watching for file changes
- */
+  /**
+   * Hot-reload: start watching for file changes
+   */
   watch(): void {
     this.stopWatch();
     const watchDir = (dir: string) => {
       if (!fs.existsSync(dir)) {
- // Create directory if missing (so user can drop files)
         try { fs.mkdirSync(dir, { recursive: true }); } catch { return; }
       }
       try {
-        const watcher = fs.watch(dir, { recursive: true }, (event, filename) => {
-          if (filename?.endsWith('.js') || filename?.endsWith('.json')) {
-            this.log(`File changed: ${filename}, reloading...`);
-            this.loadAll();
-          }
+        const watcher = chokidar.watch(dir, {
+          ignored: /(^|[\/\\])\.\./, // ignore dotfiles
+          persistent: true,
+          ignoreInitial: true,
+          awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
         });
+
+        const handleChange = (filePath: string) => {
+          if (filePath.endsWith('.js') || filePath.endsWith('.json')) {
+            this.log(`File changed: ${path.basename(filePath)}, reloading...`);
+            this.reload();
+          }
+        };
+
+        watcher.on('add', handleChange).on('change', handleChange).on('unlink', handleChange);
+        watcher.on('error', (err: unknown) => this.log(`Watch error: ${(err as Error).message}`));
         this.watchers.push(watcher);
+        this.log(`Hot-reload watcher active: ${dir}`);
       } catch (e) {
         this.log(`Watch failed for ${dir}: ${(e as Error).message}`);
       }
     };
-    this.builtinDirs.forEach(dir => watchDir(dir));
     watchDir(this.userDir);
   }
 
@@ -1096,8 +1088,8 @@ export class ProviderLoader {
             count++;
             // Identify source tier for debugging
             const source = d.startsWith(this.userDir) && !d.includes('.upstream')
-              ? 'user' : d.startsWith(this.upstreamDir) ? 'upstream' : 'builtin';
-            const overrideWarning = existed && source === 'user' ? ' ⚠ OVERRIDES builtin/upstream' : '';
+              ? 'user' : 'upstream';
+            const overrideWarning = existed && source === 'user' ? ' ⚠ OVERRIDES upstream' : '';
             this.log(`  ${existed ? '🔄' : '✅'} ${mod.type} (${mod.category}) — ${mod.name} [${source}]${overrideWarning}`);
           }
         } catch (e) {