@siftd/connect-agent 0.2.7 → 0.2.9

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.7'; // Should match package.json
+const VERSION = '0.2.9'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -22,6 +22,7 @@ export declare class MasterOrchestrator {
     private bashTool;
     private webTools;
     private workerTools;
+    private sharedState;
     private verboseMode;
     constructor(options: {
         apiKey: string;
@@ -77,6 +78,15 @@ export declare class MasterOrchestrator {
      * Delegate task to Claude Code CLI worker with retry logic
      */
     private delegateToWorker;
+    /**
+     * 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;
     /**
      * Execute remember tool
      */

package/dist/orchestrator.js

@@ -13,6 +13,7 @@ import { SystemIndexer } from './core/system-indexer.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 +86,7 @@ export class MasterOrchestrator {
     bashTool;
     webTools;
     workerTools;
+    sharedState;
     verboseMode = new Map(); // per-user verbose mode
     constructor(options) {
         this.client = new Anthropic({ apiKey: options.apiKey });
@@ -108,6 +110,7 @@ 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);
     }
     /**
      * Initialize the orchestrator - indexes filesystem on first call
@@ -690,11 +693,32 @@ Be specific about what you want done.`,
         const maxRetries = 2;
         const id = `worker_${Date.now()}_${++this.jobCounter}`;
         const cwd = workingDir || this.workspaceDir;
-        // Build prompt for worker with checkpoint instructions
+        // Search for relevant memories to inject into worker prompt
+        let memoryContext = '';
+        try {
+            const relevantMemories = await this.memory.search(task, { limit: 5, minImportance: 0.3 });
+            if (relevantMemories.length > 0) {
+                memoryContext = '\n\nRELEVANT KNOWLEDGE FROM MEMORY:\n' +
+                    relevantMemories.map(m => `[${m.type}] ${m.content}`).join('\n');
+            }
+        }
+        catch (error) {
+            // 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) {
             prompt = `Context: ${context}\n\nTask: ${task}`;
         }
+        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 += `
@@ -707,7 +731,21 @@ IMPORTANT - Progress & Logging:
 REQUIRED - Log Export:
 At the END of your work, create a final log file at: ${logFile}
 Include: job_id=${id}, timestamp, summary of work done, files modified, key findings.
-This ensures nothing is lost even if your output gets truncated.`;
+This ensures nothing is lost even if your output gets truncated.
+
+LEARNING EXPORT (optional but valuable):
+If you discover something important (patterns, user preferences, technical insights),
+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.
+
+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 = {
@@ -762,7 +800,7 @@ This ensures nothing is lost even if your output gets truncated.`;
                     job.output += text;
                 }
             });
-            child.on('close', (code) => {
+            child.on('close', async (code) => {
                 clearTimeout(timeout);
                 job.status = code === 0 ? 'completed' : 'failed';
                 job.endTime = Date.now();
@@ -771,6 +809,8 @@ This ensures nothing is lost even if your output gets truncated.`;
                 if (code !== 0 || job.output.length === 0) {
                     console.log(`[ORCHESTRATOR] Worker ${id} output: ${job.output.slice(0, 200) || '(empty)'}`);
                 }
+                // Extract and store memory contributions from worker output
+                await this.extractWorkerMemories(job.output, id);
                 resolve({
                     success: code === 0,
                     output: job.output.trim() || '(No output)'
@@ -796,6 +836,79 @@ This ensures nothing is lost even if your output gets truncated.`;
             });
         });
     }
+    /**
+     * 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) {
+        let memoryCount = 0;
+        let coordCount = 0;
+        // Extract memory contributions
+        const memoryPattern = /\[MEMORY\]\s*type=(\w+)\s*\|\s*content=(.+?)(?=\n|$)/g;
+        let match;
+        while ((match = memoryPattern.exec(output)) !== null) {
+            const type = match[1].toLowerCase();
+            const content = match[2].trim();
+            if (!content)
+                continue;
+            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,
+                    tags: ['worker-contributed', 'auto-learned']
+                });
+                memoryCount++;
+            }
+            catch (error) {
+                console.log(`[ORCHESTRATOR] Failed to store worker memory: ${error}`);
+            }
+        }
+        // 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}`);
+        }
+    }
     /**
      * Execute remember tool
      */

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.7",
+  "version": "0.2.9",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",