@siftd/connect-agent 0.2.6 → 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.6'; // 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

@@ -362,7 +362,7 @@ export class MasterOrchestrator {
                         },
                         timeout: {
                             type: 'number',
-                            description: 'Timeout in milliseconds (default: 300000 / 5 min)'
+                            description: 'Timeout in milliseconds (default: 600000 / 10 min, max: 3600000 / 60 min)'
                         },
                         priority: {
                             type: 'string',
@@ -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 = {
@@ -729,7 +752,8 @@ This ensures nothing is lost even if your output gets truncated.`;
             });
             job.process = child;
             this.jobs.set(id, job);
-            // Timeout after 5 minutes
+            // Timeout after 10 minutes (increased from 5 for complex tasks)
+            const WORKER_TIMEOUT = 10 * 60 * 1000;
             const timeout = setTimeout(() => {
                 if (job.status === 'running') {
                     job.status = 'timeout';
@@ -746,11 +770,11 @@ This ensures nothing is lost even if your output gets truncated.`;
                     resolve({
                         success: false,
                         output: partialOutput
-                            ? `Worker timed out after 5 minutes. Partial findings:\n${partialOutput.slice(-2000)}`
-                            : 'Worker timed out after 5 minutes with no output. The task may be too complex - try breaking it into smaller steps.'
+                            ? `Worker timed out after 10 minutes. Partial findings:\n${partialOutput.slice(-2000)}`
+                            : 'Worker timed out after 10 minutes with no output. The task may be too complex - try breaking it into smaller steps.'
                     });
                 }
-            }, 5 * 60 * 1000);
+            }, WORKER_TIMEOUT);
             child.stdout?.on('data', (data) => {
                 job.output += data.toString();
             });
@@ -761,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();
@@ -770,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)'
@@ -795,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/dist/workers/types.js

@@ -2,9 +2,9 @@
  * Worker System Types
  */
 export const DEFAULT_WORKER_CONFIG = {
-    maxParallel: 3,
-    defaultTimeout: 300000, // 5 minutes
-    maxTimeout: 1800000, // 30 minutes
-    jobRetention: 3600000, // 1 hour
+    maxParallel: 20, // Increased from 3 for real orchestration
+    defaultTimeout: 600000, // 10 minutes (was 5)
+    maxTimeout: 3600000, // 60 minutes (was 30)
+    jobRetention: 86400000, // 24 hours (was 1 hour)
     jobsDir: '' // Set at runtime
 };

package/package.json

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