@sesamespace/hivemind 0.5.17 → 0.6.1

package/dist/{chunk-OPOXV53N.js → chunk-7YHRRM5B.js}

@@ -16,28 +16,46 @@ var LLMClient = class {
     this.temperature = config.temperature;
     this.apiKey = config.api_key ?? "";
   }
+  /**
+   * Simple chat completion (no tools). Backwards compatible.
+   */
   async chat(messages) {
+    return this.chatWithTools(messages);
+  }
+  /**
+   * Chat completion with optional tool definitions.
+   * Returns tool_calls if the model wants to use tools.
+   */
+  async chatWithTools(messages, tools) {
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature
+    };
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
     const resp = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
       },
-      body: JSON.stringify({
-        model: this.model,
-        messages,
-        max_tokens: this.maxTokens,
-        temperature: this.temperature
-      })
+      body: JSON.stringify(body)
     });
     if (!resp.ok) {
-      const body = await resp.text();
-      throw new Error(`LLM request failed: ${resp.status} ${body}`);
+      const text = await resp.text();
+      throw new Error(`LLM request failed: ${resp.status} ${text}`);
     }
     const data = await resp.json();
+    const choice = data.choices[0];
     return {
-      content: data.choices[0].message.content,
+      content: choice.message.content ?? "",
       model: data.model,
+      tool_calls: choice.message.tool_calls,
+      finish_reason: choice.finish_reason,
       usage: data.usage
     };
   }
@@ -618,11 +636,13 @@ var Agent = class {
   llm;
   memory;
   contextManager;
+  toolRegistry = null;
   // Per-context conversation histories
   conversationHistories = /* @__PURE__ */ new Map();
   messageCount = 0;
   PROMOTION_INTERVAL = 10;
   // Run promotion every N messages
+  MAX_TOOL_ITERATIONS = 25;
   requestLogger = null;
   constructor(config, contextName = "global") {
     this.config = config;
@@ -633,6 +653,13 @@ var Agent = class {
       this.contextManager.switchContext(contextName);
     }
   }
+  setToolRegistry(registry) {
+    this.toolRegistry = registry;
+    const toolCount = registry.getDefinitions().length;
+    if (toolCount > 0) {
+      console.log(`[hivemind] Tool use enabled: ${toolCount} tools registered`);
+    }
+  }
   setRequestLogger(logger) {
     this.requestLogger = logger;
   }
@@ -668,7 +695,31 @@ var Agent = class {
     const systemPromptResult = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
     const messages = buildMessages(systemPromptResult.text, conversationHistory, userMessage);
     const llmStart = Date.now();
-    const response = await this.llm.chat(messages);
+    const toolDefs = this.toolRegistry?.getDefinitions() ?? [];
+    let response = await this.llm.chatWithTools(messages, toolDefs.length > 0 ? toolDefs : void 0);
+    let iterations = 0;
+    while (response.tool_calls && response.tool_calls.length > 0 && iterations < this.MAX_TOOL_ITERATIONS) {
+      iterations++;
+      messages.push({
+        role: "assistant",
+        content: response.content,
+        tool_calls: response.tool_calls
+      });
+      for (const call of response.tool_calls) {
+        console.log(`[tools] ${call.function.name}(${call.function.arguments.slice(0, 100)})`);
+        const result = await this.toolRegistry.executeCall(call);
+        messages.push({
+          role: "tool",
+          content: result.content,
+          tool_call_id: result.tool_call_id
+        });
+        console.log(`[tools] ${call.function.name} \u2192 ${result.content.slice(0, 100)}${result.content.length > 100 ? "..." : ""}`);
+      }
+      response = await this.llm.chatWithTools(messages, toolDefs);
+    }
+    if (iterations > 0) {
+      console.log(`[tools] Completed after ${iterations} tool iteration(s)`);
+    }
     const latencyMs = Date.now() - llmStart;
     if (this.requestLogger) {
       try {
@@ -751,192 +802,6 @@ var Agent = class {
     let stripped = message.replace(/^\[.+?\s+in\s+group\s+chat\]:\s*/, "");
     stripped = stripped.replace(/^\[.+?\]:\s*/, "");
     const cmdText = stripped;
-    if (/^hm[:\s]status\b/i.test(cmdText)) {
-      const memoryOk = await this.memory.healthCheck();
-      const contexts = this.contextManager.listContexts();
-      let contextStats = "";
-      try {
-        const daemonContexts = await this.memory.listContexts();
-        contextStats = daemonContexts.map((c) => `  - ${c.name}: ${c.episode_count} episodes`).join("\n");
-      } catch {
-        contextStats = "  (unable to query memory daemon)";
-      }
-      const response = [
-        `## Agent Status`,
-        ``,
-        `**Name:** ${this.config.agent.name}`,
-        `**Active Context:** ${activeCtx}`,
-        `**Memory Daemon:** ${memoryOk ? "\u2705 connected" : "\u274C unreachable"} (${this.config.memory.daemon_url})`,
-        `**Model:** ${this.config.llm.model}`,
-        `**Temperature:** ${this.config.llm.temperature}`,
-        `**Max Tokens:** ${this.config.llm.max_tokens}`,
-        `**Memory Top-K:** ${this.config.memory.top_k}`,
-        `**Messages Processed:** ${this.messageCount}`,
-        `**L1 Contexts in Memory:** ${this.conversationHistories.size}`,
-        ``,
-        `### Contexts`,
-        contextStats
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]memory\s+stats\b/i.test(cmdText)) {
-      try {
-        const contexts = await this.memory.listContexts();
-        let totalEpisodes = 0;
-        let totalL3 = 0;
-        let lines = [];
-        for (const ctx of contexts) {
-          totalEpisodes += ctx.episode_count;
-          let l3Count = 0;
-          try {
-            const l3 = await this.memory.getL3Knowledge(ctx.name);
-            l3Count = l3.length;
-            totalL3 += l3Count;
-          } catch {
-          }
-          lines.push(`  - **${ctx.name}**: ${ctx.episode_count} L2 episodes, ${l3Count} L3 entries`);
-        }
-        const response = [
-          `## Memory Stats`,
-          ``,
-          `**Total L2 Episodes:** ${totalEpisodes}`,
-          `**Total L3 Knowledge:** ${totalL3}`,
-          `**Contexts:** ${contexts.length}`,
-          ``,
-          `### Per Context`,
-          ...lines
-        ].join("\n");
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Memory stats failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const memSearchMatch = cmdText.match(/^hm[:\s]memory\s+search\s+(.+)/i);
-    if (memSearchMatch) {
-      const query = memSearchMatch[1].trim();
-      try {
-        const results = await this.memory.search(query, activeCtx, this.config.memory.top_k);
-        if (results.length === 0) {
-          return { content: `No memories found for "${query}" in context "${activeCtx}".`, model: "system", context: activeCtx };
-        }
-        let response = `## Memory Search: "${query}"
-
-`;
-        for (const ep of results) {
-          const ctxLabel = ep.context_name !== activeCtx ? ` [from: ${ep.context_name}]` : "";
-          response += `- **[${ep.role}]** (score: ${ep.score.toFixed(3)})${ctxLabel} ${ep.content.slice(0, 300)}${ep.content.length > 300 ? "..." : ""}
-`;
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Memory search failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const l3Match = cmdText.match(/^hm[:\s]memory\s+l3(?:\s+(\S+))?/i);
-    if (l3Match) {
-      const targetCtx = l3Match[1] || activeCtx;
-      try {
-        const entries = await this.memory.getL3Knowledge(targetCtx);
-        if (entries.length === 0) {
-          return { content: `No L3 knowledge in context "${targetCtx}".`, model: "system", context: activeCtx };
-        }
-        let response = `## L3 Knowledge: ${targetCtx}
-
-`;
-        for (const entry of entries) {
-          response += `- **[${entry.id.slice(0, 8)}]** (density: ${entry.connection_density}, accesses: ${entry.access_count})
-  ${entry.content}
-`;
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `L3 query failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    if (/^hm[:\s]config\b/i.test(cmdText)) {
-      const response = [
-        `## Configuration`,
-        ``,
-        `**Agent:** ${this.config.agent.name}`,
-        `**Personality:** ${this.config.agent.personality}`,
-        `**Workspace:** ${this.config.agent.workspace || "(none)"}`,
-        ``,
-        `### LLM`,
-        `- Model: ${this.config.llm.model}`,
-        `- Base URL: ${this.config.llm.base_url}`,
-        `- Max Tokens: ${this.config.llm.max_tokens}`,
-        `- Temperature: ${this.config.llm.temperature}`,
-        ``,
-        `### Memory`,
-        `- Daemon URL: ${this.config.memory.daemon_url}`,
-        `- Top-K: ${this.config.memory.top_k}`,
-        `- Embedding Model: ${this.config.memory.embedding_model}`,
-        ``,
-        `### Sesame`,
-        `- API: ${this.config.sesame.api_url}`,
-        `- WebSocket: ${this.config.sesame.ws_url}`,
-        `- API Key: ${this.config.sesame.api_key ? "***" + this.config.sesame.api_key.slice(-4) : "(not set)"}`
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]contexts\b/i.test(cmdText)) {
-      const localContexts = this.contextManager.listContexts();
-      let daemonInfo = "";
-      try {
-        const daemonContexts = await this.memory.listContexts();
-        daemonInfo = "\n### Memory Daemon Contexts\n" + daemonContexts.map(
-          (c) => `  - **${c.name}**: ${c.episode_count} episodes (created: ${c.created_at})`
-        ).join("\n");
-      } catch {
-        daemonInfo = "\n(Memory daemon unreachable)";
-      }
-      const localInfo = localContexts.map((c) => {
-        const active = c.name === activeCtx ? " \u2190 active" : "";
-        const historyLen = this.conversationHistories.get(c.name)?.length || 0;
-        return `  - **${c.name}**${active}: ${historyLen / 2} turns in L1`;
-      }).join("\n");
-      const response = [
-        `## Contexts`,
-        ``,
-        `**Active:** ${activeCtx}`,
-        ``,
-        `### Local (L1 Working Memory)`,
-        localInfo,
-        daemonInfo
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]help\b/i.test(cmdText)) {
-      const response = [
-        `## Available Commands`,
-        ``,
-        `### Introspection`,
-        `- \`hm:status\` \u2014 Agent health, memory status, config summary`,
-        `- \`hm:config\` \u2014 Full configuration details`,
-        `- \`hm:contexts\` \u2014 List all contexts with L1/L2 info`,
-        `- \`hm:memory stats\` \u2014 Episode counts, L3 entries per context`,
-        `- \`hm:memory search <query>\` \u2014 Search L2 memories with scores`,
-        `- \`hm:memory l3 [context]\` \u2014 Show L3 knowledge entries`,
-        `- \`hm:help\` \u2014 This help message`,
-        ``,
-        `### Context Management`,
-        `- \`switch to <name>\` \u2014 Switch active context`,
-        `- \`create context <name>\` \u2014 Create a new context`,
-        `- \`list contexts\` \u2014 List contexts (legacy)`,
-        ``,
-        `### Memory`,
-        `- \`search all: <query>\` \u2014 Cross-context search`,
-        `- \`share <episode_id> with <context>\` \u2014 Share episode across contexts`,
-        ``,
-        `### Tasks`,
-        `- \`task add <title>\` \u2014 Create a task`,
-        `- \`task list [status]\` \u2014 List tasks`,
-        `- \`task start <id>\` \u2014 Start a task`,
-        `- \`task complete <id>\` \u2014 Complete a task`,
-        `- \`task next\` \u2014 Pick up next available task`
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
     const searchAllMatch = cmdText.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
     if (searchAllMatch) {
       const query = searchAllMatch[1].trim();
@@ -1896,12 +1761,7 @@ var SesameClient2 = class {
     this.sdk.on("message", (event) => {
       const msg = event.data || event.message || event;
       const senderId = msg.senderId || msg.sender?.id;
-      if (senderId === this.agentId) {
-        const content = msg.content?.trim() || "";
-        const isHmCommand = /^hm[:\s]/i.test(content);
-        const isTextCommand = /^(?:list contexts|switch to|create context|search all:|task )/i.test(content);
-        if (!isHmCommand && !isTextCommand) return;
-      }
+      if (senderId === this.agentId) return;
       if (!this.messageHandler || !msg.content) return;
       const channelInfo = this.channels.get(msg.channelId);
       this.messageHandler({
@@ -2247,14 +2107,550 @@ function startDashboardServer(requestLogger, memoryConfig) {
   });
 }
 
+// packages/runtime/src/tool-registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(name, description, parameters, executor) {
+    this.tools.set(name, {
+      definition: {
+        type: "function",
+        function: { name, description, parameters }
+      },
+      executor
+    });
+  }
+  getDefinitions() {
+    return Array.from(this.tools.values()).map((t) => t.definition);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  async execute(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return `Error: Unknown tool "${name}"`;
+    }
+    try {
+      return await tool.executor(params);
+    } catch (err) {
+      return `Error executing ${name}: ${err.message}`;
+    }
+  }
+  async executeCall(call) {
+    let params = {};
+    try {
+      params = JSON.parse(call.function.arguments);
+    } catch {
+      return {
+        tool_call_id: call.id,
+        role: "tool",
+        content: `Error: Invalid JSON arguments for ${call.function.name}`
+      };
+    }
+    const result = await this.execute(call.function.name, params);
+    return {
+      tool_call_id: call.id,
+      role: "tool",
+      content: result
+    };
+  }
+};
+
+// packages/runtime/src/tools/shell.ts
+import { execSync } from "child_process";
+import { resolve as resolve5 } from "path";
+var MAX_OUTPUT = 5e4;
+function registerShellTool(registry, workspaceDir) {
+  registry.register(
+    "shell",
+    "Execute a shell command and return stdout/stderr. Use for running programs, checking status, installing packages, git operations, etc.",
+    {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute"
+        },
+        workdir: {
+          type: "string",
+          description: "Working directory (relative to workspace). Defaults to workspace root."
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in seconds. Default: 30"
+        }
+      },
+      required: ["command"]
+    },
+    async (params) => {
+      const command = params.command;
+      const timeout = (params.timeout || 30) * 1e3;
+      const cwd = params.workdir ? resolve5(workspaceDir, params.workdir) : workspaceDir;
+      try {
+        const output = execSync(command, {
+          cwd,
+          timeout,
+          encoding: "utf-8",
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB
+          shell: "/bin/sh",
+          env: { ...process.env, PATH: `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}` }
+        });
+        const trimmed = output.length > MAX_OUTPUT ? output.slice(0, MAX_OUTPUT) + `
+... (truncated, ${output.length} total chars)` : output;
+        return trimmed || "(no output)";
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        const output = (stdout + "\n" + stderr).trim();
+        const code = err.status ?? "unknown";
+        return `Command failed (exit code ${code}):
+${output || err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/files.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve6, dirname as dirname5 } from "path";
+var MAX_READ = 1e5;
+function registerFileTools(registry, workspaceDir) {
+  registry.register(
+    "read_file",
+    "Read the contents of a file. Returns the text content. Use offset/limit for large files.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path (relative to workspace or absolute)"
+        },
+        offset: {
+          type: "number",
+          description: "Line number to start reading from (1-indexed)"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of lines to read"
+        }
+      },
+      required: ["path"]
+    },
+    async (params) => {
+      const filePath = resolvePath(workspaceDir, params.path);
+      if (!existsSync4(filePath)) {
+        return `Error: File not found: ${filePath}`;
+      }
+      try {
+        let content = readFileSync6(filePath, "utf-8");
+        if (params.offset || params.limit) {
+          const lines = content.split("\n");
+          const start = (params.offset || 1) - 1;
+          const end = params.limit ? start + params.limit : lines.length;
+          content = lines.slice(start, end).join("\n");
+        }
+        if (content.length > MAX_READ) {
+          content = content.slice(0, MAX_READ) + `
+... (truncated, ${content.length} total chars)`;
+        }
+        return content || "(empty file)";
+      } catch (err) {
+        return `Error reading file: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "write_file",
+    "Write content to a file. Creates the file and parent directories if they don't exist. Overwrites existing content.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path (relative to workspace or absolute)"
+        },
+        content: {
+          type: "string",
+          description: "Content to write to the file"
+        }
+      },
+      required: ["path", "content"]
+    },
+    async (params) => {
+      const filePath = resolvePath(workspaceDir, params.path);
+      try {
+        const dir = dirname5(filePath);
+        if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+        writeFileSync2(filePath, params.content);
+        return `Written ${params.content.length} bytes to ${filePath}`;
+      } catch (err) {
+        return `Error writing file: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "edit_file",
+    "Edit a file by finding and replacing exact text. The old text must match exactly (including whitespace).",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path (relative to workspace or absolute)"
+        },
+        old_text: {
+          type: "string",
+          description: "Exact text to find and replace"
+        },
+        new_text: {
+          type: "string",
+          description: "New text to replace with"
+        }
+      },
+      required: ["path", "old_text", "new_text"]
+    },
+    async (params) => {
+      const filePath = resolvePath(workspaceDir, params.path);
+      if (!existsSync4(filePath)) {
+        return `Error: File not found: ${filePath}`;
+      }
+      try {
+        const content = readFileSync6(filePath, "utf-8");
+        const oldText = params.old_text;
+        const newText = params.new_text;
+        if (!content.includes(oldText)) {
+          return `Error: Could not find the exact text to replace in ${filePath}`;
+        }
+        const updated = content.replace(oldText, newText);
+        writeFileSync2(filePath, updated);
+        return `Edited ${filePath}: replaced ${oldText.length} chars with ${newText.length} chars`;
+      } catch (err) {
+        return `Error editing file: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "list_files",
+    "List files and directories in a path.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Directory path (relative to workspace or absolute). Defaults to workspace root."
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const { readdirSync: readdirSync2, statSync } = await import("fs");
+      const dirPath = params.path ? resolvePath(workspaceDir, params.path) : workspaceDir;
+      if (!existsSync4(dirPath)) {
+        return `Error: Directory not found: ${dirPath}`;
+      }
+      try {
+        const entries = readdirSync2(dirPath);
+        const results = [];
+        for (const entry of entries) {
+          if (entry.startsWith(".")) continue;
+          try {
+            const stat = statSync(resolve6(dirPath, entry));
+            results.push(stat.isDirectory() ? `${entry}/` : entry);
+          } catch {
+            results.push(entry);
+          }
+        }
+        return results.join("\n") || "(empty directory)";
+      } catch (err) {
+        return `Error listing directory: ${err.message}`;
+      }
+    }
+  );
+}
+function resolvePath(workspace, path) {
+  if (path.startsWith("/") || path.startsWith("~")) {
+    return path.replace(/^~/, process.env.HOME || "/root");
+  }
+  return resolve6(workspace, path);
+}
+
+// packages/runtime/src/tools/web.ts
+function registerWebTools(registry, config) {
+  registry.register(
+    "web_search",
+    "Search the web using Brave Search API. Returns titles, URLs, and snippets.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query string"
+        },
+        count: {
+          type: "number",
+          description: "Number of results (1-10, default 5)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      const apiKey = config?.braveApiKey || process.env.BRAVE_API_KEY;
+      if (!apiKey) {
+        return "Error: No Brave Search API key configured. Set BRAVE_API_KEY env var.";
+      }
+      const query = params.query;
+      const count = Math.min(Math.max(params.count || 5, 1), 10);
+      try {
+        const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${count}`;
+        const resp = await fetch(url, {
+          headers: { "X-Subscription-Token": apiKey, Accept: "application/json" }
+        });
+        if (!resp.ok) {
+          return `Search failed: ${resp.status} ${await resp.text()}`;
+        }
+        const data = await resp.json();
+        const results = data.web?.results || [];
+        if (results.length === 0) return "No results found.";
+        return results.map((r, i) => `${i + 1}. **${r.title}**
+   ${r.url}
+   ${r.description}`).join("\n\n");
+      } catch (err) {
+        return `Search error: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "web_fetch",
+    "Fetch a URL and extract readable content as markdown/text. Good for reading articles, docs, and web pages.",
+    {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "HTTP or HTTPS URL to fetch"
+        },
+        max_chars: {
+          type: "number",
+          description: "Maximum characters to return (default 20000)"
+        }
+      },
+      required: ["url"]
+    },
+    async (params) => {
+      const url = params.url;
+      const maxChars = params.max_chars || 2e4;
+      try {
+        const resp = await fetch(url, {
+          headers: {
+            "User-Agent": "Hivemind/1.0 (Agent Web Fetcher)",
+            Accept: "text/html,application/xhtml+xml,text/plain,application/json"
+          },
+          redirect: "follow"
+        });
+        if (!resp.ok) {
+          return `Fetch failed: ${resp.status} ${resp.statusText}`;
+        }
+        let text = await resp.text();
+        const contentType = resp.headers.get("content-type") || "";
+        if (contentType.includes("html")) {
+          text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+          text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+          text = text.replace(/<[^>]+>/g, " ");
+          text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+          text = text.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+          text = text.replace(/\s+/g, " ").trim();
+        }
+        if (text.length > maxChars) {
+          text = text.slice(0, maxChars) + `
+... (truncated, ${text.length} total chars)`;
+        }
+        return text || "(empty response)";
+      } catch (err) {
+        return `Fetch error: ${err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/memory.ts
+function registerMemoryTools(registry, daemonUrl) {
+  registry.register(
+    "memory_search",
+    "Search your episodic memory for relevant past conversations and experiences. Returns scored results from your memory system. Use this when you want to recall something from a previous conversation or check what you know about a topic.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What to search for in memory"
+        },
+        context: {
+          type: "string",
+          description: "Context to search in (default: current active context)"
+        },
+        top_k: {
+          type: "number",
+          description: "Number of results to return (default: 10)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      const query = params.query;
+      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 })
+        });
+        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");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_stats",
+    "Get statistics about your memory system \u2014 episode counts, contexts, L3 knowledge entries. Use for self-diagnosis or understanding your memory state.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      try {
+        const healthResp = await fetch(`${daemonUrl}/health`);
+        const health = healthResp.ok ? await healthResp.json() : { status: "unreachable" };
+        const ctxResp = await fetch(`${daemonUrl}/api/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)}`);
+            if (l3Resp.ok) {
+              const l3Data = await l3Resp.json();
+              l3Counts[ctx.name] = l3Data.entries?.length ?? 0;
+            }
+          } catch {
+          }
+        }
+        const totalEpisodes = contexts.reduce((sum, c) => sum + c.episode_count, 0);
+        const totalL3 = Object.values(l3Counts).reduce((sum, c) => sum + c, 0);
+        let output = `Memory Daemon: ${health.status || "unknown"}
+`;
+        output += `Total Episodes (L2): ${totalEpisodes}
+`;
+        output += `Total Knowledge (L3): ${totalL3}
+`;
+        output += `
+Contexts:
+`;
+        for (const ctx of contexts) {
+          output += `  - ${ctx.name}: ${ctx.episode_count} episodes, ${l3Counts[ctx.name] ?? 0} L3 entries
+`;
+        }
+        return output;
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_l3",
+    "View your promoted L3 knowledge \u2014 high-level patterns, decisions, and insights that have been distilled from your episodic memories. This is your 'long-term wisdom'.",
+    {
+      type: "object",
+      properties: {
+        context: {
+          type: "string",
+          description: "Context to get L3 knowledge for (default: global)"
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const context = params.context || "global";
+      try {
+        const resp = await fetch(`${daemonUrl}/api/l3/${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}".`;
+        return data.entries.map((e, i) => `${i + 1}. ${e.content} (from ${e.source_episodes} episodes, ${e.created_at})`).join("\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_cross_search",
+    "Search across ALL memory contexts at once. Useful when you're not sure which context a memory belongs to.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What to search for across all contexts"
+        },
+        top_k: {
+          type: "number",
+          description: "Number of results (default: 10)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      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 })
+        });
+        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");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/register.ts
+import { resolve as resolve7 } from "path";
+import { mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
+function registerAllTools(hivemindHome, config) {
+  const registry = new ToolRegistry();
+  if (config?.enabled === false) {
+    return registry;
+  }
+  const workspaceDir = resolve7(hivemindHome, config?.workspace || "workspace");
+  if (!existsSync5(workspaceDir)) {
+    mkdirSync3(workspaceDir, { recursive: true });
+  }
+  registerShellTool(registry, workspaceDir);
+  registerFileTools(registry, workspaceDir);
+  registerWebTools(registry, { braveApiKey: config?.braveApiKey });
+  registerMemoryTools(registry, config?.memoryDaemonUrl || "http://localhost:3434");
+  return registry;
+}
+
 // packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, unlinkSync } from "fs";
-import { resolve as resolve5, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { resolve as resolve8, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_VERSION = "unknown";
 try {
-  const __dirname2 = dirname5(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync6(resolve5(__dirname2, "../package.json"), "utf-8"));
+  const __dirname2 = dirname6(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync7(resolve8(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -2285,7 +2681,7 @@ function startHealthServer(port) {
   return server;
 }
 function writePidFile(path) {
-  writeFileSync2(path, String(process.pid));
+  writeFileSync3(path, String(process.pid));
   console.log(`[hivemind] PID file written: ${path}`);
 }
 function cleanupPidFile(path) {
@@ -2316,10 +2712,18 @@ async function startPipeline(configPath) {
     memoryConnected = true;
     console.log("[hivemind] Memory daemon connected");
   }
-  const requestLogger = new RequestLogger(resolve5(dirname5(configPath), "data", "dashboard.db"));
+  const requestLogger = new RequestLogger(resolve8(dirname6(configPath), "data", "dashboard.db"));
   startDashboardServer(requestLogger, config.memory);
   const agent = new Agent(config);
   agent.setRequestLogger(requestLogger);
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve8(process.env.HOME || "/root", "hivemind");
+  const toolRegistry = registerAllTools(hivemindHome, {
+    enabled: true,
+    workspace: config.agent.workspace || "workspace",
+    braveApiKey: process.env.BRAVE_API_KEY,
+    memoryDaemonUrl: config.memory.daemon_url
+  });
+  agent.setToolRegistry(toolRegistry);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
   if (config.sesame.api_key) {
     await startSesameLoop(config, agent);
@@ -2467,8 +2871,8 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve6) => {
-    rl.on("close", resolve6);
+  return new Promise((resolve9) => {
+    rl.on("close", resolve9);
   });
 }
 
@@ -2497,20 +2901,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve9, reject) => {
       this.server = createServer3((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve6());
+      this.server.listen(this.port, () => resolve9());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve6) => {
+    return new Promise((resolve9) => {
       if (!this.server) {
-        resolve6();
+        resolve9();
         return;
       }
-      this.server.close(() => resolve6());
+      this.server.close(() => resolve9());
     });
   }
   getPort() {
@@ -2633,10 +3037,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve9, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve9(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -2963,4 +3367,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-OPOXV53N.js.map
+//# sourceMappingURL=chunk-7YHRRM5B.js.map