@siftd/connect-agent 0.2.8 → 0.2.10

package/dist/core/file-watcher.d.ts

@@ -0,0 +1,109 @@
+/**
+ * File Watcher for Reactive Workflows
+ *
+ * Enables the orchestrator to:
+ * - Watch directories/files for changes
+ * - Trigger callbacks on file events
+ * - Support glob patterns for filtering
+ * - Debounce rapid changes
+ */
+import { EventEmitter } from 'events';
+export type FileEventType = 'add' | 'change' | 'unlink' | 'addDir' | 'unlinkDir';
+export interface FileEvent {
+    type: FileEventType;
+    path: string;
+    timestamp: string;
+}
+export interface WatchRule {
+    id: string;
+    pattern: string;
+    events: FileEventType[];
+    action: string;
+    debounceMs?: number;
+    enabled: boolean;
+    lastTriggered?: string;
+}
+export interface WatcherConfig {
+    rulesFile: string;
+    defaultDebounce: number;
+}
+export declare class FileWatcher extends EventEmitter {
+    private watchers;
+    private rules;
+    private debounceTimers;
+    private config;
+    private rulesFile;
+    constructor(workspaceDir: string, config?: Partial<WatcherConfig>);
+    /**
+     * Add a watch rule
+     */
+    addRule(rule: Omit<WatchRule, 'id' | 'enabled'>): string;
+    /**
+     * Remove a watch rule
+     */
+    removeRule(id: string): boolean;
+    /**
+     * Enable/disable a rule
+     */
+    toggleRule(id: string, enabled: boolean): boolean;
+    /**
+     * List all rules
+     */
+    listRules(): WatchRule[];
+    /**
+     * Get a specific rule
+     */
+    getRule(id: string): WatchRule | undefined;
+    /**
+     * Watch a specific path
+     */
+    watch(targetPath: string, callback: (event: FileEvent) => void): string;
+    /**
+     * Stop watching a specific watcher
+     */
+    unwatch(watcherId: string): void;
+    /**
+     * Stop all watchers
+     */
+    stopAll(): void;
+    /**
+     * Get watcher status
+     */
+    status(): {
+        activeWatchers: number;
+        rules: number;
+        enabledRules: number;
+    };
+    private watchDirectory;
+    private watchFile;
+    private determineEventType;
+    private startWatching;
+    private stopWatching;
+    private loadRules;
+    private saveRules;
+}
+/**
+ * Common watch patterns for development workflows
+ */
+export declare const COMMON_PATTERNS: {
+    typescript: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+    tests: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+    config: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+    markdown: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+};

package/dist/core/file-watcher.js

@@ -0,0 +1,275 @@
+/**
+ * File Watcher for Reactive Workflows
+ *
+ * Enables the orchestrator to:
+ * - Watch directories/files for changes
+ * - Trigger callbacks on file events
+ * - Support glob patterns for filtering
+ * - Debounce rapid changes
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventEmitter } from 'events';
+export class FileWatcher extends EventEmitter {
+    watchers = new Map();
+    rules = new Map();
+    debounceTimers = new Map();
+    config;
+    rulesFile;
+    constructor(workspaceDir, config) {
+        super();
+        this.rulesFile = config?.rulesFile || path.join(workspaceDir, '.watch-rules.json');
+        this.config = {
+            rulesFile: this.rulesFile,
+            defaultDebounce: config?.defaultDebounce || 500
+        };
+        this.loadRules();
+    }
+    /**
+     * Add a watch rule
+     */
+    addRule(rule) {
+        const id = `watch_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        const fullRule = {
+            ...rule,
+            id,
+            enabled: true,
+            debounceMs: rule.debounceMs || this.config.defaultDebounce
+        };
+        this.rules.set(id, fullRule);
+        this.saveRules();
+        this.startWatching(fullRule);
+        return id;
+    }
+    /**
+     * Remove a watch rule
+     */
+    removeRule(id) {
+        const rule = this.rules.get(id);
+        if (!rule)
+            return false;
+        this.stopWatching(rule);
+        this.rules.delete(id);
+        this.saveRules();
+        return true;
+    }
+    /**
+     * Enable/disable a rule
+     */
+    toggleRule(id, enabled) {
+        const rule = this.rules.get(id);
+        if (!rule)
+            return false;
+        rule.enabled = enabled;
+        if (enabled) {
+            this.startWatching(rule);
+        }
+        else {
+            this.stopWatching(rule);
+        }
+        this.saveRules();
+        return true;
+    }
+    /**
+     * List all rules
+     */
+    listRules() {
+        return Array.from(this.rules.values());
+    }
+    /**
+     * Get a specific rule
+     */
+    getRule(id) {
+        return this.rules.get(id);
+    }
+    /**
+     * Watch a specific path
+     */
+    watch(targetPath, callback) {
+        const id = `direct_${Date.now()}`;
+        try {
+            const resolvedPath = path.resolve(targetPath);
+            const stat = fs.statSync(resolvedPath);
+            if (stat.isDirectory()) {
+                this.watchDirectory(resolvedPath, callback, id);
+            }
+            else {
+                this.watchFile(resolvedPath, callback, id);
+            }
+            return id;
+        }
+        catch (error) {
+            console.error(`[WATCHER] Failed to watch ${targetPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Stop watching a specific watcher
+     */
+    unwatch(watcherId) {
+        const watcher = this.watchers.get(watcherId);
+        if (watcher) {
+            watcher.close();
+            this.watchers.delete(watcherId);
+        }
+    }
+    /**
+     * Stop all watchers
+     */
+    stopAll() {
+        for (const [id, watcher] of this.watchers) {
+            watcher.close();
+        }
+        this.watchers.clear();
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+    }
+    /**
+     * Get watcher status
+     */
+    status() {
+        return {
+            activeWatchers: this.watchers.size,
+            rules: this.rules.size,
+            enabledRules: Array.from(this.rules.values()).filter(r => r.enabled).length
+        };
+    }
+    watchDirectory(dirPath, callback, id) {
+        const watcher = fs.watch(dirPath, { recursive: true }, (eventType, filename) => {
+            if (!filename)
+                return;
+            const fullPath = path.join(dirPath, filename);
+            const event = {
+                type: eventType === 'rename' ? this.determineEventType(fullPath) : 'change',
+                path: fullPath,
+                timestamp: new Date().toISOString()
+            };
+            callback(event);
+        });
+        this.watchers.set(id, watcher);
+    }
+    watchFile(filePath, callback, id) {
+        const watcher = fs.watch(filePath, (eventType) => {
+            const event = {
+                type: eventType === 'rename' ? 'unlink' : 'change',
+                path: filePath,
+                timestamp: new Date().toISOString()
+            };
+            callback(event);
+        });
+        this.watchers.set(id, watcher);
+    }
+    determineEventType(filePath) {
+        try {
+            const stat = fs.statSync(filePath);
+            return stat.isDirectory() ? 'addDir' : 'add';
+        }
+        catch {
+            return 'unlink';
+        }
+    }
+    startWatching(rule) {
+        if (!rule.enabled)
+            return;
+        try {
+            const targetPath = path.resolve(rule.pattern);
+            // Check if path exists
+            if (!fs.existsSync(targetPath)) {
+                console.log(`[WATCHER] Path does not exist yet: ${targetPath}`);
+                return;
+            }
+            const callback = (event) => {
+                if (!rule.events.includes(event.type))
+                    return;
+                // Debounce
+                const debounceKey = `${rule.id}_${event.path}`;
+                const existing = this.debounceTimers.get(debounceKey);
+                if (existing) {
+                    clearTimeout(existing);
+                }
+                const timer = setTimeout(() => {
+                    this.debounceTimers.delete(debounceKey);
+                    rule.lastTriggered = new Date().toISOString();
+                    this.saveRules();
+                    // Emit event for orchestrator to handle
+                    this.emit('trigger', {
+                        rule,
+                        event,
+                        action: rule.action
+                    });
+                }, rule.debounceMs || this.config.defaultDebounce);
+                this.debounceTimers.set(debounceKey, timer);
+            };
+            this.watch(targetPath, callback);
+            console.log(`[WATCHER] Started watching: ${rule.pattern}`);
+        }
+        catch (error) {
+            console.error(`[WATCHER] Failed to start watching ${rule.pattern}:`, error);
+        }
+    }
+    stopWatching(rule) {
+        // Find and close watchers for this rule
+        for (const [id, watcher] of this.watchers) {
+            if (id.includes(rule.id)) {
+                watcher.close();
+                this.watchers.delete(id);
+            }
+        }
+    }
+    loadRules() {
+        try {
+            if (fs.existsSync(this.rulesFile)) {
+                const data = JSON.parse(fs.readFileSync(this.rulesFile, 'utf8'));
+                for (const rule of data.rules || []) {
+                    this.rules.set(rule.id, rule);
+                    if (rule.enabled) {
+                        this.startWatching(rule);
+                    }
+                }
+                console.log(`[WATCHER] Loaded ${this.rules.size} watch rules`);
+            }
+        }
+        catch (error) {
+            console.error('[WATCHER] Failed to load rules:', error);
+        }
+    }
+    saveRules() {
+        try {
+            const data = {
+                rules: Array.from(this.rules.values()),
+                savedAt: new Date().toISOString()
+            };
+            fs.writeFileSync(this.rulesFile, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            console.error('[WATCHER] Failed to save rules:', error);
+        }
+    }
+}
+/**
+ * Common watch patterns for development workflows
+ */
+export const COMMON_PATTERNS = {
+    typescript: {
+        pattern: '**/*.ts',
+        events: ['change', 'add'],
+        action: 'TypeScript file changed - run type check and tests'
+    },
+    tests: {
+        pattern: '**/*.test.ts',
+        events: ['change', 'add'],
+        action: 'Test file changed - run tests'
+    },
+    config: {
+        pattern: '**/package.json',
+        events: ['change'],
+        action: 'Package.json changed - check for dependency updates'
+    },
+    markdown: {
+        pattern: '**/*.md',
+        events: ['change', 'add'],
+        action: 'Documentation changed - validate links and formatting'
+    }
+};

package/dist/heartbeat.js

@@ -10,7 +10,7 @@ import { hostname } from 'os';
 import { createHash } from 'crypto';
 import { getServerUrl, getAgentToken, getUserId, isCloudMode } from './config.js';
 const HEARTBEAT_INTERVAL = 10000; // 10 seconds
-const VERSION = '0.2.8'; // Should match package.json
+const VERSION = '0.2.10'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -22,6 +22,8 @@ export declare class MasterOrchestrator {
     private bashTool;
     private webTools;
     private workerTools;
+    private sharedState;
+    private fileWatcher;
     private verboseMode;
     constructor(options: {
         apiKey: string;
@@ -78,8 +80,12 @@ export declare class MasterOrchestrator {
      */
     private delegateToWorker;
     /**
-     * Extract memory contributions from worker output
-     * Workers can contribute learnings using: [MEMORY] type=X | content=Y
+     * Extract memory and coordination contributions from worker output
+     * Workers can contribute using:
+     * - [MEMORY] type=X | content=Y
+     * - [SHARE] key=X | value=Y
+     * - [SIGNAL] name=X | data=Y
+     * - [MESSAGE] to=X | content=Y
      */
     private extractWorkerMemories;
     /**
@@ -114,6 +120,26 @@ export declare class MasterOrchestrator {
      * Stop a running server on a port
      */
     private executeStopServer;
+    /**
+     * Add a file watch rule
+     */
+    private executeAddWatchRule;
+    /**
+     * Remove a file watch rule
+     */
+    private executeRemoveWatchRule;
+    /**
+     * List all file watch rules
+     */
+    private executeListWatchRules;
+    /**
+     * Toggle a file watch rule
+     */
+    private executeToggleWatchRule;
+    /**
+     * Get file watcher status
+     */
+    private executeWatchStatus;
     /**
      * Format tool preview for user
      */

package/dist/orchestrator.js

@@ -10,9 +10,11 @@ import { existsSync } from 'fs';
 import { AdvancedMemoryStore } from './core/memory-advanced.js';
 import { TaskScheduler } from './core/scheduler.js';
 import { SystemIndexer } from './core/system-indexer.js';
+import { FileWatcher } from './core/file-watcher.js';
 import { BashTool } from './tools/bash.js';
 import { WebTools } from './tools/web.js';
 import { WorkerTools } from './tools/worker.js';
+import { SharedState } from './workers/shared-state.js';
 import { getKnowledgeForPrompt } from './genesis/index.js';
 const SYSTEM_PROMPT = `You're the user's personal assistant - the friendly brain behind their Connect app. You chat with them from any browser, remember everything about them, and dispatch Claude Code workers to do things on their machine.
 
@@ -85,6 +87,8 @@ export class MasterOrchestrator {
     bashTool;
     webTools;
     workerTools;
+    sharedState;
+    fileWatcher;
     verboseMode = new Map(); // per-user verbose mode
     constructor(options) {
         this.client = new Anthropic({ apiKey: options.apiKey });
@@ -108,6 +112,15 @@ export class MasterOrchestrator {
         this.bashTool = new BashTool(this.workspaceDir);
         this.webTools = new WebTools();
         this.workerTools = new WorkerTools(this.workspaceDir);
+        this.sharedState = new SharedState(this.workspaceDir);
+        this.fileWatcher = new FileWatcher(this.workspaceDir);
+        // Set up file watcher trigger handler
+        this.fileWatcher.on('trigger', async ({ rule, event, action }) => {
+            console.log(`[WATCHER] Triggered: ${rule.pattern} (${event.type}: ${event.path})`);
+            // Auto-delegate to worker when file changes
+            const task = `${action}\n\nTriggered by file change:\n- File: ${event.path}\n- Event: ${event.type}\n- Rule: ${rule.pattern}`;
+            this.delegateToWorker(task, undefined, this.workspaceDir);
+        });
     }
     /**
      * Initialize the orchestrator - indexes filesystem on first call
@@ -590,6 +603,84 @@ Be specific about what you want done.`,
                     },
                     required: ['port']
                 }
+            },
+            // File watching tools for reactive workflows
+            {
+                name: 'add_watch_rule',
+                description: 'Add a file watch rule to automatically trigger actions when files change. Useful for reactive workflows like auto-running tests when code changes.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: 'File path or directory to watch (e.g., "./src", "/path/to/file.ts")'
+                        },
+                        events: {
+                            type: 'array',
+                            items: { type: 'string', enum: ['add', 'change', 'unlink', 'addDir', 'unlinkDir'] },
+                            description: 'Events to watch for (default: ["change", "add"])'
+                        },
+                        action: {
+                            type: 'string',
+                            description: 'Task description to execute when triggered (sent to a worker)'
+                        },
+                        debounce_ms: {
+                            type: 'number',
+                            description: 'Debounce delay in milliseconds (default: 500)'
+                        }
+                    },
+                    required: ['pattern', 'action']
+                }
+            },
+            {
+                name: 'remove_watch_rule',
+                description: 'Remove a file watch rule by its ID.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        rule_id: {
+                            type: 'string',
+                            description: 'The ID of the watch rule to remove'
+                        }
+                    },
+                    required: ['rule_id']
+                }
+            },
+            {
+                name: 'list_watch_rules',
+                description: 'List all active file watch rules.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            },
+            {
+                name: 'toggle_watch_rule',
+                description: 'Enable or disable a file watch rule.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        rule_id: {
+                            type: 'string',
+                            description: 'The ID of the watch rule to toggle'
+                        },
+                        enabled: {
+                            type: 'boolean',
+                            description: 'Whether to enable (true) or disable (false) the rule'
+                        }
+                    },
+                    required: ['rule_id', 'enabled']
+                }
+            },
+            {
+                name: 'watch_status',
+                description: 'Get the status of the file watcher system.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
             }
         ];
     }
@@ -669,6 +760,22 @@ Be specific about what you want done.`,
                 case 'stop_local_server':
                     result = await this.executeStopServer(input.port);
                     break;
+                // File watching tools
+                case 'add_watch_rule':
+                    result = await this.executeAddWatchRule(input.pattern, input.action, input.events, input.debounce_ms);
+                    break;
+                case 'remove_watch_rule':
+                    result = await this.executeRemoveWatchRule(input.rule_id);
+                    break;
+                case 'list_watch_rules':
+                    result = await this.executeListWatchRules();
+                    break;
+                case 'toggle_watch_rule':
+                    result = await this.executeToggleWatchRule(input.rule_id, input.enabled);
+                    break;
+                case 'watch_status':
+                    result = await this.executeWatchStatus();
+                    break;
                 default:
                     result = { success: false, output: `Unknown tool: ${toolUse.name}` };
             }
@@ -703,6 +810,8 @@ Be specific about what you want done.`,
             // Memory search failed, continue without it
             console.log('[ORCHESTRATOR] Memory search failed, continuing without context');
         }
+        // Get shared state context for worker coordination
+        const sharedContext = this.sharedState.getSummaryForWorker(id);
         // Build prompt for worker with memory context and checkpoint instructions
         let prompt = task;
         if (context) {
@@ -711,6 +820,9 @@ Be specific about what you want done.`,
         if (memoryContext) {
             prompt += memoryContext;
         }
+        if (sharedContext) {
+            prompt += `\n\nWORKER COORDINATION:${sharedContext}`;
+        }
         // Add checkpoint and logging instructions to prevent data loss
         const logFile = `/tmp/worker-${id}-log.txt`;
         prompt += `
@@ -730,7 +842,14 @@ If you discover something important (patterns, user preferences, technical insig
 end your response with a line like:
 [MEMORY] type=semantic | content=User prefers X over Y for this type of task
 [MEMORY] type=procedural | content=When doing X, always check Y first
-This helps me remember and improve for future tasks.`;
+This helps me remember and improve for future tasks.
+
+WORKER COORDINATION (optional):
+If you need to share data with other workers or signal completion:
+[SHARE] key=myData | value={"result": "something useful"}
+[SIGNAL] name=step1_complete | data={"files": ["a.ts", "b.ts"]}
+[MESSAGE] to=worker_xyz | content=Please review the changes I made
+This enables parallel workers to coordinate.`;
         console.log(`[ORCHESTRATOR] Delegating to worker ${id}: ${task.slice(0, 80)}...`);
         return new Promise((resolve) => {
             const job = {
@@ -822,37 +941,76 @@ This helps me remember and improve for future tasks.`;
         });
     }
     /**
-     * Extract memory contributions from worker output
-     * Workers can contribute learnings using: [MEMORY] type=X | content=Y
+     * Extract memory and coordination contributions from worker output
+     * Workers can contribute using:
+     * - [MEMORY] type=X | content=Y
+     * - [SHARE] key=X | value=Y
+     * - [SIGNAL] name=X | data=Y
+     * - [MESSAGE] to=X | content=Y
      */
     async extractWorkerMemories(output, workerId) {
-        // Match lines like: [MEMORY] type=semantic | content=User prefers X
+        let memoryCount = 0;
+        let coordCount = 0;
+        // Extract memory contributions
         const memoryPattern = /\[MEMORY\]\s*type=(\w+)\s*\|\s*content=(.+?)(?=\n|$)/g;
         let match;
-        let count = 0;
         while ((match = memoryPattern.exec(output)) !== null) {
             const type = match[1].toLowerCase();
             const content = match[2].trim();
             if (!content)
                 continue;
-            // Validate memory type
             const validTypes = ['episodic', 'semantic', 'procedural'];
             const memType = validTypes.includes(type) ? type : 'semantic';
             try {
                 await this.memory.remember(content, {
                     type: memType,
                     source: `worker:${workerId}`,
-                    importance: 0.7, // Worker-contributed memories are valuable
+                    importance: 0.7,
                     tags: ['worker-contributed', 'auto-learned']
                 });
-                count++;
+                memoryCount++;
             }
             catch (error) {
                 console.log(`[ORCHESTRATOR] Failed to store worker memory: ${error}`);
             }
         }
-        if (count > 0) {
-            console.log(`[ORCHESTRATOR] Extracted ${count} memory contributions from worker ${workerId}`);
+        // Extract shared state contributions
+        const sharePattern = /\[SHARE\]\s*key=(\w+)\s*\|\s*value=(.+?)(?=\n|$)/g;
+        while ((match = sharePattern.exec(output)) !== null) {
+            const key = match[1];
+            let value = match[2].trim();
+            try {
+                value = JSON.parse(value);
+            }
+            catch { /* use as string */ }
+            this.sharedState.set(key, value, workerId);
+            coordCount++;
+        }
+        // Extract signal completions
+        const signalPattern = /\[SIGNAL\]\s*name=(\w+)(?:\s*\|\s*data=(.+?))?(?=\n|$)/g;
+        while ((match = signalPattern.exec(output)) !== null) {
+            const name = match[1];
+            let data = match[2]?.trim();
+            try {
+                data = data ? JSON.parse(data) : undefined;
+            }
+            catch { /* use as string */ }
+            this.sharedState.signalComplete(name, workerId, data);
+            coordCount++;
+        }
+        // Extract messages
+        const messagePattern = /\[MESSAGE\]\s*to=(\w+)\s*\|\s*content=(.+?)(?=\n|$)/g;
+        while ((match = messagePattern.exec(output)) !== null) {
+            const to = match[1];
+            const content = match[2].trim();
+            this.sharedState.sendMessage(workerId, to, 'data', content);
+            coordCount++;
+        }
+        if (memoryCount > 0) {
+            console.log(`[ORCHESTRATOR] Extracted ${memoryCount} memory contributions from worker ${workerId}`);
+        }
+        if (coordCount > 0) {
+            console.log(`[ORCHESTRATOR] Extracted ${coordCount} coordination messages from worker ${workerId}`);
         }
     }
     /**
@@ -1014,6 +1172,99 @@ This helps me remember and improve for future tasks.`;
             return { success: false, output: `No server running on port ${port}` };
         }
     }
+    /**
+     * Add a file watch rule
+     */
+    async executeAddWatchRule(pattern, action, events, debounceMs) {
+        try {
+            const validEvents = ['add', 'change', 'unlink', 'addDir', 'unlinkDir'];
+            const eventList = events
+                ? events.filter((e) => validEvents.includes(e))
+                : ['change', 'add'];
+            const ruleId = this.fileWatcher.addRule({
+                pattern,
+                events: eventList,
+                action,
+                debounceMs
+            });
+            console.log(`[ORCHESTRATOR] Added watch rule ${ruleId}: ${pattern}`);
+            return {
+                success: true,
+                output: `Watch rule added:\n- ID: ${ruleId}\n- Pattern: ${pattern}\n- Events: ${eventList.join(', ')}\n- Action: ${action}\n- Debounce: ${debounceMs || 500}ms`
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to add watch rule: ${msg}` };
+        }
+    }
+    /**
+     * Remove a file watch rule
+     */
+    async executeRemoveWatchRule(ruleId) {
+        try {
+            const removed = this.fileWatcher.removeRule(ruleId);
+            if (removed) {
+                console.log(`[ORCHESTRATOR] Removed watch rule ${ruleId}`);
+                return { success: true, output: `Watch rule ${ruleId} removed` };
+            }
+            return { success: false, output: `Watch rule ${ruleId} not found` };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to remove watch rule: ${msg}` };
+        }
+    }
+    /**
+     * List all file watch rules
+     */
+    async executeListWatchRules() {
+        try {
+            const rules = this.fileWatcher.listRules();
+            if (rules.length === 0) {
+                return { success: true, output: 'No watch rules configured.' };
+            }
+            const output = rules.map(r => `${r.enabled ? '✓' : '⏸'} ${r.id}\n  Pattern: ${r.pattern}\n  Events: ${r.events.join(', ')}\n  Action: ${r.action.slice(0, 60)}...${r.lastTriggered ? `\n  Last triggered: ${r.lastTriggered}` : ''}`).join('\n\n');
+            return { success: true, output: `Watch Rules (${rules.length}):\n\n${output}` };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to list watch rules: ${msg}` };
+        }
+    }
+    /**
+     * Toggle a file watch rule
+     */
+    async executeToggleWatchRule(ruleId, enabled) {
+        try {
+            const toggled = this.fileWatcher.toggleRule(ruleId, enabled);
+            if (toggled) {
+                console.log(`[ORCHESTRATOR] ${enabled ? 'Enabled' : 'Disabled'} watch rule ${ruleId}`);
+                return { success: true, output: `Watch rule ${ruleId} ${enabled ? 'enabled' : 'disabled'}` };
+            }
+            return { success: false, output: `Watch rule ${ruleId} not found` };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to toggle watch rule: ${msg}` };
+        }
+    }
+    /**
+     * Get file watcher status
+     */
+    async executeWatchStatus() {
+        try {
+            const status = this.fileWatcher.status();
+            return {
+                success: true,
+                output: `File Watcher Status:\n- Active watchers: ${status.activeWatchers}\n- Total rules: ${status.rules}\n- Enabled rules: ${status.enabledRules}`
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to get watcher status: ${msg}` };
+        }
+    }
     /**
      * Format tool preview for user
      */
@@ -1057,6 +1308,16 @@ This helps me remember and improve for future tasks.`;
                 return `Starting server on port ${input.port || 8080}...`;
             case 'stop_local_server':
                 return `Stopping server on port ${input.port}...`;
+            case 'add_watch_rule':
+                return `Adding watch rule for ${input.pattern}...`;
+            case 'remove_watch_rule':
+                return `Removing watch rule ${input.rule_id}...`;
+            case 'list_watch_rules':
+                return 'Listing watch rules...';
+            case 'toggle_watch_rule':
+                return `${input.enabled ? 'Enabling' : 'Disabling'} watch rule ${input.rule_id}...`;
+            case 'watch_status':
+                return 'Getting watcher status...';
             default:
                 return null;
         }
@@ -1077,6 +1338,7 @@ This helps me remember and improve for future tasks.`;
      * Shutdown cleanly
      */
     shutdown() {
+        this.fileWatcher.stopAll();
         this.scheduler.shutdown();
         this.memory.close();
     }

package/dist/workers/shared-state.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Shared State for Worker Communication
+ *
+ * Enables workers to:
+ * - Share data via a common state store
+ * - Signal completion of dependencies
+ * - Lock resources to prevent conflicts
+ * - Pass messages between workers
+ */
+export interface SharedMessage {
+    from: string;
+    to: string | '*';
+    type: 'data' | 'signal' | 'request';
+    content: string;
+    timestamp: string;
+}
+export interface ResourceLock {
+    resource: string;
+    owner: string;
+    acquired: string;
+    expires: string;
+}
+export declare class SharedState {
+    private stateDir;
+    private stateFile;
+    private messagesFile;
+    private locksFile;
+    constructor(workspaceDir: string);
+    private ensureStateDir;
+    /**
+     * Set a shared value
+     */
+    set(key: string, value: unknown, workerId?: string): void;
+    /**
+     * Get a shared value
+     */
+    get(key: string): unknown;
+    /**
+     * Get all shared state
+     */
+    getAll(): Record<string, unknown>;
+    /**
+     * Signal that a worker has completed a specific task/dependency
+     */
+    signalComplete(signalName: string, workerId: string, data?: unknown): void;
+    /**
+     * Wait for a signal (polling-based)
+     * Returns true if signal is already set, false if not
+     */
+    checkSignal(signalName: string): {
+        completed: boolean;
+        data?: unknown;
+    };
+    /**
+     * Send a message to another worker
+     */
+    sendMessage(from: string, to: string, type: 'data' | 'signal' | 'request', content: string): void;
+    /**
+     * Get messages for a worker
+     */
+    getMessages(workerId: string, since?: string): SharedMessage[];
+    /**
+     * Try to acquire a resource lock
+     */
+    acquireLock(resource: string, workerId: string, durationMs?: number): boolean;
+    /**
+     * Release a resource lock
+     */
+    releaseLock(resource: string, workerId: string): boolean;
+    /**
+     * Clean up expired locks
+     */
+    cleanupExpiredLocks(): void;
+    /**
+     * Get summary for injecting into worker prompts
+     */
+    getSummaryForWorker(workerId: string): string;
+    /**
+     * Clear all shared state (for cleanup between sessions)
+     */
+    clear(): void;
+    private loadState;
+    private saveState;
+    private loadSignals;
+    private saveSignals;
+    private loadMessages;
+    private saveMessages;
+    private loadLocks;
+    private saveLocks;
+}

package/dist/workers/shared-state.js

@@ -0,0 +1,254 @@
+/**
+ * Shared State for Worker Communication
+ *
+ * Enables workers to:
+ * - Share data via a common state store
+ * - Signal completion of dependencies
+ * - Lock resources to prevent conflicts
+ * - Pass messages between workers
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export class SharedState {
+    stateDir;
+    stateFile;
+    messagesFile;
+    locksFile;
+    constructor(workspaceDir) {
+        this.stateDir = path.join(workspaceDir, '.worker-state');
+        this.stateFile = path.join(this.stateDir, 'state.json');
+        this.messagesFile = path.join(this.stateDir, 'messages.json');
+        this.locksFile = path.join(this.stateDir, 'locks.json');
+        this.ensureStateDir();
+    }
+    ensureStateDir() {
+        if (!fs.existsSync(this.stateDir)) {
+            fs.mkdirSync(this.stateDir, { recursive: true });
+        }
+    }
+    /**
+     * Set a shared value
+     */
+    set(key, value, workerId) {
+        const state = this.loadState();
+        state[key] = {
+            value,
+            setBy: workerId || 'unknown',
+            timestamp: new Date().toISOString()
+        };
+        this.saveState(state);
+    }
+    /**
+     * Get a shared value
+     */
+    get(key) {
+        const state = this.loadState();
+        return state[key]?.value;
+    }
+    /**
+     * Get all shared state
+     */
+    getAll() {
+        const state = this.loadState();
+        const result = {};
+        for (const [key, entry] of Object.entries(state)) {
+            result[key] = entry.value;
+        }
+        return result;
+    }
+    /**
+     * Signal that a worker has completed a specific task/dependency
+     */
+    signalComplete(signalName, workerId, data) {
+        const signals = this.loadSignals();
+        signals[signalName] = {
+            completed: true,
+            completedBy: workerId,
+            timestamp: new Date().toISOString(),
+            data
+        };
+        this.saveSignals(signals);
+    }
+    /**
+     * Wait for a signal (polling-based)
+     * Returns true if signal is already set, false if not
+     */
+    checkSignal(signalName) {
+        const signals = this.loadSignals();
+        const signal = signals[signalName];
+        if (signal?.completed) {
+            return { completed: true, data: signal.data };
+        }
+        return { completed: false };
+    }
+    /**
+     * Send a message to another worker
+     */
+    sendMessage(from, to, type, content) {
+        const messages = this.loadMessages();
+        messages.push({
+            from,
+            to,
+            type,
+            content,
+            timestamp: new Date().toISOString()
+        });
+        // Keep last 100 messages
+        if (messages.length > 100) {
+            messages.splice(0, messages.length - 100);
+        }
+        this.saveMessages(messages);
+    }
+    /**
+     * Get messages for a worker
+     */
+    getMessages(workerId, since) {
+        const messages = this.loadMessages();
+        return messages.filter(m => {
+            const isForMe = m.to === workerId || m.to === '*';
+            const isAfterSince = !since || m.timestamp > since;
+            return isForMe && isAfterSince;
+        });
+    }
+    /**
+     * Try to acquire a resource lock
+     */
+    acquireLock(resource, workerId, durationMs = 60000) {
+        const locks = this.loadLocks();
+        const now = new Date();
+        const existing = locks[resource];
+        // Check if existing lock is still valid
+        if (existing && new Date(existing.expires) > now && existing.owner !== workerId) {
+            return false; // Lock held by another worker
+        }
+        // Acquire lock
+        locks[resource] = {
+            resource,
+            owner: workerId,
+            acquired: now.toISOString(),
+            expires: new Date(now.getTime() + durationMs).toISOString()
+        };
+        this.saveLocks(locks);
+        return true;
+    }
+    /**
+     * Release a resource lock
+     */
+    releaseLock(resource, workerId) {
+        const locks = this.loadLocks();
+        if (locks[resource]?.owner === workerId) {
+            delete locks[resource];
+            this.saveLocks(locks);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Clean up expired locks
+     */
+    cleanupExpiredLocks() {
+        const locks = this.loadLocks();
+        const now = new Date();
+        let changed = false;
+        for (const [resource, lock] of Object.entries(locks)) {
+            if (new Date(lock.expires) < now) {
+                delete locks[resource];
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.saveLocks(locks);
+        }
+    }
+    /**
+     * Get summary for injecting into worker prompts
+     */
+    getSummaryForWorker(workerId) {
+        const state = this.getAll();
+        const messages = this.getMessages(workerId);
+        const signals = this.loadSignals();
+        let summary = '';
+        if (Object.keys(state).length > 0) {
+            summary += '\n## Shared State:\n';
+            for (const [key, value] of Object.entries(state)) {
+                summary += `- ${key}: ${JSON.stringify(value)}\n`;
+            }
+        }
+        if (messages.length > 0) {
+            summary += '\n## Messages for you:\n';
+            for (const msg of messages.slice(-5)) { // Last 5 messages
+                summary += `- [${msg.from}] ${msg.content}\n`;
+            }
+        }
+        const completedSignals = Object.entries(signals).filter(([, s]) => s.completed);
+        if (completedSignals.length > 0) {
+            summary += '\n## Completed dependencies:\n';
+            for (const [name] of completedSignals) {
+                summary += `- ${name} ✓\n`;
+            }
+        }
+        return summary;
+    }
+    /**
+     * Clear all shared state (for cleanup between sessions)
+     */
+    clear() {
+        if (fs.existsSync(this.stateFile))
+            fs.unlinkSync(this.stateFile);
+        if (fs.existsSync(this.messagesFile))
+            fs.unlinkSync(this.messagesFile);
+        if (fs.existsSync(this.locksFile))
+            fs.unlinkSync(this.locksFile);
+    }
+    // Private helpers
+    loadState() {
+        try {
+            if (fs.existsSync(this.stateFile)) {
+                return JSON.parse(fs.readFileSync(this.stateFile, 'utf8'));
+            }
+        }
+        catch { /* ignore */ }
+        return {};
+    }
+    saveState(state) {
+        fs.writeFileSync(this.stateFile, JSON.stringify(state, null, 2));
+    }
+    loadSignals() {
+        try {
+            const signalsFile = path.join(this.stateDir, 'signals.json');
+            if (fs.existsSync(signalsFile)) {
+                return JSON.parse(fs.readFileSync(signalsFile, 'utf8'));
+            }
+        }
+        catch { /* ignore */ }
+        return {};
+    }
+    saveSignals(signals) {
+        const signalsFile = path.join(this.stateDir, 'signals.json');
+        fs.writeFileSync(signalsFile, JSON.stringify(signals, null, 2));
+    }
+    loadMessages() {
+        try {
+            if (fs.existsSync(this.messagesFile)) {
+                return JSON.parse(fs.readFileSync(this.messagesFile, 'utf8'));
+            }
+        }
+        catch { /* ignore */ }
+        return [];
+    }
+    saveMessages(messages) {
+        fs.writeFileSync(this.messagesFile, JSON.stringify(messages, null, 2));
+    }
+    loadLocks() {
+        try {
+            if (fs.existsSync(this.locksFile)) {
+                return JSON.parse(fs.readFileSync(this.locksFile, 'utf8'));
+            }
+        }
+        catch { /* ignore */ }
+        return {};
+    }
+    saveLocks(locks) {
+        fs.writeFileSync(this.locksFile, JSON.stringify(locks, null, 2));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",