@sesamespace/hivemind 0.11.4 → 0.12.0

package/dist/{chunk-ZA4NWNS6.js → chunk-3EB4T7D4.js}

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

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

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

package/dist/{chunk-4C6B2AMB.js → chunk-G5LF3BSN.js}

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

package/dist/{chunk-4YXOQGQC.js → chunk-JP3ZHMPE.js}

@@ -1,7 +1,7 @@
 import {
   SesameClient,
   getClaudeCodeOAuthToken
-} from "./chunk-OB6OXLPC.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-4YXOQGQC.js.map
+//# sourceMappingURL=chunk-JP3ZHMPE.js.map

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

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

package/dist/{chunk-OB6OXLPC.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
@@ -5335,15 +5335,12 @@ function registerMemoryTools(registry, daemonUrl) {
       const context = params.context || "global";
       const topK = params.top_k || 10;
       try {
-        const resp = await fetch(`${daemonUrl}/api/search`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ query, context_name: context, top_k: topK })
-        });
+        const searchParams = new URLSearchParams({ q: query, context, limit: String(topK) });
+        const resp = await fetch(`${daemonUrl}/search?${searchParams}`);
         if (!resp.ok) return `Memory search failed: ${resp.status}`;
         const data = await resp.json();
-        if (!data.results?.length) return `No memories found for "${query}" in context "${context}".`;
-        return data.results.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.context_name}] [${r.role}] ${r.content.slice(0, 200)}`).join("\n");
+        if (!data.episodes?.length) return `No memories found for "${query}" in context "${context}".`;
+        return data.episodes.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.context_name}] [${r.role}] ${r.content.slice(0, 200)}`).join("\n");
       } catch (err) {
         return `Memory daemon unreachable: ${err.message}`;
       }
@@ -5361,12 +5358,12 @@ function registerMemoryTools(registry, daemonUrl) {
       try {
         const healthResp = await fetch(`${daemonUrl}/health`);
         const health = healthResp.ok ? await healthResp.json() : { status: "unreachable" };
-        const ctxResp = await fetch(`${daemonUrl}/api/contexts`);
+        const ctxResp = await fetch(`${daemonUrl}/contexts`);
         const contexts = ctxResp.ok ? (await ctxResp.json()).contexts : [];
         const l3Counts = {};
         for (const ctx of contexts) {
           try {
-            const l3Resp = await fetch(`${daemonUrl}/api/l3/${encodeURIComponent(ctx.name)}`);
+            const l3Resp = await fetch(`${daemonUrl}/promotion/l3?context=${encodeURIComponent(ctx.name)}`);
             if (l3Resp.ok) {
               const l3Data = await l3Resp.json();
               l3Counts[ctx.name] = l3Data.entries?.length ?? 0;
@@ -5411,7 +5408,7 @@ Contexts:
     async (params) => {
       const context = params.context || "global";
       try {
-        const resp = await fetch(`${daemonUrl}/api/l3/${encodeURIComponent(context)}`);
+        const resp = await fetch(`${daemonUrl}/promotion/l3?context=${encodeURIComponent(context)}`);
         if (!resp.ok) return `L3 query failed: ${resp.status}`;
         const data = await resp.json();
         if (!data.entries?.length) return `No L3 knowledge in context "${context}".`;
@@ -5442,15 +5439,19 @@ Contexts:
       const query = params.query;
       const topK = params.top_k || 10;
       try {
-        const resp = await fetch(`${daemonUrl}/api/search/cross-context`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ query, top_k: topK })
-        });
+        const crossParams = new URLSearchParams({ q: query, limit: String(topK) });
+        const resp = await fetch(`${daemonUrl}/search/cross-context?${crossParams}`);
         if (!resp.ok) return `Cross-context search failed: ${resp.status}`;
         const data = await resp.json();
-        if (!data.results?.length) return `No memories found across any context for "${query}".`;
-        return data.results.map((r, i) => `${i + 1}. [${r.score.toFixed(3)}] [${r.context_name}] ${r.content.slice(0, 200)}`).join("\n");
+        const flat = [];
+        for (const group of data.results || []) {
+          for (const ep of group.episodes) {
+            flat.push({ ...ep, context_name: group.context });
+          }
+        }
+        if (!flat.length) return `No memories found across any context for "${query}".`;
+        flat.sort((a, b) => b.score - a.score);
+        return flat.map((r, i) => `${i + 1}. [${r.score.toFixed(3)}] [${r.context_name}] ${r.content.slice(0, 200)}`).join("\n");
       } catch (err) {
         return `Memory daemon unreachable: ${err.message}`;
       }
@@ -7808,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.",
@@ -7826,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"]
@@ -7834,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 {
@@ -8070,7 +8112,7 @@ ${findingText}`
 async function storeInMemory(contextName, topic, findings, synthesis, daemonUrl) {
   const storedIds = [];
   try {
-    await fetch(`${daemonUrl}/api/contexts`, {
+    await fetch(`${daemonUrl}/contexts`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -8084,7 +8126,7 @@ async function storeInMemory(contextName, topic, findings, synthesis, daemonUrl)
     const content = `[Source: ${finding.source}]
 ${finding.keyPoints.join("\n")}`;
     try {
-      const resp = await fetch(`${daemonUrl}/api/episodes`, {
+      const resp = await fetch(`${daemonUrl}/episodes`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
@@ -8101,7 +8143,7 @@ ${finding.keyPoints.join("\n")}`;
     }
   }
   try {
-    const resp = await fetch(`${daemonUrl}/api/episodes`, {
+    const resp = await fetch(`${daemonUrl}/episodes`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -8118,7 +8160,7 @@ ${synthesis}`
   } catch {
   }
   try {
-    await fetch(`${daemonUrl}/api/promotion/run?context=${encodeURIComponent(contextName)}`, {
+    await fetch(`${daemonUrl}/promotion/run?context=${encodeURIComponent(contextName)}`, {
       method: "POST"
     });
   } catch {
@@ -8265,28 +8307,30 @@ ${synthesis}${storageNote}`;
       const daemonUrl = config.memoryDaemonUrl;
       try {
         if (context) {
-          const resp2 = await fetch(`${daemonUrl}/api/search`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ query: topic, context_name: context, top_k: 10 })
-          });
+          const searchParams = new URLSearchParams({ q: topic, context, limit: "10" });
+          const resp2 = await fetch(`${daemonUrl}/search?${searchParams}`);
           if (!resp2.ok) return `Memory search failed: ${resp2.status}`;
           const data2 = await resp2.json();
-          if (!data2.results?.length) return `No learned knowledge found for "${topic}" in context "${context}".`;
-          return data2.results.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.role}]
+          if (!data2.episodes?.length) return `No learned knowledge found for "${topic}" in context "${context}".`;
+          return data2.episodes.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.role}]
 ${r.content.slice(0, 500)}`).join("\n\n");
         }
-        const resp = await fetch(`${daemonUrl}/api/search/cross-context`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ query: topic, top_k: 15 })
-        });
+        const crossParams = new URLSearchParams({ q: topic, limit: "15" });
+        const resp = await fetch(`${daemonUrl}/search/cross-context?${crossParams}`);
         if (!resp.ok) return `Memory cross-search failed: ${resp.status}`;
         const data = await resp.json();
-        const learnResults = data.results?.filter((r) => r.context_name.startsWith("learn-")) || [];
+        const learnResults = [];
+        for (const group of data.results || []) {
+          if (group.context.startsWith("learn-")) {
+            for (const ep of group.episodes) {
+              learnResults.push({ ...ep, context_name: group.context });
+            }
+          }
+        }
         if (learnResults.length === 0) {
           return `No previously learned knowledge found for "${topic}". Use the learn tool first.`;
         }
+        learnResults.sort((a, b) => b.score - a.score);
         return learnResults.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.context_name}] [${r.role}]
 ${r.content.slice(0, 500)}`).join("\n\n");
       } catch (err) {
@@ -8325,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",
@@ -8534,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 {
 }
@@ -8582,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) {
@@ -8623,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);
@@ -8886,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 {
@@ -8903,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;
   }
@@ -9415,4 +9684,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-OB6OXLPC.js.map
+//# sourceMappingURL=chunk-ZQ26EOYD.js.map