@sesamespace/hivemind 0.12.2 → 0.12.4

package/dist/{chunk-ZAPHLG7V.js → chunk-FIHSUSBJ.js}

@@ -7,7 +7,7 @@ import {
   SesameClient2 as SesameClient,
   WORKER_ROUTES,
   createLogger
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-PGLO6WA5.js";
 
 // packages/runtime/src/watchdog.ts
 import { execSync } from "child_process";
@@ -1095,4 +1095,4 @@ export {
   WorkerMemorySync,
   PrimaryMemorySync
 };
-//# sourceMappingURL=chunk-ZAPHLG7V.js.map
+//# sourceMappingURL=chunk-FIHSUSBJ.js.map

package/dist/{chunk-EJM4KCCY.js → chunk-J3WGHS5W.js}

@@ -1,6 +1,6 @@
 import {
   FleetManager
-} from "./chunk-ZAPHLG7V.js";
+} from "./chunk-FIHSUSBJ.js";
 
 // packages/cli/src/commands/fleet.ts
 function formatUptime(seconds) {
@@ -183,4 +183,4 @@ Commands:
 export {
   runFleetCommand
 };
-//# sourceMappingURL=chunk-EJM4KCCY.js.map
+//# sourceMappingURL=chunk-J3WGHS5W.js.map

package/dist/{chunk-R7RHYYOM.js → chunk-PGLO6WA5.js}

@@ -5178,7 +5178,7 @@ function registerFileTools(registry, workspaceDir) {
       required: []
     },
     async (params) => {
-      const { readdirSync: readdirSync5, statSync: statSync4 } = await import("fs");
+      const { readdirSync: readdirSync5, statSync: statSync5 } = await import("fs");
       const dirPath = params.path ? resolvePath(workspaceDir, params.path) : workspaceDir;
       if (!existsSync10(dirPath)) {
         return `Error: Directory not found: ${dirPath}`;
@@ -5189,7 +5189,7 @@ function registerFileTools(registry, workspaceDir) {
         for (const entry of entries) {
           if (entry.startsWith(".")) continue;
           try {
-            const stat = statSync4(resolve9(dirPath, entry));
+            const stat = statSync5(resolve9(dirPath, entry));
             results.push(stat.isDirectory() ? `${entry}/` : entry);
           } catch {
             results.push(entry);
@@ -7885,6 +7885,18 @@ function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
       }
       const escapedTask = task.replace(/'/g, "'\\''");
       const command = `claude --dangerously-skip-permissions -p '${escapedTask}'`;
+      let needHandler;
+      let errorHandler;
+      if (contextBridge) {
+        needHandler = (need) => {
+          console.log(`[Claude needs context]: ${need}`);
+        };
+        contextBridge.on("context-request", needHandler);
+        errorHandler = (error) => {
+          console.log(`[Claude encountered error]: ${error}`);
+        };
+        contextBridge.on("error-encountered", errorHandler);
+      }
       try {
         const output = await new Promise((resolve21, reject) => {
           const child = exec2(command, {
@@ -7908,9 +7920,35 @@ function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
           });
           child.stdin?.end();
         });
+        let summaryText = "";
+        if (contextBridge) {
+          try {
+            const summary = await contextBridge.getSessionSummary();
+            if (summary.discoveries.length > 0) {
+              summaryText += `
+
+## Discoveries Made:
+${summary.discoveries.map((d) => `- ${d}`).join("\n")}`;
+            }
+            if (summary.patterns.length > 0) {
+              summaryText += `
+
+## Patterns Found:
+${summary.patterns.map((p) => `- ${p}`).join("\n")}`;
+            }
+            if (summary.errors.length > 0) {
+              summaryText += `
+
+## Errors Encountered:
+${summary.errors.map((e) => `- ${e}`).join("\n")}`;
+            }
+          } catch (err) {
+            console.warn("Failed to get session summary:", err);
+          }
+        }
         const trimmed = output.length > MAX_OUTPUT6 ? output.slice(0, MAX_OUTPUT6) + `
 ... (truncated, ${output.length} total chars)` : output;
-        return trimmed || "(no output)";
+        return (trimmed || "(no output)") + summaryText;
       } catch (err) {
         if (err.killed) {
           return `Error: Claude Code timed out after ${timeoutSeconds}s`;
@@ -7921,6 +7959,13 @@ function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
         const code = err.status ?? "unknown";
         return `Claude Code failed (exit code ${code}):
 ${output || err.message}`;
+      } finally {
+        if (contextBridge && needHandler) {
+          contextBridge.off("context-request", needHandler);
+        }
+        if (contextBridge && errorHandler) {
+          contextBridge.off("error-encountered", errorHandler);
+        }
       }
     }
   );
@@ -8588,12 +8633,13 @@ Path: ${skillDir}`;
 }
 
 // packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
 import { resolve as resolve20, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // packages/runtime/src/tools/context-bridge.ts
-import { writeFileSync as writeFileSync8, existsSync as existsSync20, mkdirSync as mkdirSync15, watchFile, unwatchFile, openSync, readSync, closeSync } from "fs";
+import { writeFileSync as writeFileSync8, readFileSync as readFileSync15, statSync as statSync4, existsSync as existsSync20, mkdirSync as mkdirSync15, openSync, readSync, closeSync } from "fs";
+import { createHash as createHash2 } from "crypto";
 import { join as join8 } from "path";
 import { homedir } from "os";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -8603,6 +8649,9 @@ var ClaudeContextBridge = class extends EventEmitter2 {
   logger;
   sessionLogPath;
   contextFilePath;
+  watchInterval = null;
+  lastLogSize = 0;
+  seenPatterns = /* @__PURE__ */ new Set();
   constructor(config) {
     super();
     this.workspaceDir = config.workspaceDir;
@@ -8693,7 +8742,7 @@ ${memories.join("\n\n")}
 `;
       }
     } catch (err) {
-      this.logger.warn("Failed to fetch memories for context", err);
+      this.logger.warn("Failed to fetch memories for context", { error: String(err) });
     }
     writeFileSync8(this.contextFilePath, content);
     this.logger.info("Context prepared for Claude Code", { goal: context.goal });
@@ -8721,25 +8770,33 @@ ${memories.join("\n\n")}
     if (!existsSync20(this.sessionLogPath)) {
       writeFileSync8(this.sessionLogPath, "");
     }
-    let lastSize = 0;
-    watchFile(this.sessionLogPath, { interval: 2e3 }, (curr) => {
-      if (curr.size > lastSize) {
-        try {
-          const fd = openSync(this.sessionLogPath, "r");
-          const buf = Buffer.alloc(curr.size - lastSize);
-          readSync(fd, buf, 0, buf.length, lastSize);
-          closeSync(fd);
-          lastSize = curr.size;
-          const lines = buf.toString("utf-8").split("\n").filter((l) => l.trim());
-          for (const line of lines) {
-            this.processLogLine(line);
-          }
-        } catch (err) {
-          this.logger.warn("Failed to read session log", { error: String(err) });
+    const stats = existsSync20(this.sessionLogPath) ? statSync4(this.sessionLogPath) : { size: 0 };
+    this.lastLogSize = stats.size;
+    this.watchInterval = setInterval(() => {
+      this.checkForLogUpdates();
+    }, 500);
+    this.logger.info("Started real-time monitoring of Claude session log");
+  }
+  /**
+   * Check for new log entries
+   */
+  checkForLogUpdates() {
+    try {
+      const stats = statSync4(this.sessionLogPath);
+      if (stats.size > this.lastLogSize) {
+        const fd = openSync(this.sessionLogPath, "r");
+        const buf = Buffer.alloc(stats.size - this.lastLogSize);
+        readSync(fd, buf, 0, buf.length, this.lastLogSize);
+        closeSync(fd);
+        this.lastLogSize = stats.size;
+        const lines = buf.toString("utf-8").split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          this.processLogLine(line);
         }
       }
-    });
-    this.logger.info("Started monitoring Claude session log");
+    } catch (err) {
+      this.logger.warn("Failed to check session log", { error: String(err) });
+    }
   }
   /**
    * Process a line from Claude's session log
@@ -8769,6 +8826,14 @@ ${memories.join("\n\n")}
   async handleInsight(type, content) {
     this.logger.info(`Claude insight: ${type}`, { content });
     this.emit("insight", { type, content });
+    if (type === "PATTERN") {
+      const patternHash = createHash2("md5").update(content).digest("hex");
+      if (this.seenPatterns.has(patternHash)) {
+        this.logger.debug("Skipping duplicate pattern", { content });
+        return;
+      }
+      this.seenPatterns.add(patternHash);
+    }
     if (["DISCOVERY", "PATTERN"].includes(type)) {
       try {
         await this.memoryClient.storeEpisode({
@@ -8776,21 +8841,115 @@ ${memories.join("\n\n")}
           role: "system",
           content: `Claude Code ${type}: ${content}`
         });
+        this.logger.info(`Stored ${type} in memory`, { content });
       } catch (err) {
-        this.logger.warn("Failed to store Claude insight in memory", err);
+        this.logger.warn("Failed to store Claude insight in memory", { error: String(err) });
+      }
+    }
+    switch (type) {
+      case "NEED":
+        this.emit("context-request", content);
+        await this.tryProvideContext(content);
+        break;
+      case "ERROR":
+        this.emit("error-encountered", content);
+        break;
+      case "COMPLETE":
+        this.emit("task-complete", content);
+        break;
+    }
+  }
+  /**
+   * Try to provide additional context when Claude needs it
+   */
+  async tryProvideContext(need) {
+    try {
+      const results = await Promise.race([
+        this.memoryClient.search(need, "global", 3),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Memory search timeout")), 3e3)
+        )
+      ]);
+      if (results.length > 0) {
+        let additionalContext = `
+
+## Additional Context (Requested: ${(/* @__PURE__ */ new Date()).toISOString()})
+`;
+        additionalContext += `### You asked about: ${need}
+
+`;
+        additionalContext += results.map((r) => `- ${r.content}`).join("\n");
+        const currentContext = existsSync20(this.contextFilePath) ? readFileSync15(this.contextFilePath, "utf-8") : "";
+        writeFileSync8(this.contextFilePath, currentContext + additionalContext);
+        this.logger.info("Provided additional context to Claude", { need });
       }
+    } catch (err) {
+      this.logger.warn("Failed to provide additional context", { error: String(err) });
     }
-    if (type === "NEED") {
-      this.emit("context-request", content);
+  }
+  /**
+   * Get session insights summary
+   */
+  async getSessionSummary() {
+    try {
+      const results = await Promise.race([
+        this.memoryClient.search("", "claude-code-insights", 50),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Memory search timeout")), 3e3)
+        )
+      ]);
+      const summary = {
+        discoveries: [],
+        patterns: [],
+        needs: [],
+        errors: [],
+        completions: []
+      };
+      for (const result of results) {
+        const match = result.content.match(/^(DISCOVERY|PATTERN|NEED|ERROR|COMPLETE):\s*(.+)$/);
+        if (match) {
+          const [, type, content] = match;
+          switch (type) {
+            case "DISCOVERY":
+              summary.discoveries.push(content);
+              break;
+            case "PATTERN":
+              summary.patterns.push(content);
+              break;
+            case "NEED":
+              summary.needs.push(content);
+              break;
+            case "ERROR":
+              summary.errors.push(content);
+              break;
+            case "COMPLETE":
+              summary.completions.push(content);
+              break;
+          }
+        }
+      }
+      return summary;
+    } catch (err) {
+      this.logger.warn("Failed to get session summary", { error: String(err) });
+      return {
+        discoveries: [],
+        patterns: [],
+        needs: [],
+        errors: [],
+        completions: []
+      };
     }
   }
   /**
    * Clean up resources
    */
   destroy() {
-    if (this.sessionLogPath && existsSync20(this.sessionLogPath)) {
-      unwatchFile(this.sessionLogPath);
+    if (this.watchInterval) {
+      clearInterval(this.watchInterval);
+      this.watchInterval = null;
     }
+    this.seenPatterns.clear();
+    this.removeAllListeners();
   }
 };
 async function createContextBridge(config) {
@@ -8803,7 +8962,7 @@ async function createContextBridge(config) {
 var PACKAGE_VERSION = "unknown";
 try {
   const __dirname2 = dirname8(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync15(resolve20(__dirname2, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync16(resolve20(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -9695,4 +9854,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-R7RHYYOM.js.map
+//# sourceMappingURL=chunk-PGLO6WA5.js.map