@sesamespace/hivemind 0.12.2 → 0.12.4

package/dist/{chunk-3F7M2BPR.js → chunk-TJBUZUVY.js}

@@ -1,10 +1,10 @@
 import {
   Watchdog
-} from "./chunk-ZAPHLG7V.js";
+} from "./chunk-FIHSUSBJ.js";
 import {
   defaultSentinelConfig,
   loadConfig
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-PGLO6WA5.js";
 
 // packages/cli/src/commands/watchdog.ts
 import { resolve } from "path";
@@ -76,4 +76,4 @@ Options:
 export {
   runWatchdogCommand
 };
-//# sourceMappingURL=chunk-3F7M2BPR.js.map
+//# sourceMappingURL=chunk-TJBUZUVY.js.map

package/dist/{chunk-SNW6Z2W4.js → chunk-XW4AQDZA.js}

@@ -1,6 +1,6 @@
 import {
   startPipeline
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-PGLO6WA5.js";
 
 // packages/cli/src/commands/start.ts
 import { resolve } from "path";
@@ -66,4 +66,4 @@ Options:
 export {
   runStartCommand
 };
-//# sourceMappingURL=chunk-SNW6Z2W4.js.map
+//# sourceMappingURL=chunk-XW4AQDZA.js.map

package/dist/{chunk-ZI4AN7GT.js → chunk-YDK3Z5IW.js}

@@ -1,7 +1,7 @@
 import {
   SesameClient,
   getClaudeCodeOAuthToken
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-PGLO6WA5.js";
 
 // packages/cli/src/commands/init.ts
 import { resolve, dirname } from "path";
@@ -436,4 +436,4 @@ Options:
 export {
   runInitCommand
 };
-//# sourceMappingURL=chunk-ZI4AN7GT.js.map
+//# sourceMappingURL=chunk-YDK3Z5IW.js.map

package/dist/commands/fleet.js

@@ -1,8 +1,8 @@
 import {
   runFleetCommand
-} from "../chunk-EJM4KCCY.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-J3WGHS5W.js";
+import "../chunk-FIHSUSBJ.js";
+import "../chunk-PGLO6WA5.js";
 import "../chunk-DGUM43GV.js";
 export {
   runFleetCommand

package/dist/commands/init.js

@@ -1,8 +1,8 @@
 import {
   runInitCommand
-} from "../chunk-ZI4AN7GT.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-YDK3Z5IW.js";
+import "../chunk-FIHSUSBJ.js";
+import "../chunk-PGLO6WA5.js";
 import "../chunk-DGUM43GV.js";
 export {
   runInitCommand

package/dist/commands/start.js

@@ -1,8 +1,8 @@
 import {
   runStartCommand
-} from "../chunk-SNW6Z2W4.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-XW4AQDZA.js";
+import "../chunk-FIHSUSBJ.js";
+import "../chunk-PGLO6WA5.js";
 import "../chunk-DGUM43GV.js";
 export {
   runStartCommand

package/dist/commands/watchdog.js

@@ -1,8 +1,8 @@
 import {
   runWatchdogCommand
-} from "../chunk-3F7M2BPR.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-TJBUZUVY.js";
+import "../chunk-FIHSUSBJ.js";
+import "../chunk-PGLO6WA5.js";
 import "../chunk-DGUM43GV.js";
 export {
   runWatchdogCommand

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   PrimaryMemorySync,
   Watchdog,
   WorkerMemorySync
-} from "./chunk-ZAPHLG7V.js";
+} from "./chunk-FIHSUSBJ.js";
 import {
   Agent,
   AutoDebugger,
@@ -34,7 +34,7 @@ import {
   setLogLevel,
   startPipeline,
   startWorker
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-PGLO6WA5.js";
 import "./chunk-DGUM43GV.js";
 export {
   Agent,

package/dist/main.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   runInitCommand
-} from "./chunk-ZI4AN7GT.js";
+} from "./chunk-YDK3Z5IW.js";
 import {
   runStartCommand
-} from "./chunk-SNW6Z2W4.js";
+} from "./chunk-XW4AQDZA.js";
 import {
   runFleetCommand
-} from "./chunk-EJM4KCCY.js";
+} from "./chunk-J3WGHS5W.js";
 import {
   runServiceCommand
 } from "./chunk-6QZDXOMW.js";
@@ -16,9 +16,9 @@ import {
 } from "./chunk-ICSJNKI6.js";
 import {
   runWatchdogCommand
-} from "./chunk-3F7M2BPR.js";
-import "./chunk-ZAPHLG7V.js";
-import "./chunk-R7RHYYOM.js";
+} from "./chunk-TJBUZUVY.js";
+import "./chunk-FIHSUSBJ.js";
+import "./chunk-PGLO6WA5.js";
 import "./chunk-DGUM43GV.js";
 
 // packages/cli/src/commands/session.ts

package/dist/start.js

@@ -3,7 +3,7 @@ import {
   loadConfig,
   startPipeline,
   startWorker
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-PGLO6WA5.js";
 import "./chunk-DGUM43GV.js";
 
 // packages/runtime/src/start.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sesamespace/hivemind",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "description": "Cognitive architecture for AI agents with multi-layered memory",
   "scripts": {
     "build": "tsup",

package/test/claude-integration.test.ts

@@ -0,0 +1,325 @@
+/**
+ * Test Suite for Claude Code Integration
+ * 
+ * Tests the bidirectional context bridge, memory storage,
+ * and real-time notification systems.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { ClaudeContextBridge } from "../packages/runtime/src/tools/context-bridge.js";
+import { ClaudeNotifier } from "../packages/runtime/src/tools/claude-notifier.js";
+import { MemoryClient } from "../packages/runtime/src/memory-client.js";
+import { Logger } from "../packages/runtime/src/logger.js";
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+describe("Claude Code Integration", () => {
+  let contextBridge: ClaudeContextBridge;
+  let memoryClient: MemoryClient;
+  let logger: Logger;
+  let workspaceDir: string;
+  let sessionLogPath: string;
+
+  beforeEach(async () => {
+    // Set up test environment
+    workspaceDir = "/tmp/test-workspace";
+    sessionLogPath = join(homedir(), ".claude", "session.log");
+    
+    // Create mock implementations
+    logger = {
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+      debug: jest.fn(),
+    } as any;
+
+    memoryClient = {
+      search: jest.fn().mockResolvedValue([]),
+      storeEpisode: jest.fn().mockResolvedValue({}),
+    } as any;
+
+    // Create context bridge
+    contextBridge = new ClaudeContextBridge({
+      workspaceDir,
+      memoryClient,
+      logger,
+    });
+    
+    await contextBridge.initialize();
+  });
+
+  afterEach(() => {
+    contextBridge.destroy();
+    // Clean up test files
+    if (existsSync(sessionLogPath)) {
+      unlinkSync(sessionLogPath);
+    }
+  });
+
+  describe("Context Preparation", () => {
+    it("should prepare context with all fields", async () => {
+      const context = {
+        goal: "Fix authentication bug",
+        requirements: ["Must support OAuth", "Handle token refresh"],
+        recentErrors: ["401 Unauthorized on /api/user"],
+        relevantPatterns: ["Use middleware for auth"],
+        workingFiles: ["src/auth.ts", "src/middleware.ts"],
+        knownConstraints: ["JWT tokens expire after 1 hour"],
+      };
+
+      await contextBridge.prepareContext(context);
+
+      const contextFile = join(workspaceDir, "CLAUDE_CONTEXT.md");
+      expect(existsSync(contextFile)).toBe(true);
+      
+      const content = require('fs').readFileSync(contextFile, 'utf-8');
+      expect(content).toContain("Fix authentication bug");
+      expect(content).toContain("Must support OAuth");
+      expect(content).toContain("401 Unauthorized");
+      expect(content).toContain("Use middleware for auth");
+      expect(content).toContain("src/auth.ts");
+      expect(content).toContain("JWT tokens expire after 1 hour");
+    });
+
+    it("should include memory search results", async () => {
+      // Mock memory search
+      (memoryClient.search as jest.Mock).mockResolvedValue([
+        { content: "Previous auth implementation used Passport.js" },
+        { content: "Refresh tokens stored in Redis" },
+      ]);
+
+      await contextBridge.prepareContext({ goal: "Implement authentication" });
+
+      expect(memoryClient.search).toHaveBeenCalledWith("Implement authentication", "global", 5);
+      
+      const contextFile = join(workspaceDir, "CLAUDE_CONTEXT.md");
+      const content = require('fs').readFileSync(contextFile, 'utf-8');
+      expect(content).toContain("Previous auth implementation used Passport.js");
+      expect(content).toContain("Refresh tokens stored in Redis");
+    });
+  });
+
+  describe("Session Log Monitoring", () => {
+    it("should detect and process DISCOVERY entries", (done) => {
+      contextBridge.on('insight', ({ type, content }) => {
+        expect(type).toBe('DISCOVERY');
+        expect(content).toBe('Found JWT validation in middleware');
+        done();
+      });
+
+      // Simulate Claude writing to session log
+      setTimeout(() => {
+        writeFileSync(sessionLogPath, "DISCOVERY: Found JWT validation in middleware\n", { flag: 'a' });
+      }, 100);
+    });
+
+    it("should detect and process NEED entries", (done) => {
+      contextBridge.on('context-request', (need) => {
+        expect(need).toBe('Database schema for users table');
+        done();
+      });
+
+      setTimeout(() => {
+        writeFileSync(sessionLogPath, "NEED: Database schema for users table\n", { flag: 'a' });
+      }, 100);
+    });
+
+    it("should store PATTERN entries in memory", (done) => {
+      contextBridge.on('insight', async ({ type }) => {
+        if (type === 'PATTERN') {
+          // Give it time to store
+          setTimeout(() => {
+            expect(memoryClient.storeEpisode).toHaveBeenCalledWith({
+              context_name: "claude-code-insights",
+              role: "system",
+              content: "PATTERN: Always validate JWT in middleware",
+              metadata: expect.objectContaining({
+                type: "PATTERN",
+                source: "claude-code",
+              }),
+            });
+            done();
+          }, 100);
+        }
+      });
+
+      setTimeout(() => {
+        writeFileSync(sessionLogPath, "PATTERN: Always validate JWT in middleware\n", { flag: 'a' });
+      }, 100);
+    });
+
+    it("should deduplicate identical patterns", async () => {
+      // Write the same pattern twice
+      writeFileSync(sessionLogPath, "PATTERN: Use async/await for DB calls\n");
+      await new Promise(resolve => setTimeout(resolve, 600));
+      writeFileSync(sessionLogPath, "PATTERN: Use async/await for DB calls\n", { flag: 'a' });
+      await new Promise(resolve => setTimeout(resolve, 600));
+
+      // Should only store once
+      expect(memoryClient.storeEpisode).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("Real-time Context Injection", () => {
+    it("should append context when Claude needs it", async () => {
+      // Mock memory search for additional context
+      (memoryClient.search as jest.Mock).mockResolvedValue([
+        { content: "Users table has columns: id, email, password_hash, created_at" },
+      ]);
+
+      // Prepare initial context
+      await contextBridge.prepareContext({ goal: "Fix user query" });
+
+      // Simulate Claude needing more info
+      writeFileSync(sessionLogPath, "NEED: Database schema\n", { flag: 'a' });
+
+      // Wait for processing
+      await new Promise(resolve => setTimeout(resolve, 600));
+
+      // Check that context was appended
+      const contextFile = join(workspaceDir, "CLAUDE_CONTEXT.md");
+      const content = require('fs').readFileSync(contextFile, 'utf-8');
+      expect(content).toContain("Additional Context");
+      expect(content).toContain("You asked about: Database schema");
+      expect(content).toContain("Users table has columns");
+    });
+  });
+
+  describe("Session Summary", () => {
+    it("should retrieve categorized insights", async () => {
+      // Mock memory with various insight types
+      (memoryClient.search as jest.Mock).mockResolvedValue([
+        { content: "DISCOVERY: Auth uses JWT with RS256" },
+        { content: "PATTERN: Validate tokens in middleware" },
+        { content: "ERROR: Missing JWKS endpoint" },
+        { content: "COMPLETE: Implemented token refresh" },
+        { content: "NEED: Public key for verification" },
+      ]);
+
+      const summary = await contextBridge.getSessionSummary();
+
+      expect(summary.discoveries).toContain("Auth uses JWT with RS256");
+      expect(summary.patterns).toContain("Validate tokens in middleware");
+      expect(summary.errors).toContain("Missing JWKS endpoint");
+      expect(summary.completions).toContain("Implemented token refresh");
+      expect(summary.needs).toContain("Public key for verification");
+    });
+  });
+
+  describe("Notification System", () => {
+    it("should emit urgent events for NEED requests", (done) => {
+      const notifier = new ClaudeNotifier({
+        logger,
+        contextBridge,
+        onNeed: async (need) => {
+          expect(need).toBe("API documentation");
+          done();
+        },
+      });
+
+      // Simulate Claude needing something
+      writeFileSync(sessionLogPath, "NEED: API documentation\n", { flag: 'a' });
+    });
+
+    it("should handle critical errors", (done) => {
+      const notifier = new ClaudeNotifier({
+        logger,
+        contextBridge,
+        onError: async (error) => {
+          expect(error).toBe("Cannot find module 'auth'");
+          done();
+        },
+      });
+
+      writeFileSync(sessionLogPath, "ERROR: Cannot find module 'auth'\n", { flag: 'a' });
+    });
+
+    it("should create urgent events", (done) => {
+      const notifier = new ClaudeNotifier({
+        logger,
+        contextBridge,
+      });
+
+      notifier.on('urgent-event', (event) => {
+        expect(event.type).toBe("immediate");
+        expect(event.text).toContain("[Claude Code Urgent]");
+        expect(event.text).toContain("Missing database credentials");
+        done();
+      });
+
+      notifier.createUrgentEvent("Missing database credentials", "test-channel");
+    });
+  });
+
+  describe("End-to-End Integration", () => {
+    it("should handle a complete Claude Code session", async () => {
+      // Prepare context
+      await contextBridge.prepareContext({
+        goal: "Implement user authentication",
+        requirements: ["Support JWT", "Handle refresh tokens"],
+      });
+
+      // Simulate Claude Code session
+      const sessionLog = [
+        "DISCOVERY: Found existing Passport.js setup",
+        "PATTERN: Use httpOnly cookies for refresh tokens",
+        "NEED: Redis connection details",
+        "ERROR: Redis connection failed",
+        "COMPLETE: Implemented JWT authentication",
+      ];
+
+      for (const line of sessionLog) {
+        writeFileSync(sessionLogPath, line + "\n", { flag: 'a' });
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+
+      // Wait for processing
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      // Verify memory storage
+      const storeEpisodeCalls = (memoryClient.storeEpisode as jest.Mock).mock.calls;
+      expect(storeEpisodeCalls.length).toBeGreaterThanOrEqual(2);
+      
+      // Verify discoveries and patterns were stored
+      const storedContent = storeEpisodeCalls.map(call => call[0].content);
+      expect(storedContent).toContain("DISCOVERY: Found existing Passport.js setup");
+      expect(storedContent).toContain("PATTERN: Use httpOnly cookies for refresh tokens");
+
+      // Get session summary
+      const summary = await contextBridge.getSessionSummary();
+      expect(summary.discoveries.length).toBeGreaterThan(0);
+      expect(summary.patterns.length).toBeGreaterThan(0);
+      expect(summary.errors.length).toBeGreaterThan(0);
+      expect(summary.completions.length).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe("Test Suite Requirements", () => {
+  it("should cover all critical functionality", () => {
+    const testCategories = [
+      "Context Preparation",
+      "Session Log Monitoring", 
+      "Real-time Context Injection",
+      "Session Summary",
+      "Notification System",
+      "End-to-End Integration"
+    ];
+
+    const criticalFeatures = [
+      "Prepare context with memory search",
+      "Monitor session log in real-time",
+      "Store discoveries and patterns",
+      "Deduplicate patterns",
+      "Inject context on NEED",
+      "Emit notifications for urgent needs",
+      "Generate session summaries",
+      "Handle complete sessions"
+    ];
+
+    // This test just documents what we're testing
+    expect(testCategories.length).toBeGreaterThanOrEqual(6);
+    expect(criticalFeatures.length).toBeGreaterThanOrEqual(8);
+  });
+});

package/.session-log.json

@@ -1,58 +0,0 @@
-{
-  "timestamp": "2026-03-10T00:00:00Z",
-  "summary": "Fixed stale PID reporting in `hivemind service status` by rewriting showStatus() to parse PIDs from `launchctl list` output instead of PID files. Added kickstart recovery for KeepAlive services (memory, watchdog). Removed hardcoded wrapper scripts from git tracking and added them to .gitignore since they are generated dynamically during `hivemind service install`.",
-  "decisions": [
-    {
-      "topic": "PID source",
-      "choice": "Parse PID from launchctl list output using regex",
-      "rationale": "launchctl is the authoritative source for launchd-managed process PIDs; PID files go stale when launchd restarts a crashed process",
-      "alternatives_considered": ["Keep PID file approach with periodic refresh", "Use ps/pgrep to find processes"]
-    },
-    {
-      "topic": "Stale service recovery",
-      "choice": "Auto-kickstart KeepAlive services (memory, watchdog) but not agent",
-      "rationale": "Agent is managed by watchdog, so kickstarting it from status would bypass watchdog's coordination",
-      "alternatives_considered": ["Kickstart all services", "Only report status without recovery"]
-    }
-  ],
-  "patterns": [
-    {
-      "pattern": "Wrapper scripts in bin/ are generated dynamically during `hivemind service install` with correct local paths — never commit them",
-      "scope": "project-wide"
-    }
-  ],
-  "gotchas": [
-    {
-      "issue": "Wrapper scripts had hardcoded paths from another developer's machine committed to git",
-      "resolution": "Removed from git tracking with `git rm --cached`, added bin/*-wrapper.sh to .gitignore",
-      "prevention": "The .gitignore entry will prevent future accidental commits"
-    }
-  ],
-  "files_changed": [
-    {
-      "path": "packages/cli/src/commands/service.ts",
-      "action": "modified",
-      "purpose": "Rewrote showStatus() to use launchctl as PID source with kickstart recovery"
-    },
-    {
-      "path": ".gitignore",
-      "action": "modified",
-      "purpose": "Added bin/*-wrapper.sh pattern"
-    },
-    {
-      "path": "bin/agent-wrapper.sh",
-      "action": "deleted",
-      "purpose": "Removed hardcoded wrapper script from git tracking"
-    },
-    {
-      "path": "bin/memory-wrapper.sh",
-      "action": "deleted",
-      "purpose": "Removed hardcoded wrapper script from git tracking"
-    },
-    {
-      "path": "bin/watchdog-wrapper.sh",
-      "action": "deleted",
-      "purpose": "Removed hardcoded wrapper script from git tracking"
-    }
-  ]
-}