@siftd/connect-agent 0.2.7 → 0.2.8

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

package/dist/orchestrator.d.ts

@@ -77,6 +77,11 @@ export declare class MasterOrchestrator {
      * Delegate task to Claude Code CLI worker with retry logic
      */
     private delegateToWorker;
+    /**
+     * Extract memory contributions from worker output
+     * Workers can contribute learnings using: [MEMORY] type=X | content=Y
+     */
+    private extractWorkerMemories;
     /**
      * Execute remember tool
      */

package/dist/orchestrator.js

@@ -690,11 +690,27 @@ 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');
+        }
+        // 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;
+        }
         // Add checkpoint and logging instructions to prevent data loss
         const logFile = `/tmp/worker-${id}-log.txt`;
         prompt += `
@@ -707,7 +723,14 @@ 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.`;
         console.log(`[ORCHESTRATOR] Delegating to worker ${id}: ${task.slice(0, 80)}...`);
         return new Promise((resolve) => {
             const job = {
@@ -762,7 +785,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 +794,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 +821,40 @@ This ensures nothing is lost even if your output gets truncated.`;
             });
         });
     }
+    /**
+     * Extract memory contributions from worker output
+     * Workers can contribute learnings using: [MEMORY] type=X | content=Y
+     */
+    async extractWorkerMemories(output, workerId) {
+        // Match lines like: [MEMORY] type=semantic | content=User prefers X
+        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
+                    tags: ['worker-contributed', 'auto-learned']
+                });
+                count++;
+            }
+            catch (error) {
+                console.log(`[ORCHESTRATOR] Failed to store worker memory: ${error}`);
+            }
+        }
+        if (count > 0) {
+            console.log(`[ORCHESTRATOR] Extracted ${count} memory contributions from worker ${workerId}`);
+        }
+    }
     /**
      * Execute remember tool
      */

package/package.json

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