@stackmemoryai/stackmemory 1.2.1 → 1.2.4

package/dist/src/integrations/mcp/tool-definitions.js

@@ -14,7 +14,9 @@ class MCPToolDefinitions {
       ...this.getTraceTools(),
       ...this.getDiscoveryTools(),
       ...this.getEditTools(),
-      ...this.getGraphitiTools()
+      ...this.getGraphitiTools(),
+      ...this.getTeamTools(),
+      ...this.getCordTools()
     ];
   }
   /**
@@ -755,6 +757,214 @@ class MCPToolDefinitions {
       }
     ];
   }
+  /**
+   * Multi-agent team collaboration tools
+   */
+  getTeamTools() {
+    return [
+      {
+        name: "team_context_get",
+        description: "Get context from other agents working on the same project. Returns recent frames and shared anchors from other sessions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              default: 10,
+              description: "Max frames to return"
+            },
+            types: {
+              type: "array",
+              items: { type: "string" },
+              description: "Filter by frame types"
+            },
+            since: {
+              type: "number",
+              description: "Only frames created after this timestamp (epoch ms)"
+            }
+          }
+        }
+      },
+      {
+        name: "team_context_share",
+        description: "Share a piece of context with other agents working on the same project. Creates a high-priority anchor visible to team_context_get.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "The context to share"
+            },
+            type: {
+              type: "string",
+              enum: [
+                "FACT",
+                "DECISION",
+                "CONSTRAINT",
+                "INTERFACE_CONTRACT",
+                "TODO",
+                "RISK"
+              ],
+              default: "FACT",
+              description: "Type of context"
+            },
+            priority: {
+              type: "number",
+              minimum: 1,
+              maximum: 10,
+              default: 8,
+              description: "Priority level (1-10)"
+            }
+          },
+          required: ["content"]
+        }
+      },
+      {
+        name: "team_search",
+        description: "Search across all agents' context in the project. Uses full-text search across all sessions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query"
+            },
+            limit: {
+              type: "number",
+              default: 20,
+              description: "Maximum results to return"
+            },
+            include_events: {
+              type: "boolean",
+              default: false,
+              description: "Include events in results"
+            }
+          },
+          required: ["query"]
+        }
+      }
+    ];
+  }
+  /**
+   * Cord task orchestration tools
+   */
+  getCordTools() {
+    return [
+      {
+        name: "cord_spawn",
+        description: "Create a subtask with clean context (spawn). Child sees only its prompt and completed blocker results.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            goal: {
+              type: "string",
+              description: "What this task should accomplish"
+            },
+            prompt: {
+              type: "string",
+              description: "Detailed instructions for the task"
+            },
+            blocked_by: {
+              type: "array",
+              items: { type: "string" },
+              description: "Task IDs that must complete before this can start"
+            },
+            parent_id: {
+              type: "string",
+              description: "Parent task ID"
+            }
+          },
+          required: ["goal"]
+        }
+      },
+      {
+        name: "cord_fork",
+        description: "Create a subtask with full sibling context (fork). Child sees its prompt, blocker results, AND completed sibling results.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            goal: {
+              type: "string",
+              description: "What this task should accomplish"
+            },
+            prompt: {
+              type: "string",
+              description: "Detailed instructions for the task"
+            },
+            blocked_by: {
+              type: "array",
+              items: { type: "string" },
+              description: "Task IDs that must complete before this can start"
+            },
+            parent_id: {
+              type: "string",
+              description: "Parent task ID"
+            }
+          },
+          required: ["goal"]
+        }
+      },
+      {
+        name: "cord_complete",
+        description: "Mark a cord task as completed with a result. Automatically unblocks dependent tasks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            task_id: {
+              type: "string",
+              description: "Task ID to complete"
+            },
+            result: {
+              type: "string",
+              description: "The result/output of this task"
+            }
+          },
+          required: ["task_id", "result"]
+        }
+      },
+      {
+        name: "cord_ask",
+        description: "Create an ask task \u2014 a question that needs an answer before dependent tasks can proceed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            question: {
+              type: "string",
+              description: "The question to ask"
+            },
+            options: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional list of answer choices"
+            },
+            parent_id: {
+              type: "string",
+              description: "Parent task ID"
+            }
+          },
+          required: ["question"]
+        }
+      },
+      {
+        name: "cord_tree",
+        description: "View the cord task tree with context scoping. Shows which tasks are active, blocked, or completed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            task_id: {
+              type: "string",
+              description: "Root task ID to show subtree (omit for full project tree)"
+            },
+            include_results: {
+              type: "boolean",
+              default: false,
+              description: "Include task results in output"
+            }
+          }
+        }
+      }
+    ];
+  }
   /**
    * Get tool definition by name
    */
@@ -780,6 +990,10 @@ class MCPToolDefinitions {
         return this.getEditTools();
       case "graphiti":
         return this.getGraphitiTools();
+      case "team":
+        return this.getTeamTools();
+      case "cord":
+        return this.getCordTools();
       default:
         return [];
     }

package/dist/src/integrations/ralph/context/context-budget-manager.js

@@ -115,14 +115,22 @@ class ContextBudgetManager {
     const reductionRatio = this.config.maxTokens / currentTokens;
     const phase = this.determinePhase(context.task.currentIteration);
     const adjustedWeights = this.getPhaseAdjustedWeights(phase);
-    return this.applyWeightedReduction(context, reductionRatio, adjustedWeights);
+    return this.applyWeightedReduction(
+      context,
+      reductionRatio,
+      adjustedWeights
+    );
   }
   /**
    * Priority-based allocation using fixed weights
    */
   priorityBasedAllocation(context, currentTokens) {
     const reductionRatio = this.config.maxTokens / currentTokens;
-    return this.applyWeightedReduction(context, reductionRatio, this.config.priorityWeights);
+    return this.applyWeightedReduction(
+      context,
+      reductionRatio,
+      this.config.priorityWeights
+    );
   }
   /**
    * Apply weighted reduction to context

package/dist/src/integrations/ralph/context/stackmemory-context-loader.js

@@ -46,7 +46,10 @@ class StackMemoryContextLoader {
       await sharedContextLayer.initialize();
       const session = await sessionManager.getOrCreateSession({});
       if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.frameManager = new FrameManager(
+          session.database,
+          session.projectId
+        );
         this.contextRetriever = new ContextRetriever(session.database);
       }
       logger.info("Context loader initialized successfully");
@@ -115,17 +118,25 @@ class StackMemoryContextLoader {
         totalTokens += sources[sources.length - 1].tokens;
       }
       const budgetedSources = this.budgetManager.allocateBudget({ sources });
-      const synthesizedContext = this.synthesizeContext(budgetedSources.sources);
+      const synthesizedContext = this.synthesizeContext(
+        budgetedSources.sources
+      );
       logger.info("Context loaded successfully", {
         totalSources: sources.length,
         totalTokens,
-        budgetedTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0)
+        budgetedTokens: budgetedSources.sources.reduce(
+          (sum, s) => sum + s.tokens,
+          0
+        )
       });
       return {
         context: synthesizedContext,
         sources: budgetedSources.sources,
         metadata: {
-          totalTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0),
+          totalTokens: budgetedSources.sources.reduce(
+            (sum, s) => sum + s.tokens,
+            0
+          ),
           sourcesCount: budgetedSources.sources.length,
           patterns: request.usePatterns ? patterns : [],
           similarTasks: request.useSimilarTasks ? similarTasks : []
@@ -144,16 +155,22 @@ class StackMemoryContextLoader {
       return [];
     }
     try {
-      const searchResults = await this.contextRetriever.search(taskDescription, {
-        maxResults: 10,
-        types: ["task", "subtask"],
-        timeFilter: {
-          days: this.config.lookbackDays
+      const searchResults = await this.contextRetriever.search(
+        taskDescription,
+        {
+          maxResults: 10,
+          types: ["task", "subtask"],
+          timeFilter: {
+            days: this.config.lookbackDays
+          }
         }
-      });
+      );
       const similarities = [];
       for (const result of searchResults) {
-        const similarity = this.calculateTaskSimilarity(taskDescription, result.content);
+        const similarity = this.calculateTaskSimilarity(
+          taskDescription,
+          result.content
+        );
         if (similarity >= this.config.similarityThreshold) {
           similarities.push({
             frameId: result.frameId,
@@ -184,7 +201,10 @@ class StackMemoryContextLoader {
       if (!context) return [];
       const relevantPatterns = [];
       for (const pattern of context.globalPatterns) {
-        const relevance = this.calculatePatternRelevance(taskDescription, pattern.pattern);
+        const relevance = this.calculatePatternRelevance(
+          taskDescription,
+          pattern.pattern
+        );
         if (relevance >= 0.5) {
           relevantPatterns.push({
             pattern: pattern.pattern,
@@ -197,7 +217,9 @@ class StackMemoryContextLoader {
           });
         }
       }
-      return relevantPatterns.sort((a, b) => b.relevance * Math.log(b.frequency + 1) - a.relevance * Math.log(a.frequency + 1)).slice(0, 8);
+      return relevantPatterns.sort(
+        (a, b) => b.relevance * Math.log(b.frequency + 1) - a.relevance * Math.log(a.frequency + 1)
+      ).slice(0, 8);
     } catch (error) {
       logger.error("Failed to extract patterns", error);
       return [];
@@ -270,12 +292,14 @@ class StackMemoryContextLoader {
     const contextParts = [];
     contextParts.push("Similar tasks from history:");
     for (const sim of similarities) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Task: ${sim.task}
 Outcome: ${sim.outcome}
 Similarity: ${Math.round(sim.similarity * 100)}%
 ${sim.outcome === "success" ? "\u2705 Successfully completed" : "\u274C Had issues"}
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -286,13 +310,15 @@ ${sim.outcome === "success" ? "\u2705 Successfully completed" : "\u274C Had issu
     const contextParts = [];
     contextParts.push("Relevant patterns from experience:");
     for (const pattern of patterns2) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Pattern: ${pattern.pattern}
 Type: ${pattern.type}
 Frequency: ${pattern.frequency} occurrences
 ${pattern.resolution ? `Resolution: ${pattern.resolution}` : ""}
 Relevance: ${Math.round(pattern.relevance * 100)}%
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -303,11 +329,13 @@ Relevance: ${Math.round(pattern.relevance * 100)}%
     const contextParts = [];
     contextParts.push("Recent successful decisions:");
     for (const decision of decisions) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Decision: ${decision.decision}
 Reasoning: ${decision.reasoning}
 Date: ${new Date(decision.timestamp).toLocaleDateString()}
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -322,11 +350,15 @@ Date: ${new Date(decision.timestamp).toLocaleDateString()}
     contextParts.push("Context from StackMemory:");
     const sortedSources = sources.sort((a, b) => b.weight - a.weight);
     for (const source of sortedSources) {
-      contextParts.push(`
---- ${source.type.replace("_", " ").toUpperCase()} ---`);
+      contextParts.push(
+        `
+--- ${source.type.replace("_", " ").toUpperCase()} ---`
+      );
       contextParts.push(source.content);
     }
-    contextParts.push("\nUse this context to inform your approach to the current task.");
+    contextParts.push(
+      "\nUse this context to inform your approach to the current task."
+    );
     return contextParts.join("\n");
   }
   /**

package/dist/src/integrations/ralph/learning/pattern-learner.js

@@ -25,7 +25,10 @@ class PatternLearner {
       await sharedContextLayer.initialize();
       const session = await sessionManager.getOrCreateSession({});
       if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.frameManager = new FrameManager(
+          session.database,
+          session.projectId
+        );
       }
       logger.info("Pattern learner initialized successfully");
     } catch (error) {
@@ -40,7 +43,9 @@ class PatternLearner {
     logger.info("Starting pattern learning from completed loops");
     try {
       const completedLoops = await this.getCompletedRalphLoops();
-      logger.info(`Found ${completedLoops.length} completed loops for analysis`);
+      logger.info(
+        `Found ${completedLoops.length} completed loops for analysis`
+      );
       if (completedLoops.length < this.config.minLoopCountForPattern) {
         logger.info("Not enough loops for pattern extraction");
         return [];
@@ -55,7 +60,9 @@ class PatternLearner {
       const taskPatterns = await this.extractTaskPatterns(completedLoops);
       patterns.push(...taskPatterns);
       await this.saveLearnedPatterns(patterns);
-      logger.info(`Learned ${patterns.length} patterns from ${completedLoops.length} loops`);
+      logger.info(
+        `Learned ${patterns.length} patterns from ${completedLoops.length} loops`
+      );
       return patterns;
     } catch (error) {
       logger.error("Failed to learn patterns", error);
@@ -97,7 +104,10 @@ class PatternLearner {
             analyses.push(analysis);
           }
         } catch (error) {
-          logger.warn(`Failed to analyze loop ${frame.frame_id}`, error);
+          logger.warn(
+            `Failed to analyze loop ${frame.frame_id}`,
+            error
+          );
         }
       }
       return analyses;
@@ -159,15 +169,21 @@ class PatternLearner {
       examples: successfulLoops.slice(0, 3).map((l) => l.task),
       metadata: {
         avgIterations,
-        minIterations: Math.min(...successfulLoops.map((l) => l.iterationCount)),
-        maxIterations: Math.max(...successfulLoops.map((l) => l.iterationCount))
+        minIterations: Math.min(
+          ...successfulLoops.map((l) => l.iterationCount)
+        ),
+        maxIterations: Math.max(
+          ...successfulLoops.map((l) => l.iterationCount)
+        )
       }
     });
     const criteriaPatterns = this.extractCriteriaPatterns(successfulLoops);
     patterns.push(...criteriaPatterns);
     const successFactors = this.extractSuccessFactors(successfulLoops);
     patterns.push(...successFactors);
-    return patterns.filter((p) => p.confidence >= this.config.confidenceThreshold);
+    return patterns.filter(
+      (p) => p.confidence >= this.config.confidenceThreshold
+    );
   }
   /**
    * Extract patterns from failed loops to avoid
@@ -191,7 +207,9 @@ class PatternLearner {
         metadata: { failureType: failure.type }
       });
     }
-    return patterns.filter((p) => p.confidence >= this.config.confidenceThreshold);
+    return patterns.filter(
+      (p) => p.confidence >= this.config.confidenceThreshold
+    );
   }
   /**
    * Extract iteration-specific patterns
@@ -223,7 +241,10 @@ class PatternLearner {
     const patterns = [];
     for (const [taskType, taskLoops] of Object.entries(taskGroups)) {
       if (taskLoops.length >= this.config.minLoopCountForPattern) {
-        const taskSpecificPatterns = await this.extractSpecializedPatterns(taskLoops, taskType);
+        const taskSpecificPatterns = await this.extractSpecializedPatterns(
+          taskLoops,
+          taskType
+        );
         patterns.push(...taskSpecificPatterns);
       }
     }
@@ -266,12 +287,15 @@ class PatternLearner {
    */
   classifyTaskType(task) {
     const taskLower = task.toLowerCase();
-    if (taskLower.includes("test") || taskLower.includes("unit")) return "testing";
+    if (taskLower.includes("test") || taskLower.includes("unit"))
+      return "testing";
     if (taskLower.includes("fix") || taskLower.includes("bug")) return "bugfix";
     if (taskLower.includes("refactor")) return "refactoring";
-    if (taskLower.includes("add") || taskLower.includes("implement")) return "feature";
+    if (taskLower.includes("add") || taskLower.includes("implement"))
+      return "feature";
     if (taskLower.includes("document")) return "documentation";
-    if (taskLower.includes("optimize") || taskLower.includes("performance")) return "optimization";
+    if (taskLower.includes("optimize") || taskLower.includes("performance"))
+      return "optimization";
     return "general";
   }
   /**
@@ -331,7 +355,10 @@ class PatternLearner {
   // Additional helper methods for pattern analysis
   analyzeIterations(iterations) {
     return {
-      avgDuration: iterations.length > 0 ? iterations.reduce((sum, i) => sum + (i.updated_at - i.created_at), 0) / iterations.length : 0,
+      avgDuration: iterations.length > 0 ? iterations.reduce(
+        (sum, i) => sum + (i.updated_at - i.created_at),
+        0
+      ) / iterations.length : 0,
       progressPattern: this.extractProgressPattern(iterations),
       commonIssues: this.extractCommonIssues(iterations)
     };
@@ -347,11 +374,16 @@ class PatternLearner {
     return iterations.filter((i) => i.outputs?.errors?.length > 0).flatMap((i) => i.outputs.errors).slice(0, 3);
   }
   extractCriteriaPatterns(loops) {
-    const criteriaWords = loops.flatMap((l) => l.criteria.toLowerCase().split(/\s+/));
-    const wordCounts = criteriaWords.reduce((acc, word) => {
-      acc[word] = (acc[word] || 0) + 1;
-      return acc;
-    }, {});
+    const criteriaWords = loops.flatMap(
+      (l) => l.criteria.toLowerCase().split(/\s+/)
+    );
+    const wordCounts = criteriaWords.reduce(
+      (acc, word) => {
+        acc[word] = (acc[word] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
     const commonCriteria = Object.entries(wordCounts).filter(([_, count]) => count >= this.config.minLoopCountForPattern).sort((a, b) => b[1] - a[1]).slice(0, 3);
     return commonCriteria.map(([word, count]) => ({
       id: `criteria-${word}`,
@@ -374,12 +406,15 @@ class PatternLearner {
     return [];
   }
   groupByTaskType(loops) {
-    return loops.reduce((acc, loop) => {
-      const type = loop.taskType;
-      if (!acc[type]) acc[type] = [];
-      acc[type].push(loop);
-      return acc;
-    }, {});
+    return loops.reduce(
+      (acc, loop) => {
+        const type = loop.taskType;
+        if (!acc[type]) acc[type] = [];
+        acc[type].push(loop);
+        return acc;
+      },
+      {}
+    );
   }
   summarizeSuccessPattern(loops) {
     const avgIterations = loops.reduce((sum, l) => sum + l.iterationCount, 0) / loops.length;