@sesamespace/hivemind 0.11.5 → 0.12.0

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-NUMLGOLM.js → chunk-3EB4T7D4.js}

@@ -1,6 +1,6 @@
 import {
   startPipeline
-} from "./chunk-EKZ3IZU6.js";
+} from "./chunk-ZQ26EOYD.js";
 
 // packages/cli/src/commands/start.ts
 import { resolve } from "path";
@@ -66,4 +66,4 @@ Options:
 export {
   runStartCommand
 };
-//# sourceMappingURL=chunk-NUMLGOLM.js.map
+//# sourceMappingURL=chunk-3EB4T7D4.js.map

package/dist/{chunk-TTVGHFFT.js → chunk-6JB4OAB6.js}

@@ -1,10 +1,10 @@
 import {
   Watchdog
-} from "./chunk-MWQZTAYA.js";
+} from "./chunk-YJW6OOEJ.js";
 import {
   defaultSentinelConfig,
   loadConfig
-} from "./chunk-EKZ3IZU6.js";
+} from "./chunk-ZQ26EOYD.js";
 
 // packages/cli/src/commands/watchdog.ts
 import { resolve } from "path";
@@ -76,4 +76,4 @@ Options:
 export {
   runWatchdogCommand
 };
-//# sourceMappingURL=chunk-TTVGHFFT.js.map
+//# sourceMappingURL=chunk-6JB4OAB6.js.map

package/dist/{chunk-HQTD25CP.js → chunk-G5LF3BSN.js}

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

package/dist/{chunk-GD6XTDQQ.js → chunk-JP3ZHMPE.js}

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

package/dist/{chunk-MWQZTAYA.js → chunk-YJW6OOEJ.js}

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

package/dist/{chunk-EKZ3IZU6.js → chunk-ZQ26EOYD.js}

@@ -4225,12 +4225,12 @@ var LogWatcher = class extends BackgroundProcess {
   }
   savePositions() {
     try {
-      const { mkdirSync: mkdirSync15, writeFileSync: writeFileSync9 } = __require("fs");
-      const { dirname: dirname9 } = __require("path");
-      const dir = dirname9(this.positionsFile);
-      if (!existsSync7(dir)) mkdirSync15(dir, { recursive: true });
+      const { mkdirSync: mkdirSync16, writeFileSync: writeFileSync10 } = __require("fs");
+      const { dirname: dirname10 } = __require("path");
+      const dir = dirname10(this.positionsFile);
+      if (!existsSync7(dir)) mkdirSync16(dir, { recursive: true });
       const data = Object.fromEntries(this.tailPositions);
-      writeFileSync9(this.positionsFile, JSON.stringify(data));
+      writeFileSync10(this.positionsFile, JSON.stringify(data));
     } catch (err) {
       log2.warn("failed to save tail positions", {
         error: err.message
@@ -7809,7 +7809,7 @@ function truncate2(text) {
 import { execSync as execSync9 } from "child_process";
 import { resolve as resolve17 } from "path";
 var MAX_OUTPUT6 = 5e4;
-function registerCodingAgentTools(registry, workspaceDir) {
+function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
   registry.register(
     "coding_agent",
     "Spawn Claude Code CLI to perform a coding task. Use for writing code, debugging, refactoring, or any task that benefits from an AI coding assistant with full filesystem access. Requires the 'claude' CLI to be installed.",
@@ -7827,6 +7827,31 @@ function registerCodingAgentTools(registry, workspaceDir) {
         timeout: {
           type: "number",
           description: "Timeout in seconds. Default: 300"
+        },
+        requirements: {
+          type: "array",
+          items: { type: "string" },
+          description: "Key requirements or constraints for the task"
+        },
+        recentErrors: {
+          type: "array",
+          items: { type: "string" },
+          description: "Recent errors encountered that may be relevant"
+        },
+        relevantPatterns: {
+          type: "array",
+          items: { type: "string" },
+          description: "Known patterns or approaches that might help"
+        },
+        workingFiles: {
+          type: "array",
+          items: { type: "string" },
+          description: "Files currently being worked on"
+        },
+        knownConstraints: {
+          type: "array",
+          items: { type: "string" },
+          description: "Known constraints or limitations to consider"
         }
       },
       required: ["task"]
@@ -7835,8 +7860,24 @@ function registerCodingAgentTools(registry, workspaceDir) {
       const task = params.task;
       const timeoutSeconds = params.timeout || 300;
       const cwd = params.workdir ? resolve17(workspaceDir, params.workdir) : workspaceDir;
-      const homedir = process.env.HOME || "/root";
-      const extendedPath = `${homedir}/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}`;
+      if (contextBridge) {
+        const context = {
+          goal: task,
+          // Extract additional context from params if provided
+          requirements: params.requirements || [],
+          recentErrors: params.recentErrors || [],
+          relevantPatterns: params.relevantPatterns || [],
+          workingFiles: params.workingFiles || [],
+          knownConstraints: params.knownConstraints || []
+        };
+        try {
+          await contextBridge.prepareContext(context);
+        } catch (err) {
+          console.warn("Failed to prepare context for Claude Code:", err);
+        }
+      }
+      const homedir2 = process.env.HOME || "/root";
+      const extendedPath = `${homedir2}/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}`;
       try {
         execSync9("which claude", { stdio: "ignore", env: { ...process.env, PATH: extendedPath } });
       } catch {
@@ -8328,7 +8369,7 @@ function registerAllTools(hivemindHome, config) {
   registerWatchTools(registry, workspaceDir, dataDir);
   registerMacOSTools(registry, workspaceDir);
   registerDataTools(registry, workspaceDir);
-  registerCodingAgentTools(registry, workspaceDir);
+  registerCodingAgentTools(registry, workspaceDir, config?.contextBridge);
   registerLearnTools(registry, {
     llmConfig: config?.llmConfig,
     memoryDaemonUrl: config?.memoryDaemonUrl || "http://localhost:3434",
@@ -8537,13 +8578,224 @@ Path: ${skillDir}`;
 }
 
 // packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
-import { resolve as resolve20, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
+import { resolve as resolve20, dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+
+// packages/runtime/src/tools/context-bridge.ts
+import { writeFileSync as writeFileSync8, readFileSync as readFileSync15, existsSync as existsSync20, mkdirSync as mkdirSync15, watchFile, unwatchFile } from "fs";
+import { join as join8, dirname as dirname8 } from "path";
+import { homedir } from "os";
+import { EventEmitter as EventEmitter2 } from "events";
+var ClaudeContextBridge = class extends EventEmitter2 {
+  workspaceDir;
+  memoryClient;
+  logger;
+  sessionLogPath;
+  contextFilePath;
+  claudeSettingsPath;
+  logWatcher;
+  constructor(config) {
+    super();
+    this.workspaceDir = config.workspaceDir;
+    this.memoryClient = config.memoryClient;
+    this.logger = config.logger;
+    this.sessionLogPath = join8(homedir(), ".claude", "session.log");
+    this.contextFilePath = join8(this.workspaceDir, "CLAUDE_CONTEXT.md");
+    this.claudeSettingsPath = join8(homedir(), ".claude", "settings.json");
+  }
+  /**
+   * Initialize the context bridge
+   */
+  async initialize() {
+    const claudeDir = dirname8(this.claudeSettingsPath);
+    if (!existsSync20(claudeDir)) {
+      mkdirSync15(claudeDir, { recursive: true });
+    }
+    await this.setupClaudeSettings();
+    this.startLogMonitoring();
+    this.logger.info("Claude context bridge initialized");
+  }
+  /**
+   * Configure Claude Code to report insights
+   */
+  async setupClaudeSettings() {
+    const customInstructions = `# Hivemind Context Bridge
+
+When working on tasks, please report significant findings by writing to the session log:
+
+- When you discover architecture/patterns: echo "DISCOVERY: [details]" >> ~/.claude/session.log
+- When you need more context: echo "NEED: [what you need]" >> ~/.claude/session.log  
+- When you complete major steps: echo "COMPLETE: [what you did]" >> ~/.claude/session.log
+- When you find reusable solutions: echo "PATTERN: [approach]" >> ~/.claude/session.log
+- When you encounter errors: echo "ERROR: [error details]" >> ~/.claude/session.log
+
+Always check ~/hivemind/workspace/CLAUDE_CONTEXT.md for task context and requirements.`;
+    const settings = {
+      customInstructions,
+      alwaysIncludeFiles: [
+        this.contextFilePath,
+        join8(this.workspaceDir, "ARCHITECTURE.md"),
+        join8(this.workspaceDir, "TOOLS.md")
+      ],
+      // Enable verbose logging for better insights
+      verboseLogging: true
+    };
+    writeFileSync8(this.claudeSettingsPath, JSON.stringify(settings, null, 2));
+    this.logger.info("Claude settings configured for context bridge");
+  }
+  /**
+   * Prepare context for a Claude Code session
+   */
+  async prepareContext(context) {
+    let content = `# Claude Code Context
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Current Goal
+${context.goal}
+`;
+    if (context.requirements?.length) {
+      content += `
+## Requirements
+${context.requirements.map((r) => `- ${r}`).join("\n")}
+`;
+    }
+    if (context.recentErrors?.length) {
+      content += `
+## Recent Errors
+\`\`\`
+${context.recentErrors.join("\n")}
+\`\`\`
+`;
+    }
+    if (context.relevantPatterns?.length) {
+      content += `
+## Known Patterns
+${context.relevantPatterns.map((p) => `- ${p}`).join("\n")}
+`;
+    }
+    if (context.workingFiles?.length) {
+      content += `
+## Working Files
+${context.workingFiles.map((f) => `- ${f}`).join("\n")}
+`;
+    }
+    if (context.knownConstraints?.length) {
+      content += `
+## Known Constraints
+${context.knownConstraints.map((c) => `- ${c}`).join("\n")}
+`;
+    }
+    try {
+      const memories = await this.getRelevantMemories(context.goal);
+      if (memories.length > 0) {
+        content += `
+## Relevant Knowledge
+${memories.join("\n\n")}
+`;
+      }
+    } catch (err) {
+      this.logger.warn("Failed to fetch memories for context", err);
+    }
+    writeFileSync8(this.contextFilePath, content);
+    this.logger.info("Context prepared for Claude Code", { goal: context.goal });
+  }
+  /**
+   * Fetch relevant memories for the task
+   */
+  async getRelevantMemories(goal) {
+    try {
+      const results = await this.memoryClient.search(goal, "global", 5);
+      return results.map((r) => `- ${r.content}`);
+    } catch (err) {
+      return [];
+    }
+  }
+  /**
+   * Start monitoring Claude's session log for insights
+   */
+  startLogMonitoring() {
+    if (!existsSync20(this.sessionLogPath)) {
+      writeFileSync8(this.sessionLogPath, "");
+    }
+    let lastSize = 0;
+    watchFile(this.sessionLogPath, { interval: 1e3 }, (curr, prev) => {
+      if (curr.size > lastSize) {
+        const content = readFileSync15(this.sessionLogPath, "utf-8");
+        const newContent = content.slice(lastSize);
+        lastSize = curr.size;
+        const lines = newContent.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          this.processLogLine(line);
+        }
+      }
+    });
+    this.logger.info("Started monitoring Claude session log");
+  }
+  /**
+   * Process a line from Claude's session log
+   */
+  processLogLine(line) {
+    const patterns = {
+      DISCOVERY: /^DISCOVERY:\s*(.+)$/,
+      NEED: /^NEED:\s*(.+)$/,
+      COMPLETE: /^COMPLETE:\s*(.+)$/,
+      PATTERN: /^PATTERN:\s*(.+)$/,
+      ERROR: /^ERROR:\s*(.+)$/
+    };
+    for (const [type, pattern] of Object.entries(patterns)) {
+      const match = line.match(pattern);
+      if (match) {
+        const content = match[1];
+        this.handleInsight(type, content);
+        break;
+      }
+    }
+  }
+  /**
+   * Handle an insight from Claude Code
+   */
+  async handleInsight(type, content) {
+    this.logger.info(`Claude insight: ${type}`, { content });
+    this.emit("insight", { type, content });
+    if (["DISCOVERY", "PATTERN"].includes(type)) {
+      try {
+        await this.memoryClient.store({
+          content: `Claude Code ${type}: ${content}`,
+          metadata: {
+            source: "claude-code",
+            type: type.toLowerCase(),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+      } catch (err) {
+        this.logger.warn("Failed to store Claude insight in memory", err);
+      }
+    }
+    if (type === "NEED") {
+      this.emit("context-request", content);
+    }
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.sessionLogPath && existsSync20(this.sessionLogPath)) {
+      unwatchFile(this.sessionLogPath);
+    }
+  }
+};
+async function createContextBridge(config) {
+  const bridge = new ClaudeContextBridge(config);
+  await bridge.initialize();
+  return bridge;
+}
+
+// packages/runtime/src/pipeline.ts
 var PACKAGE_VERSION = "unknown";
 try {
-  const __dirname2 = dirname8(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync15(resolve20(__dirname2, "../package.json"), "utf-8"));
+  const __dirname2 = dirname9(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync16(resolve20(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -8585,7 +8837,7 @@ function startHealthServer(port) {
   return server;
 }
 function writePidFile(path) {
-  writeFileSync8(path, String(process.pid));
+  writeFileSync9(path, String(process.pid));
   console.log(`[hivemind] PID file written: ${path}`);
 }
 function cleanupPidFile(path) {
@@ -8626,20 +8878,34 @@ async function startPipeline(configPath) {
       console.log("[hivemind] Global context already exists in memory daemon");
     }
   }
-  const requestLogger = new RequestLogger(resolve20(dirname8(configPath), "data", "dashboard.db"));
+  const requestLogger = new RequestLogger(resolve20(dirname9(configPath), "data", "dashboard.db"));
   const agent = new Agent(config);
   startDashboardServer(requestLogger, config.memory, () => agent.getConversationHistories());
   agent.setRequestLogger(requestLogger);
   const hivemindHome = process.env.HIVEMIND_HOME || resolve20(process.env.HOME || "/root", "hivemind");
+  const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
+  let contextBridge;
+  if (memoryConnected) {
+    try {
+      contextBridge = await createContextBridge({
+        workspaceDir,
+        memoryClient: memory,
+        logger: createLogger("claude-bridge")
+      });
+      console.log("[hivemind] Claude context bridge initialized");
+    } catch (err) {
+      console.warn("[hivemind] Failed to create Claude context bridge:", err);
+    }
+  }
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
     braveApiKey: process.env.BRAVE_API_KEY,
     memoryDaemonUrl: config.memory.daemon_url,
     configPath,
-    llmConfig: config.llm
+    llmConfig: config.llm,
+    contextBridge
   });
-  const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
   const skillsEngine = new SkillsEngine(workspaceDir, toolRegistry);
   await skillsEngine.loadAll();
   registerSkillsTools(toolRegistry, skillsEngine, workspaceDir);
@@ -8889,7 +9155,7 @@ async function runSpawnTask(config, configPath) {
     const result = response.content;
     console.log(`[spawn] Task completed (context: ${response.context})`);
     if (spawnDir) {
-      writeFileSync8(resolve20(spawnDir, "result.txt"), result);
+      writeFileSync9(resolve20(spawnDir, "result.txt"), result);
     }
     if (channelId && config.sesame.api_key) {
       try {
@@ -8906,7 +9172,7 @@ async function runSpawnTask(config, configPath) {
     const errorMsg = `[SPAWN ERROR] ${err.message}`;
     console.error(`[spawn] ${errorMsg}`);
     if (spawnDir) {
-      writeFileSync8(resolve20(spawnDir, "result.txt"), errorMsg);
+      writeFileSync9(resolve20(spawnDir, "result.txt"), errorMsg);
     }
     process.exitCode = 1;
   }
@@ -9418,4 +9684,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-EKZ3IZU6.js.map
+//# sourceMappingURL=chunk-ZQ26EOYD.js.map