@sesamespace/hivemind 0.12.1 → 0.12.3

package/.session-log.json

@@ -0,0 +1,58 @@
+{
+  "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"
+    }
+  ]
+}

package/dist/{chunk-6IAV6YAV.js → chunk-3SIWFXC7.js}

@@ -7,7 +7,7 @@ import {
   SesameClient2 as SesameClient,
   WORKER_ROUTES,
   createLogger
-} from "./chunk-7XXV5FKN.js";
+} from "./chunk-TQYOGZIN.js";
 
 // packages/runtime/src/watchdog.ts
 import { execSync } from "child_process";
@@ -1095,4 +1095,4 @@ export {
   WorkerMemorySync,
   PrimaryMemorySync
 };
-//# sourceMappingURL=chunk-6IAV6YAV.js.map
+//# sourceMappingURL=chunk-3SIWFXC7.js.map

package/dist/{chunk-AZ2ZKLN3.js → chunk-6W56VBXG.js}

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

package/dist/{chunk-DD7TRNOD.js → chunk-7HOPTFRU.js}

@@ -1,6 +1,6 @@
 import {
   startPipeline
-} from "./chunk-7XXV5FKN.js";
+} from "./chunk-TQYOGZIN.js";
 
 // packages/cli/src/commands/start.ts
 import { resolve } from "path";
@@ -66,4 +66,4 @@ Options:
 export {
   runStartCommand
 };
-//# sourceMappingURL=chunk-DD7TRNOD.js.map
+//# sourceMappingURL=chunk-7HOPTFRU.js.map

package/dist/{chunk-VAR7O4UE.js → chunk-EDSK2CG6.js}

@@ -1,10 +1,10 @@
 import {
   Watchdog
-} from "./chunk-6IAV6YAV.js";
+} from "./chunk-3SIWFXC7.js";
 import {
   defaultSentinelConfig,
   loadConfig
-} from "./chunk-7XXV5FKN.js";
+} from "./chunk-TQYOGZIN.js";
 
 // packages/cli/src/commands/watchdog.ts
 import { resolve } from "path";
@@ -76,4 +76,4 @@ Options:
 export {
   runWatchdogCommand
 };
-//# sourceMappingURL=chunk-VAR7O4UE.js.map
+//# sourceMappingURL=chunk-EDSK2CG6.js.map

package/dist/{chunk-Y2FWCQDX.js → chunk-KOSNIWPS.js}

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

package/dist/{chunk-7XXV5FKN.js → chunk-TQYOGZIN.js}

@@ -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, {
@@ -7893,7 +7905,6 @@ function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
             encoding: "utf-8",
             maxBuffer: 10 * 1024 * 1024,
             // 10MB
-            shell: "/bin/sh",
             env: {
               ...process.env,
               PATH: extendedPath
@@ -7909,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`;
@@ -7922,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);
+        }
       }
     }
   );
@@ -8594,7 +8638,7 @@ 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, existsSync as existsSync20, mkdirSync as mkdirSync15, openSync, readSync, closeSync } from "fs";
 import { join as join8 } from "path";
 import { homedir } from "os";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -8604,6 +8648,9 @@ var ClaudeContextBridge = class extends EventEmitter2 {
   logger;
   sessionLogPath;
   contextFilePath;
+  watchInterval = null;
+  lastLogSize = 0;
+  seenPatterns = /* @__PURE__ */ new Set();
   constructor(config) {
     super();
     this.workspaceDir = config.workspaceDir;
@@ -8722,25 +8769,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) ? __require("fs").statSync(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 = __require("fs").statSync(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
@@ -8770,28 +8825,125 @@ ${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 = __require("crypto").createHash("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({
-          context_name: "claude-code",
+          context_name: "claude-code-insights",
           role: "system",
-          content: `Claude Code ${type}: ${content}`
+          content: `${type}: ${content}`,
+          metadata: {
+            type,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            source: "claude-code"
+          }
         });
+        this.logger.info(`Stored ${type} in memory`, { content });
       } catch (err) {
         this.logger.warn("Failed to store Claude insight in memory", err);
       }
     }
-    if (type === "NEED") {
-      this.emit("context-request", content);
+    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 this.memoryClient.search(need, "global", 3);
+      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 = __require("fs").readFileSync(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", err);
+    }
+  }
+  /**
+   * Get session insights summary
+   */
+  async getSessionSummary() {
+    try {
+      const results = await this.memoryClient.search("", "claude-code-insights", 50);
+      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", 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) {
@@ -9696,4 +9848,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-7XXV5FKN.js.map
+//# sourceMappingURL=chunk-TQYOGZIN.js.map