fix: config reload — watch nested deps, fix Ctrl+C, propagate to runner

src/cli-main.ts

@@ -1332,20 +1332,25 @@
             snapshotStore: watchStore,
             onSwap: newConfig => {
               config = newConfig;
+              runner.updateConfig(newConfig);
               logger.info('[Watch] Config updated');
             },
           });
           const watcher = new ConfigWatcher(options.configPath, reloader);
           watcher.start();
           logger.info('Config watching enabled');
 
-          // Clean up watcher resources on process shutdown
-          const cleanup = () => {
+          // Clean up watcher resources on process shutdown, then re-raise
+          // the signal so the default handler (or other listeners) can terminate.
+          const onSignal = (sig: NodeJS.Signals) => {
             watcher.stop();
             watchStore.shutdown().catch(() => {});
+            process.removeListener('SIGINT', onSignal);
+            process.removeListener('SIGTERM', onSignal);
+            process.kill(process.pid, sig);
           };
-          process.on('SIGINT', cleanup);
-          process.on('SIGTERM', cleanup);
+          process.on('SIGINT', onSignal);
+          process.on('SIGTERM', onSignal);
         } catch (watchErr: unknown) {
           logger.warn(`Config watch setup failed (Slack mode continues without it): ${watchErr}`);
         }

src/config/config-watcher.ts

@@ -1,24 +1,108 @@
 /**
  * Config file watcher — watches for file changes and SIGUSR2 signals.
  *
+ * Watches the main config file AND all local dependencies (extends, include,
+ * imports) so that changes to nested workflows, skills, or parent configs
+ * trigger a reload.
+ *
  * Uses fs.watch (no external deps) with debouncing to handle editor quirks
  * (multiple write events per save). SIGUSR2 is guarded for non-Windows only.
- * The watcher uses persistent: false so it doesn't keep the process alive.
+ * All watchers use persistent: false so they don't keep the process alive.
  *
- * All reload calls are wrapped in error handling so that failures never
- * propagate as unhandled promise rejections or crash the process.
+ * After each successful reload the watch list is refreshed so newly added
+ * or removed dependencies are tracked automatically.
  */
 import fs from 'fs';
+import path from 'path';
 import { logger } from '../logger';
 import { ConfigReloader } from './config-reloader';
 
 const DEFAULT_DEBOUNCE_MS = 500;
 
+/**
+ * Collect all local file paths that a config depends on by parsing YAML
+ * and following extends/include/imports chains recursively.
+ * Remote URLs and the special "default" source are skipped.
+ */
+export function collectLocalConfigDeps(configPath: string, visited?: Set<string>): string[] {
+  visited = visited || new Set();
+  const absPath = path.resolve(configPath);
+  if (visited.has(absPath)) return [];
+  visited.add(absPath);
+
+  let content: string;
+  try {
+    content = fs.readFileSync(absPath, 'utf8');
+  } catch {
+    return [];
+  }
+
+  // Use a lightweight YAML parse — js-yaml is already a bundled dependency
+  let parsed: any;
+  try {
+    const yaml = require('js-yaml') as typeof import('js-yaml');
+    parsed = yaml.load(content);
+  } catch {
+    return [];
+  }
+
+  if (!parsed || typeof parsed !== 'object') return [];
+
+  const deps: string[] = [];
+  const baseDir = path.dirname(absPath);
+
+  const isLocal = (src: string): boolean =>
+    typeof src === 'string' &&
+    src !== 'default' &&
+    !src.startsWith('http://') &&
+    !src.startsWith('https://');
+
+  // extends / include
+  const extendsVal = parsed.extends || parsed.include;
+  if (extendsVal) {
+    const sources: string[] = Array.isArray(extendsVal) ? extendsVal : [extendsVal];
+    for (const src of sources) {
+      if (!isLocal(src)) continue;
+      const resolved = path.resolve(baseDir, src);
+      deps.push(resolved);
+      deps.push(...collectLocalConfigDeps(resolved, visited));
+    }
+  }
+
+  // imports (workflow / skill files)
+  if (Array.isArray(parsed.imports)) {
+    for (const src of parsed.imports) {
+      if (!isLocal(src)) continue;
+      const resolved = path.resolve(baseDir, src);
+      deps.push(resolved);
+      deps.push(...collectLocalConfigDeps(resolved, visited));
+    }
+  }
+
+  // checks/steps that reference external workflow configs via `config:` field
+  const checks = parsed.checks || parsed.steps;
+  if (checks && typeof checks === 'object') {
+    for (const check of Object.values(checks) as any[]) {
+      if (
+        check?.type === 'workflow' &&
+        typeof check?.config === 'string' &&
+        isLocal(check.config)
+      ) {
+        const resolved = path.resolve(baseDir, check.config);
+        deps.push(resolved);
+        deps.push(...collectLocalConfigDeps(resolved, visited));
+      }
+    }
+  }
+
+  return deps;
+}
+
 export class ConfigWatcher {
   private configPath: string;
   private reloader: ConfigReloader;
   private debounceMs: number;
-  private watcher: fs.FSWatcher | null = null;
+  private watchers: Map<string, fs.FSWatcher> = new Map();
   private debounceTimer: ReturnType<typeof setTimeout> | null = null;
   private signalHandler: (() => void) | null = null;
 
@@ -32,18 +116,11 @@
     // Remove any previous listeners in case start() is called after stop()
     this.stop();
 
-    // Watch the config file
-    try {
-      this.watcher = fs.watch(this.configPath, { persistent: false }, _eventType => {
-        this.debouncedReload();
-      });
+    // Collect all files to watch: main config + dependencies
+    const filesToWatch = this.collectWatchTargets();
 
-      this.watcher.on('error', err => {
-        logger.warn(`[ConfigWatcher] File watch error: ${err.message}`);
-      });
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err);
-      logger.warn(`[ConfigWatcher] Could not watch file: ${msg}`);
+    for (const filePath of filesToWatch) {
+      this.watchFile(filePath);
     }
 
     // Listen for SIGUSR2 (non-Windows)
@@ -55,14 +132,16 @@
       process.on('SIGUSR2', this.signalHandler);
     }
 
-    logger.info(`[ConfigWatcher] Watching ${this.configPath} for changes`);
+    const depCount = filesToWatch.length - 1;
+    const depMsg = depCount > 0 ? ` (+ ${depCount} dependencies)` : '';
+    logger.info(`[ConfigWatcher] Watching ${this.configPath}${depMsg} for changes`);
   }
 
   stop(): void {
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
+    for (const [, watcher] of this.watchers) {
+      watcher.close();
     }
+    this.watchers.clear();
 
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
@@ -79,6 +158,56 @@
     logger.debug('[ConfigWatcher] Stopped');
   }
 
+  /**
+   * Refresh the set of watched files after a successful reload.
+   * New dependencies are watched; removed ones are unwatched.
+   */
+  private refreshWatches(): void {
+    const newTargets = new Set(this.collectWatchTargets());
+    const current = new Set(this.watchers.keys());
+
+    // Stop watching removed files
+    for (const filePath of current) {
+      if (!newTargets.has(filePath)) {
+        this.watchers.get(filePath)?.close();
+        this.watchers.delete(filePath);
+        logger.debug(`[ConfigWatcher] Unwatched removed dep: ${filePath}`);
+      }
+    }
+
+    // Start watching new files
+    for (const filePath of newTargets) {
+      if (!current.has(filePath)) {
+        this.watchFile(filePath);
+        logger.debug(`[ConfigWatcher] Watching new dep: ${filePath}`);
+      }
+    }
+  }
+
+  private collectWatchTargets(): string[] {
+    const mainPath = path.resolve(this.configPath);
+    const deps = collectLocalConfigDeps(this.configPath);
+    // Deduplicate
+    return [...new Set([mainPath, ...deps])];
+  }
+
+  private watchFile(filePath: string): void {
+    try {
+      const watcher = fs.watch(filePath, { persistent: false }, _eventType => {
+        this.debouncedReload();
+      });
+
+      watcher.on('error', err => {
+        logger.warn(`[ConfigWatcher] Watch error on ${filePath}: ${err.message}`);
+      });
+
+      this.watchers.set(filePath, watcher);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`[ConfigWatcher] Could not watch ${filePath}: ${msg}`);
+    }
+  }
+
   private debouncedReload(): void {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
@@ -92,11 +221,19 @@
 
   /**
    * Fire-and-forget reload with full error handling.
+   * On success, refreshes the watch list to pick up new/removed dependencies.
    * Ensures unhandled promise rejections never escape.
    */
   private safeReload(): void {
-    this.reloader.reload().catch(err => {
-      logger.error(`[ConfigWatcher] Unhandled reload error: ${err}`);
-    });
+    this.reloader
+      .reload()
+      .then(success => {
+        if (success) {
+          this.refreshWatches();
+        }
+      })
+      .catch(err => {
+        logger.error(`[ConfigWatcher] Unhandled reload error: ${err}`);
+      });
   }
 }

src/slack/socket-runner.ts

@@ -71,6 +71,11 @@ export class SlackSocketRunner {
     this.cfg = cfg;
   }
 
+  /** Hot-swap the config used for future requests (does not affect in-flight ones). */
+  updateConfig(cfg: VisorConfig): void {
+    this.cfg = cfg;
+  }
+
   /**
    * Lazily initialize the SlackClient if not already set.
    * Called by both start() and handleMessage() to ensure the client is available.