@sesamespace/hivemind 0.8.9 → 0.8.11

package/MEMORY-ENHANCEMENT-PLAN.md

@@ -0,0 +1,211 @@
+# Memory Enhancement Plan — Automatic Context Management
+
+## Vision
+Transform Hivemind's memory system from passive storage to active context management. Background processes continuously organize, index, and surface relevant information without agent intervention.
+
+## Core Enhancements
+
+### 1. Code Context Tracking
+**Background Process:** `code-indexer`
+- Monitors file access patterns (which files the agent reads/writes)
+- Extracts key structures: functions, classes, interfaces, schemas
+- Maintains a "working set" of active code elements
+- Updates git commit context automatically
+- Indexes by: project, language, purpose, last-accessed
+
+**Data Structure:**
+```json
+{
+  "type": "code_context",
+  "project": "hivemind",
+  "file": "packages/runtime/src/agent.ts",
+  "elements": [
+    {
+      "name": "processMessage",
+      "type": "function",
+      "signature": "(msg: Message): Promise<Response>",
+      "purpose": "Core message processing loop",
+      "dependencies": ["memory-client", "router"]
+    }
+  ],
+  "last_accessed": "2024-01-15T10:30:00Z",
+  "access_count": 15,
+  "git_context": {
+    "branch": "feature/memory-enhancement",
+    "last_commit": "abc123",
+    "modified": true
+  }
+}
+```
+
+### 2. Web Research Digestion
+**Background Process:** `research-digester`
+- Monitors web fetch/browse operations
+- Extracts key concepts, APIs, solutions
+- Links research to active tasks/projects
+- Builds knowledge graph of related concepts
+- Identifies patterns across multiple sources
+
+**Data Structure:**
+```json
+{
+  "type": "research_insight",
+  "url": "https://docs.example.com/api",
+  "project": "sesame-integration",
+  "extracted": {
+    "key_concepts": ["OAuth flow", "webhook endpoints"],
+    "code_examples": ["const auth = await getToken()..."],
+    "warnings": ["Rate limit: 100 req/min"],
+    "related_to": ["auth-implementation", "rate-limiting"]
+  },
+  "timestamp": "2024-01-15T09:00:00Z",
+  "referenced_count": 3
+}
+```
+
+### 3. Task State Management
+**Background Process:** `task-tracker`
+- Monitors agent actions and maps to task progress
+- Detects task transitions (started, blocked, completed)
+- Tracks dependencies and blockers
+- Identifies patterns in task completion
+- Surfaces relevant context when returning to a task
+
+**Data Structure:**
+```json
+{
+  "type": "task_state",
+  "id": "implement-dashboard",
+  "project": "hivemind",
+  "status": "in_progress",
+  "progress": {
+    "completed": ["setup routes", "basic UI"],
+    "current": "implement request filtering",
+    "next": ["add export functionality", "write tests"]
+  },
+  "context": {
+    "key_files": ["src/dashboard/server.js", "src/dashboard/index.html"],
+    "recent_decisions": ["use server-sent events for real-time updates"],
+    "blockers": [],
+    "time_spent": "3.5 hours"
+  },
+  "last_updated": "2024-01-15T11:00:00Z"
+}
+```
+
+### 4. Tool Usage Patterns
+**Background Process:** `command-learner`
+- Tracks successful command sequences
+- Identifies common patterns and workflows
+- Builds "recipes" for common tasks
+- Learns from failures and corrections
+- Suggests optimizations
+
+**Data Structure:**
+```json
+{
+  "type": "tool_pattern",
+  "name": "github-push-workflow",
+  "triggers": ["git push", "push changes"],
+  "sequence": [
+    {"tool": "git_status", "check": "has_changes"},
+    {"tool": "git_add", "params": {"files": "."}}
+    {"tool": "git_commit", "params": {"message": "<generated>"}},
+    {"tool": "git_push", "params": {"remote": "origin"}}
+  ],
+  "success_rate": 0.95,
+  "last_used": "2024-01-15T10:00:00Z",
+  "variations": ["with-specific-files", "force-push"]
+}
+```
+
+### 5. Cross-Agent Awareness
+**Background Process:** `agent-sync`
+- Monitors Sesame channels for other agent activity
+- Extracts "public knowledge" from agent interactions
+- Tracks handoff points and collaboration patterns
+- Maintains agent capability registry
+- Identifies complementary skills
+
+**Data Structure:**
+```json
+{
+  "type": "agent_knowledge",
+  "agent": "bailey",
+  "capabilities": ["rust development", "system architecture"],
+  "current_focus": ["hivemind dashboard", "memory optimization"],
+  "collaboration_points": [
+    {
+      "task": "dashboard-implementation",
+      "status": "bailey-implementing",
+      "handoff_ready": "2024-01-16"
+    }
+  ],
+  "last_seen": "2024-01-15T11:30:00Z"
+}
+```
+
+## Implementation Architecture
+
+### Background Process Framework
+```typescript
+interface BackgroundProcess {
+  name: string;
+  interval: number; // milliseconds
+  async run(context: ProcessContext): Promise<void>;
+  async shouldRun(context: ProcessContext): Promise<boolean>;
+}
+
+class ProcessManager {
+  private processes: Map<string, BackgroundProcess>;
+  private memory: MemoryClient;
+  
+  async start() {
+    for (const [name, process] of this.processes) {
+      setInterval(async () => {
+        if (await process.shouldRun(this.context)) {
+          await process.run(this.context);
+        }
+      }, process.interval);
+    }
+  }
+}
+```
+
+### Memory Indexing Strategy
+1. **Write-through cache**: All observations written immediately to L2
+2. **Background indexing**: Processes run every 30s-5min depending on type
+3. **Smart batching**: Group related updates to minimize memory churn
+4. **Relevance scoring**: Continuously update scores based on access patterns
+5. **Compression**: Older entries compressed/summarized, recent kept detailed
+
+### Context Injection
+When building LLM prompts, the system will:
+1. Query active task state
+2. Include relevant code context (files, functions being worked on)
+3. Add recent research/documentation insights
+4. Include tool patterns for likely next actions
+5. Add cross-agent awareness if collaborating
+
+### Local Processing Power Usage
+- **Embedding generation**: Ollama with local models (no API calls)
+- **Pattern matching**: Rust-based processors for speed
+- **Index management**: LanceDB for vector operations
+- **File watching**: Native OS APIs for efficiency
+- **Git operations**: libgit2 bindings for speed
+
+## Benefits
+1. **Zero cognitive load**: Agents don't think about memory management
+2. **Rich context**: Every request includes highly relevant information
+3. **Learning system**: Gets better at predicting needed context over time
+4. **Collaborative**: Agents automatically aware of each other's work
+5. **Efficient**: Background processing keeps LLM calls focused
+
+## Next Steps
+1. Implement the background process framework in TypeScript
+2. Create the first processor: `code-indexer`
+3. Test with real agent workflows
+4. Add remaining processors incrementally
+5. Optimize based on dashboard metrics
+
+This system will make every Hivemind agent dramatically more capable without any changes to their prompts or behavior.

package/README.md

@@ -2,6 +2,8 @@
 
 Cognitive architecture for AI agents with multi-layered memory, context isolation, and multi-machine fleet distribution.
 
+_Updated by Caitlin 2026-03-01_
+
 ## Quick Start
 
 ### One-Command Install (recommended)

package/dist/{chunk-AC6ETJUC.js → chunk-A5LMEJIN.js}

@@ -6,7 +6,7 @@ import {
   PRIMARY_ROUTES,
   SesameClient2 as SesameClient,
   WORKER_ROUTES
-} from "./chunk-CMPDA2UR.js";
+} from "./chunk-OG6GPQDK.js";
 
 // packages/runtime/src/watchdog.ts
 import { execSync } from "child_process";
@@ -1048,4 +1048,4 @@ export {
   WorkerMemorySync,
   PrimaryMemorySync
 };
-//# sourceMappingURL=chunk-AC6ETJUC.js.map
+//# sourceMappingURL=chunk-A5LMEJIN.js.map

package/dist/{chunk-DDFWLDFN.js → chunk-F6EMICWP.js}

@@ -1,10 +1,10 @@
 import {
   Watchdog
-} from "./chunk-AC6ETJUC.js";
+} from "./chunk-A5LMEJIN.js";
 import {
   defaultSentinelConfig,
   loadConfig
-} from "./chunk-CMPDA2UR.js";
+} from "./chunk-OG6GPQDK.js";
 
 // packages/cli/src/commands/watchdog.ts
 import { resolve } from "path";
@@ -76,4 +76,4 @@ Options:
 export {
   runWatchdogCommand
 };
-//# sourceMappingURL=chunk-DDFWLDFN.js.map
+//# sourceMappingURL=chunk-F6EMICWP.js.map

package/dist/{chunk-CMPDA2UR.js → chunk-OG6GPQDK.js}

@@ -6611,6 +6611,17 @@ function startHealthServer(port) {
       res.end();
     }
   });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.warn(`[hivemind] Health port ${port} in use \u2014 retrying in 2s`);
+      setTimeout(() => {
+        server.close();
+        server.listen(port, "127.0.0.1");
+      }, 2e3);
+    } else {
+      console.error("[hivemind] Health server error:", err.message);
+    }
+  });
   server.listen(port, "127.0.0.1", () => {
     console.log(`[hivemind] Health endpoint listening on http://127.0.0.1:${port}${HEALTH_PATH}`);
   });
@@ -7400,4 +7411,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-CMPDA2UR.js.map
+//# sourceMappingURL=chunk-OG6GPQDK.js.map