@sesamespace/hivemind 0.7.2 → 0.8.0

package/dist/{chunk-G6PPTVAS.js → chunk-A7X4FKQZ.js}

@@ -753,10 +753,37 @@ ${memoryFiles.context}
     }
   };
 }
-function buildMessages(systemPrompt, conversationHistory, currentMessage) {
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function buildMessages(systemPrompt, conversationHistory, currentMessage, contextLimit = 2e5, reserveForResponse = 4096) {
+  const budget = contextLimit - reserveForResponse;
+  const systemTokens = estimateTokens(systemPrompt);
+  const userTokens = estimateTokens(currentMessage);
+  const fixedTokens = systemTokens + userTokens;
+  if (fixedTokens >= budget) {
+    console.warn(`[prompt] System prompt (${systemTokens} est. tokens) + user message (${userTokens}) exceeds budget (${budget}). Sending without history.`);
+    return [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: currentMessage }
+    ];
+  }
+  let remainingBudget = budget - fixedTokens;
+  const fittingHistory = [];
+  for (let i = conversationHistory.length - 1; i >= 0; i--) {
+    const msg = conversationHistory[i];
+    const msgTokens = estimateTokens(msg.content ?? "");
+    if (msgTokens > remainingBudget) break;
+    fittingHistory.unshift(msg);
+    remainingBudget -= msgTokens;
+  }
+  if (fittingHistory.length < conversationHistory.length) {
+    const dropped = conversationHistory.length - fittingHistory.length;
+    console.log(`[prompt] Token budget: dropped ${dropped} oldest L1 turns (kept ${fittingHistory.length}/${conversationHistory.length})`);
+  }
   return [
     { role: "system", content: systemPrompt },
-    ...conversationHistory,
+    ...fittingHistory,
     { role: "user", content: currentMessage }
   ];
 }
@@ -873,18 +900,18 @@ var SessionStore = class {
     return content.split("\n").length;
   }
 };
-function estimateTokens(text) {
+function estimateTokens2(text) {
   if (!text) return 0;
   return Math.ceil(text.length / 4);
 }
 function estimateMessageTokens(messages) {
   let total = 0;
   for (const msg of messages) {
-    if (msg.content) total += estimateTokens(msg.content);
+    if (msg.content) total += estimateTokens2(msg.content);
     if (msg.tool_calls) {
       for (const call of msg.tool_calls) {
-        total += estimateTokens(call.function.name);
-        total += estimateTokens(call.function.arguments);
+        total += estimateTokens2(call.function.name);
+        total += estimateTokens2(call.function.arguments);
       }
     }
   }
@@ -1119,7 +1146,7 @@ var Agent = class {
       l3Knowledge,
       dataDir: this.dataDir
     });
-    const systemPromptTokens = estimateTokens(systemPromptResult.text);
+    const systemPromptTokens = estimateTokens2(systemPromptResult.text);
     if (this.compactionManager.shouldCompact(conversationHistory, systemPromptTokens, this.config.llm.model)) {
       console.log("[compaction] Context approaching limit, compacting...");
       const result = await this.compactionManager.compact(
@@ -1134,7 +1161,8 @@ var Agent = class {
       conversationHistory.length = 0;
       conversationHistory.push(...updatedHistory);
     }
-    const messages = buildMessages(systemPromptResult.text, conversationHistory, userMessage);
+    const contextLimit = this.config.llm.context_limit ?? 2e5;
+    const messages = buildMessages(systemPromptResult.text, conversationHistory, userMessage, contextLimit, this.config.llm.max_tokens);
     const llmStart = Date.now();
     const toolDefs = this.toolRegistry?.getDefinitions() ?? [];
     let response = await this.llm.chatWithTools(messages, toolDefs.length > 0 ? toolDefs : void 0);
@@ -2513,8 +2541,233 @@ var SesameClient2 = class {
   }
 };
 
+// packages/runtime/src/skills.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync3, watch as watch2, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+function shellEscape(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+function renderCommand(template, params, skillDir, workspaceDir) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    if (key === "skill_dir") return shellEscape(skillDir);
+    if (key === "workspace") return shellEscape(workspaceDir);
+    const val = params[key];
+    if (val === void 0 || val === null) return "''";
+    return shellEscape(String(val));
+  });
+}
+function parseSkillMd(content, fallbackName) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  let name = fallbackName;
+  let description = "";
+  if (fmMatch) {
+    const fm = fmMatch[1];
+    const nameMatch = fm.match(/^name:\s*(.+)$/m);
+    const descMatch = fm.match(/^description:\s*(.+)$/m);
+    if (nameMatch) name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+    if (descMatch) description = descMatch[1].trim().replace(/^["']|["']$/g, "");
+  }
+  return { name, description };
+}
+var SkillsEngine = class {
+  workspaceDir;
+  skillsDir;
+  toolRegistry;
+  loadedSkills = /* @__PURE__ */ new Map();
+  watcher = null;
+  debounceTimers = /* @__PURE__ */ new Map();
+  constructor(workspaceDir, toolRegistry) {
+    this.workspaceDir = workspaceDir;
+    this.toolRegistry = toolRegistry;
+    this.skillsDir = resolve5(workspaceDir, "skills");
+  }
+  async loadAll() {
+    if (!existsSync5(this.skillsDir)) return;
+    let entries;
+    try {
+      entries = readdirSync3(this.skillsDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const skillMdPath = resolve5(this.skillsDir, entry, "SKILL.md");
+      if (!existsSync5(skillMdPath)) continue;
+      try {
+        await this.loadSkill(entry);
+      } catch (err) {
+        console.error(`[skills] Failed to load skill "${entry}":`, err.message);
+      }
+    }
+  }
+  async loadSkill(dirName) {
+    const skillDir = resolve5(this.skillsDir, dirName);
+    const skillMdPath = resolve5(skillDir, "SKILL.md");
+    if (!existsSync5(skillMdPath)) {
+      throw new Error(`SKILL.md not found in ${skillDir}`);
+    }
+    const mdContent = readFileSync6(skillMdPath, "utf-8");
+    const { name, description } = parseSkillMd(mdContent, dirName);
+    const setupPath = resolve5(skillDir, "setup.sh");
+    if (existsSync5(setupPath)) {
+      try {
+        execSync("bash setup.sh", { cwd: skillDir, timeout: 3e4, stdio: "pipe" });
+        console.log(`[skills] Ran setup.sh for "${name}"`);
+      } catch (err) {
+        console.warn(`[skills] setup.sh failed for "${name}":`, err.message);
+      }
+    }
+    const toolNames = [];
+    const toolsJsonPath = resolve5(skillDir, "tools.json");
+    if (existsSync5(toolsJsonPath)) {
+      try {
+        const toolsData = JSON.parse(readFileSync6(toolsJsonPath, "utf-8"));
+        const toolDefs = toolsData.tools || [];
+        for (const toolDef of toolDefs) {
+          if (!toolDef.name || !toolDef.command) continue;
+          const toolName = toolDef.name;
+          const toolDesc = toolDef.description || `Tool from skill "${name}"`;
+          const toolParams = toolDef.parameters || { type: "object", properties: {}, required: [] };
+          const commandTemplate = toolDef.command;
+          this.toolRegistry.register(
+            toolName,
+            toolDesc,
+            toolParams,
+            async (params) => {
+              const cmd = renderCommand(commandTemplate, params, skillDir, this.workspaceDir);
+              try {
+                const output = execSync(cmd, {
+                  cwd: skillDir,
+                  timeout: 6e4,
+                  encoding: "utf-8",
+                  maxBuffer: 1024 * 1024,
+                  shell: "/bin/bash"
+                });
+                return output || "(no output)";
+              } catch (err) {
+                const execErr = err;
+                return `Error: ${execErr.stderr || execErr.message}`;
+              }
+            }
+          );
+          toolNames.push(toolName);
+        }
+      } catch (err) {
+        console.warn(`[skills] Failed to parse tools.json for "${name}":`, err.message);
+      }
+    }
+    this.loadedSkills.set(dirName, {
+      name,
+      dirName,
+      description,
+      path: skillDir,
+      tools: toolNames
+    });
+    const toolSuffix = toolNames.length > 0 ? ` (${toolNames.length} tools: ${toolNames.join(", ")})` : "";
+    console.log(`[skills] Loaded "${name}"${toolSuffix}`);
+  }
+  async unloadSkill(dirName) {
+    const skill = this.loadedSkills.get(dirName);
+    if (!skill) return;
+    for (const toolName of skill.tools) {
+      this.toolRegistry.unregister(toolName);
+    }
+    const teardownPath = resolve5(skill.path, "teardown.sh");
+    if (existsSync5(teardownPath)) {
+      try {
+        execSync("bash teardown.sh", { cwd: skill.path, timeout: 3e4, stdio: "pipe" });
+        console.log(`[skills] Ran teardown.sh for "${skill.name}"`);
+      } catch (err) {
+        console.warn(`[skills] teardown.sh failed for "${skill.name}":`, err.message);
+      }
+    }
+    this.loadedSkills.delete(dirName);
+    console.log(`[skills] Unloaded "${skill.name}"`);
+  }
+  async reloadSkill(dirName) {
+    await this.unloadSkill(dirName);
+    await this.loadSkill(dirName);
+  }
+  startWatching() {
+    if (this.watcher) return;
+    if (!existsSync5(this.skillsDir)) {
+      mkdirSync3(this.skillsDir, { recursive: true });
+    }
+    try {
+      this.watcher = watch2(this.skillsDir, { recursive: true }, (_event, filename) => {
+        if (!filename) return;
+        const parts = filename.split("/");
+        if (parts.length < 2) return;
+        const skillDirName = parts[0];
+        const changedFile = parts.slice(1).join("/");
+        if (changedFile !== "tools.json" && changedFile !== "SKILL.md") return;
+        const existing = this.debounceTimers.get(skillDirName);
+        if (existing) clearTimeout(existing);
+        this.debounceTimers.set(
+          skillDirName,
+          setTimeout(async () => {
+            this.debounceTimers.delete(skillDirName);
+            const skillDir = resolve5(this.skillsDir, skillDirName);
+            const hasMd = existsSync5(resolve5(skillDir, "SKILL.md"));
+            if (hasMd && this.loadedSkills.has(skillDirName)) {
+              console.log(`[skills] Detected change in "${skillDirName}", reloading...`);
+              try {
+                await this.reloadSkill(skillDirName);
+              } catch (err) {
+                console.error(`[skills] Reload failed for "${skillDirName}":`, err.message);
+              }
+            } else if (hasMd && !this.loadedSkills.has(skillDirName)) {
+              console.log(`[skills] Detected new skill "${skillDirName}", loading...`);
+              try {
+                await this.loadSkill(skillDirName);
+              } catch (err) {
+                console.error(`[skills] Load failed for "${skillDirName}":`, err.message);
+              }
+            }
+          }, 500)
+        );
+      });
+      console.log(`[skills] Watching ${this.skillsDir} for changes`);
+    } catch (err) {
+      console.warn(`[skills] Failed to start watcher:`, err.message);
+    }
+  }
+  stopWatching() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  listSkills() {
+    return Array.from(this.loadedSkills.values()).map((s) => ({
+      name: s.name,
+      dirName: s.dirName,
+      description: s.description,
+      path: s.path,
+      tools: [...s.tools],
+      loaded: true
+    }));
+  }
+  getSkill(dirName) {
+    const s = this.loadedSkills.get(dirName);
+    if (!s) return void 0;
+    return {
+      name: s.name,
+      dirName: s.dirName,
+      description: s.description,
+      path: s.path,
+      tools: [...s.tools],
+      loaded: true
+    };
+  }
+};
+
 // packages/runtime/src/pipeline.ts
-import { createServer as createServer2 } from "http";
+import { createServer as createServer3 } from "http";
 
 // packages/runtime/src/health.ts
 var HEALTH_PORT = 9484;
@@ -2522,7 +2775,7 @@ var HEALTH_PATH = "/health";
 
 // packages/runtime/src/request-logger.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync3, existsSync as existsSync5, appendFileSync as appendFileSync2, readFileSync as readFileSync6, writeFileSync } from "fs";
+import { mkdirSync as mkdirSync4, existsSync as existsSync6, appendFileSync as appendFileSync2, readFileSync as readFileSync7, writeFileSync } from "fs";
 import { dirname as dirname4 } from "path";
 var RequestLogger = class {
   logPath;
@@ -2531,14 +2784,14 @@ var RequestLogger = class {
     this.logPath = dbPath.replace(/\.db$/, ".jsonl");
     if (this.logPath === dbPath) this.logPath = dbPath + ".jsonl";
     const dir = dirname4(this.logPath);
-    if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
+    if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
     this.prune();
   }
   prune() {
-    if (!existsSync5(this.logPath)) return;
+    if (!existsSync6(this.logPath)) return;
     const cutoff = new Date(Date.now() - this.maxAgeDays * 24 * 60 * 60 * 1e3).toISOString();
     try {
-      const lines = readFileSync6(this.logPath, "utf-8").split("\n").filter(Boolean);
+      const lines = readFileSync7(this.logPath, "utf-8").split("\n").filter(Boolean);
       const kept = [];
       let pruned = 0;
       for (const line of lines) {
@@ -2614,9 +2867,9 @@ var RequestLogger = class {
   close() {
   }
   readAll() {
-    if (!existsSync5(this.logPath)) return [];
+    if (!existsSync6(this.logPath)) return [];
     try {
-      const lines = readFileSync6(this.logPath, "utf-8").split("\n").filter(Boolean);
+      const lines = readFileSync7(this.logPath, "utf-8").split("\n").filter(Boolean);
       const entries = [];
       for (const line of lines) {
         try {
@@ -2633,17 +2886,17 @@ var RequestLogger = class {
 
 // packages/runtime/src/dashboard.ts
 import { createServer } from "http";
-import { readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve5, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve6, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname = dirname5(fileURLToPath2(import.meta.url));
 var DASHBOARD_PORT = 9485;
 var spaHtml = null;
 function getSpaHtml() {
   if (!spaHtml) {
-    for (const dir of [__dirname, resolve5(__dirname, "../src")]) {
+    for (const dir of [__dirname, resolve6(__dirname, "../src")]) {
       try {
-        spaHtml = readFileSync7(resolve5(dir, "dashboard.html"), "utf-8");
+        spaHtml = readFileSync8(resolve6(dir, "dashboard.html"), "utf-8");
         break;
       } catch {
       }
@@ -2782,6 +3035,9 @@ var ToolRegistry = class {
   has(name) {
     return this.tools.has(name);
   }
+  unregister(name) {
+    return this.tools.delete(name);
+  }
   async execute(name, params) {
     const tool = this.tools.get(name);
     if (!tool) {
@@ -2814,8 +3070,8 @@ var ToolRegistry = class {
 };
 
 // packages/runtime/src/tools/shell.ts
-import { execSync } from "child_process";
-import { resolve as resolve6 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { resolve as resolve7 } from "path";
 var MAX_OUTPUT = 5e4;
 function registerShellTool(registry, workspaceDir) {
   registry.register(
@@ -2842,9 +3098,9 @@ function registerShellTool(registry, workspaceDir) {
     async (params) => {
       const command = params.command;
       const timeout = (params.timeout || 30) * 1e3;
-      const cwd = params.workdir ? resolve6(workspaceDir, params.workdir) : workspaceDir;
+      const cwd = params.workdir ? resolve7(workspaceDir, params.workdir) : workspaceDir;
       try {
-        const output = execSync(command, {
+        const output = execSync2(command, {
           cwd,
           timeout,
           encoding: "utf-8",
@@ -2869,8 +3125,8 @@ ${output || err.message}`;
 }
 
 // packages/runtime/src/tools/files.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import { resolve as resolve7, dirname as dirname6 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve8, dirname as dirname6 } from "path";
 var MAX_READ = 1e5;
 function registerFileTools(registry, workspaceDir) {
   registry.register(
@@ -2896,11 +3152,11 @@ function registerFileTools(registry, workspaceDir) {
     },
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
-      if (!existsSync6(filePath)) {
+      if (!existsSync7(filePath)) {
         return `Error: File not found: ${filePath}`;
       }
       try {
-        let content = readFileSync8(filePath, "utf-8");
+        let content = readFileSync9(filePath, "utf-8");
         if (params.offset || params.limit) {
           const lines = content.split("\n");
           const start = (params.offset || 1) - 1;
@@ -2938,7 +3194,7 @@ function registerFileTools(registry, workspaceDir) {
       const filePath = resolvePath(workspaceDir, params.path);
       try {
         const dir = dirname6(filePath);
-        if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+        if (!existsSync7(dir)) mkdirSync5(dir, { recursive: true });
         writeFileSync2(filePath, params.content);
         return `Written ${params.content.length} bytes to ${filePath}`;
       } catch (err) {
@@ -2969,11 +3225,11 @@ function registerFileTools(registry, workspaceDir) {
     },
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
-      if (!existsSync6(filePath)) {
+      if (!existsSync7(filePath)) {
         return `Error: File not found: ${filePath}`;
       }
       try {
-        const content = readFileSync8(filePath, "utf-8");
+        const content = readFileSync9(filePath, "utf-8");
         const oldText = params.old_text;
         const newText = params.new_text;
         if (!content.includes(oldText)) {
@@ -3001,18 +3257,18 @@ function registerFileTools(registry, workspaceDir) {
       required: []
     },
     async (params) => {
-      const { readdirSync: readdirSync3, statSync: statSync2 } = await import("fs");
+      const { readdirSync: readdirSync5, statSync: statSync3 } = await import("fs");
       const dirPath = params.path ? resolvePath(workspaceDir, params.path) : workspaceDir;
-      if (!existsSync6(dirPath)) {
+      if (!existsSync7(dirPath)) {
         return `Error: Directory not found: ${dirPath}`;
       }
       try {
-        const entries = readdirSync3(dirPath);
+        const entries = readdirSync5(dirPath);
         const results = [];
         for (const entry of entries) {
           if (entry.startsWith(".")) continue;
           try {
-            const stat = statSync2(resolve7(dirPath, entry));
+            const stat = statSync3(resolve8(dirPath, entry));
             results.push(stat.isDirectory() ? `${entry}/` : entry);
           } catch {
             results.push(entry);
@@ -3029,7 +3285,7 @@ function resolvePath(workspace, path) {
   if (path.startsWith("/") || path.startsWith("~")) {
     return path.replace(/^~/, process.env.HOME || "/root");
   }
-  return resolve7(workspace, path);
+  return resolve8(workspace, path);
 }
 
 // packages/runtime/src/tools/web.ts
@@ -3281,172 +3537,2314 @@ Contexts:
   );
 }
 
-// packages/runtime/src/tools/register.ts
-import { resolve as resolve8 } from "path";
-import { mkdirSync as mkdirSync5, existsSync as existsSync7 } from "fs";
-function registerAllTools(hivemindHome, config) {
-  const registry = new ToolRegistry();
-  if (config?.enabled === false) {
-    return registry;
+// packages/runtime/src/tools/events.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+function registerEventTools(registry, dataDir) {
+  const eventsDir = join4(dataDir, "events");
+  if (!existsSync8(eventsDir)) {
+    mkdirSync6(eventsDir, { recursive: true });
   }
-  const workspaceDir = resolve8(hivemindHome, config?.workspace || "workspace");
-  if (!existsSync7(workspaceDir)) {
-    mkdirSync5(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 readFileSync9, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
-import { resolve as resolve9, dirname as dirname7 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var PACKAGE_VERSION = "unknown";
-try {
-  const __dirname2 = dirname7(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync9(resolve9(__dirname2, "../package.json"), "utf-8"));
-  PACKAGE_VERSION = pkg.version ?? "unknown";
-} catch {
-}
-var sesameConnected = false;
-var memoryConnected = false;
-var startTime = Date.now();
-function startHealthServer(port) {
-  const server = createServer2((req, res) => {
-    if (req.method === "GET" && req.url === HEALTH_PATH) {
-      const status = {
-        status: sesameConnected ? "ok" : "degraded",
-        pid: process.pid,
-        uptime_s: Math.floor((Date.now() - startTime) / 1e3),
-        sesame_connected: sesameConnected,
-        memory_connected: memoryConnected,
-        version: PACKAGE_VERSION
-      };
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(status));
-    } else {
-      res.writeHead(404);
-      res.end();
+  registry.register(
+    "create_event",
+    "Create a scheduled event. Immediate events fire right away. One-shot events fire at a specific time. Periodic events fire on a cron schedule. The event will trigger a message to the specified Sesame channel.",
+    {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["immediate", "one-shot", "periodic"],
+          description: "Event type: 'immediate' fires now, 'one-shot' fires at a specific time, 'periodic' fires on a cron schedule"
+        },
+        channelId: {
+          type: "string",
+          description: "Sesame channel ID to send the event result to"
+        },
+        text: {
+          type: "string",
+          description: "The prompt/message for the event"
+        },
+        at: {
+          type: "string",
+          description: "ISO 8601 datetime for one-shot events (e.g. '2026-03-01T15:00:00Z')"
+        },
+        schedule: {
+          type: "string",
+          description: "Cron expression for periodic events (e.g. '0 9 * * 1-5' for weekdays at 9am)"
+        },
+        timezone: {
+          type: "string",
+          description: "IANA timezone for periodic events (default: 'UTC')"
+        }
+      },
+      required: ["type", "channelId", "text"]
+    },
+    async (params) => {
+      const type = params.type;
+      const channelId = params.channelId;
+      const text = params.text;
+      if (type === "one-shot" && !params.at) {
+        return "Error: 'at' parameter is required for one-shot events (ISO 8601 datetime)";
+      }
+      if (type === "periodic" && !params.schedule) {
+        return "Error: 'schedule' parameter is required for periodic events (cron expression)";
+      }
+      let event;
+      switch (type) {
+        case "immediate":
+          event = { type: "immediate", channelId, text };
+          break;
+        case "one-shot":
+          event = { type: "one-shot", channelId, text, at: params.at };
+          break;
+        case "periodic":
+          event = {
+            type: "periodic",
+            channelId,
+            text,
+            schedule: params.schedule,
+            timezone: params.timezone || "UTC"
+          };
+          break;
+        default:
+          return `Error: Unknown event type '${type}'. Use 'immediate', 'one-shot', or 'periodic'.`;
+      }
+      const filename = `${randomUUID3()}.json`;
+      const filePath = join4(eventsDir, filename);
+      try {
+        writeFileSync3(filePath, JSON.stringify(event, null, 2));
+        return `Event created: ${filename} (type: ${type})`;
+      } catch (err) {
+        return `Error creating event: ${err.message}`;
+      }
     }
-  });
-  server.listen(port, "127.0.0.1", () => {
-    console.log(`[hivemind] Health endpoint listening on http://127.0.0.1:${port}${HEALTH_PATH}`);
-  });
-  return server;
-}
-function writePidFile(path) {
-  writeFileSync3(path, String(process.pid));
-  console.log(`[hivemind] PID file written: ${path}`);
-}
-function cleanupPidFile(path) {
-  try {
-    unlinkSync2(path);
-  } catch {
-  }
-}
-async function startPipeline(configPath) {
-  const config = loadConfig(configPath);
-  const sentinel = config.sentinel ?? defaultSentinelConfig();
-  const healthPort = sentinel.health_port || HEALTH_PORT;
-  const pidFile = sentinel.pid_file;
-  console.log(`[hivemind] Starting ${config.agent.name} (pid ${process.pid})`);
-  writePidFile(pidFile);
-  const healthServer = startHealthServer(healthPort);
-  const cleanupOnExit = () => {
-    cleanupPidFile(pidFile);
-    healthServer.close();
-  };
-  process.on("exit", cleanupOnExit);
-  const memory = new MemoryClient(config.memory);
-  const memoryOk = await memory.healthCheck();
-  if (!memoryOk) {
-    console.warn("[hivemind] Memory daemon unreachable at", config.memory.daemon_url);
-    console.warn("[hivemind] Continuing without persistent memory \u2014 episodes will not be stored");
-  } else {
-    memoryConnected = true;
-    console.log("[hivemind] Memory daemon connected");
-  }
-  const requestLogger = new RequestLogger(resolve9(dirname7(configPath), "data", "dashboard.db"));
-  startDashboardServer(requestLogger, config.memory);
-  const agent = new Agent(config);
-  agent.setRequestLogger(requestLogger);
-  const hivemindHome = process.env.HIVEMIND_HOME || resolve9(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()})`);
-  const dataDir = resolve9(hivemindHome, "data");
-  if (config.sesame.api_key) {
-    await startSesameLoop(config, agent, dataDir);
-  } else {
-    console.log("[hivemind] No Sesame API key configured \u2014 running in stdin mode");
-    await startStdinLoop(agent);
-  }
-}
-async function startSesameLoop(config, agent, dataDir) {
-  const sesame = new SesameClient2(config.sesame);
-  let eventsWatcher = null;
-  if (dataDir) {
-    eventsWatcher = new EventsWatcher(dataDir, async (channelId, text, filename, eventType) => {
-      console.log(`[events] Firing ${eventType} event from ${filename}`);
-      const eventMessage = `[EVENT:${filename}:${eventType}] ${text}`;
+  );
+  registry.register(
+    "list_events",
+    "List all scheduled events with their type and configuration.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
       try {
-        const response = await agent.processMessage(eventMessage);
-        if (response.content.trim() === "[SILENT]" || response.content.trim().startsWith("[SILENT]")) {
-          console.log(`[events] Silent response for ${filename}`);
-          return;
+        if (!existsSync8(eventsDir)) {
+          return "No events directory found.";
         }
-        if (response.content.trim() === "__SKIP__") return;
-        if (channelId) {
-          await sesame.sendMessage(channelId, response.content);
+        const files = readdirSync4(eventsDir).filter((f) => f.endsWith(".json"));
+        if (files.length === 0) {
+          return "No events scheduled.";
+        }
+        const lines = [];
+        for (const file of files) {
+          try {
+            const content = readFileSync10(join4(eventsDir, file), "utf-8");
+            const event = JSON.parse(content);
+            let detail = `${file} \u2014 type: ${event.type}, channel: ${event.channelId}`;
+            if (event.type === "one-shot") {
+              detail += `, at: ${event.at}`;
+            } else if (event.type === "periodic") {
+              detail += `, schedule: ${event.schedule}, tz: ${event.timezone}`;
+            }
+            detail += `, text: "${event.text.slice(0, 80)}${event.text.length > 80 ? "..." : ""}"`;
+            lines.push(detail);
+          } catch {
+            lines.push(`${file} \u2014 (unreadable)`);
+          }
         }
+        return `${files.length} event(s):
+${lines.join("\n")}`;
       } catch (err) {
-        console.error(`[events] Error processing event ${filename}:`, err.message);
+        return `Error listing events: ${err.message}`;
       }
-    });
-    eventsWatcher.start();
-  }
-  let shuttingDown = false;
-  const shutdown = (signal) => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    console.log(`
-[hivemind] Received ${signal}, shutting down...`);
-    try {
-      sesame.updatePresence("offline", { emoji: "\u2B58" });
-      sesame.disconnect();
-      console.log("[hivemind] Sesame disconnected cleanly");
-    } catch (err) {
-      console.error("[hivemind] Error during disconnect:", err.message);
-    }
-    process.exit(0);
-  };
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  const processedIds = /* @__PURE__ */ new Set();
-  const MAX_SEEN = 500;
-  let processing = false;
-  const messageQueue = [];
-  async function processQueue() {
-    if (processing || messageQueue.length === 0) return;
-    processing = true;
-    while (messageQueue.length > 0) {
-      const msg = messageQueue.shift();
-      await handleMessage(msg);
     }
-    processing = false;
-  }
-  sesame.onMessage(async (msg) => {
-    if (shuttingDown) return;
-    if (processedIds.has(msg.id)) {
-      console.log(`[sesame] Skipping duplicate message ${msg.id}`);
+  );
+  registry.register(
+    "delete_event",
+    "Delete a scheduled event by filename.",
+    {
+      type: "object",
+      properties: {
+        filename: {
+          type: "string",
+          description: "The event filename to delete (e.g. 'abc123.json')"
+        }
+      },
+      required: ["filename"]
+    },
+    async (params) => {
+      const filename = params.filename;
+      const filePath = join4(eventsDir, filename);
+      if (filename.includes("/") || filename.includes("\\") || filename.includes("..")) {
+        return "Error: Invalid filename.";
+      }
+      if (!existsSync8(filePath)) {
+        return `Event not found: ${filename}`;
+      }
+      try {
+        unlinkSync2(filePath);
+        return `Event deleted: ${filename}`;
+      } catch (err) {
+        return `Error deleting event: ${err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/spawn.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5, resolve as resolve9 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+var spawnedAgents = /* @__PURE__ */ new Map();
+function registerSpawnTools(registry, hivemindHome, dataDir, configPath) {
+  const spawnDir = join5(dataDir, "spawn");
+  if (!existsSync9(spawnDir)) {
+    mkdirSync7(spawnDir, { recursive: true });
+  }
+  const hivemindBin = resolve9(hivemindHome, "node_modules", ".bin", "hivemind");
+  registry.register(
+    "spawn_agent",
+    "Fork a new hivemind process to run an isolated task. The sub-agent gets its own context, processes the task, and exits. Use for parallel work, long-running tasks, or tasks that need isolation.",
+    {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "The prompt/instruction for the sub-agent to process"
+        },
+        context: {
+          type: "string",
+          description: "Context name for the sub-agent (default: 'spawn-<uuid>')"
+        },
+        channelId: {
+          type: "string",
+          description: "Sesame channel ID to post results to when done"
+        },
+        timeoutSeconds: {
+          type: "number",
+          description: "Timeout in seconds (default: 300)"
+        }
+      },
+      required: ["task"]
+    },
+    async (params) => {
+      const task = params.task;
+      const spawnId = randomUUID4();
+      const context = params.context || `spawn-${spawnId.slice(0, 8)}`;
+      const channelId = params.channelId;
+      const timeoutSeconds = params.timeoutSeconds || 300;
+      const spawnWorkDir = join5(spawnDir, spawnId);
+      mkdirSync7(spawnWorkDir, { recursive: true });
+      writeFileSync4(join5(spawnWorkDir, "task.md"), task);
+      const childEnv = {
+        ...process.env,
+        SPAWN_TASK: task,
+        SPAWN_ID: spawnId,
+        SPAWN_CONTEXT: context,
+        SPAWN_DIR: spawnWorkDir,
+        // Disable health server and PID file for spawned agents
+        SENTINEL_HEALTH_PORT: "0",
+        SENTINEL_PID_FILE: join5(spawnWorkDir, ".pid")
+      };
+      if (channelId) {
+        childEnv.SPAWN_CHANNEL_ID = channelId;
+      }
+      try {
+        const child = spawn(hivemindBin, ["start", "--config", configPath], {
+          env: childEnv,
+          stdio: ["ignore", "pipe", "pipe"],
+          detached: false
+        });
+        if (!child.pid) {
+          return `Error: Failed to spawn sub-agent process`;
+        }
+        const logPath = join5(spawnWorkDir, "output.log");
+        const logChunks = [];
+        child.stdout?.on("data", (chunk) => logChunks.push(chunk));
+        child.stderr?.on("data", (chunk) => logChunks.push(chunk));
+        const agent = {
+          pid: child.pid,
+          context,
+          task,
+          channelId,
+          startTime: Date.now(),
+          process: child,
+          exitCode: null,
+          exited: false
+        };
+        spawnedAgents.set(spawnId, agent);
+        child.on("exit", (code) => {
+          agent.exitCode = code;
+          agent.exited = true;
+          try {
+            writeFileSync4(logPath, Buffer.concat(logChunks).toString("utf-8"));
+          } catch {
+          }
+        });
+        const timer = setTimeout(() => {
+          if (!agent.exited) {
+            try {
+              child.kill("SIGTERM");
+            } catch {
+            }
+            agent.exited = true;
+            agent.exitCode = -1;
+            try {
+              writeFileSync4(
+                join5(spawnWorkDir, "result.txt"),
+                `[TIMEOUT] Sub-agent killed after ${timeoutSeconds}s`
+              );
+            } catch {
+            }
+          }
+        }, timeoutSeconds * 1e3);
+        child.on("exit", () => clearTimeout(timer));
+        return [
+          `Sub-agent spawned successfully.`,
+          `  ID: ${spawnId}`,
+          `  PID: ${child.pid}`,
+          `  Context: ${context}`,
+          `  Timeout: ${timeoutSeconds}s`,
+          channelId ? `  Channel: ${channelId}` : null,
+          `  Log: ${logPath}`
+        ].filter(Boolean).join("\n");
+      } catch (err) {
+        return `Error spawning sub-agent: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "list_agents",
+    "List all spawned sub-agent processes with their status (running/completed/failed/timeout).",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      if (spawnedAgents.size === 0) {
+        return "No spawned agents.";
+      }
+      const lines = [];
+      for (const [id, agent] of spawnedAgents) {
+        const runtime = Math.floor((Date.now() - agent.startTime) / 1e3);
+        let status;
+        if (!agent.exited) {
+          status = "running";
+        } else if (agent.exitCode === 0) {
+          status = "completed";
+        } else if (agent.exitCode === -1) {
+          status = "timeout";
+        } else {
+          status = `failed (exit ${agent.exitCode})`;
+        }
+        const taskPreview = agent.task.length > 80 ? agent.task.slice(0, 80) + "..." : agent.task;
+        let detail = `${id} \u2014 status: ${status}, pid: ${agent.pid}, context: ${agent.context}, runtime: ${runtime}s`;
+        if (agent.channelId) detail += `, channel: ${agent.channelId}`;
+        detail += `
+  task: "${taskPreview}"`;
+        if (agent.exited) {
+          const resultPath = join5(spawnDir, id, "result.txt");
+          if (existsSync9(resultPath)) {
+            try {
+              const result = readFileSync11(resultPath, "utf-8");
+              const preview = result.length > 200 ? result.slice(0, 200) + "..." : result;
+              detail += `
+  result: "${preview}"`;
+            } catch {
+            }
+          }
+        }
+        lines.push(detail);
+      }
+      return `${spawnedAgents.size} agent(s):
+${lines.join("\n\n")}`;
+    }
+  );
+  registry.register(
+    "kill_agent",
+    "Kill a spawned sub-agent process by its ID.",
+    {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "The spawn ID of the agent to kill"
+        }
+      },
+      required: ["id"]
+    },
+    async (params) => {
+      const id = params.id;
+      const agent = spawnedAgents.get(id);
+      if (!agent) {
+        return `Error: No spawned agent found with ID ${id}`;
+      }
+      if (agent.exited) {
+        return `Agent ${id} has already exited (code ${agent.exitCode})`;
+      }
+      try {
+        agent.process.kill("SIGTERM");
+        agent.exited = true;
+        agent.exitCode = -2;
+        writeFileSync4(
+          join5(spawnDir, id, "result.txt"),
+          `[KILLED] Sub-agent killed by parent agent`
+        );
+        return `Agent ${id} (pid ${agent.pid}) killed`;
+      } catch (err) {
+        return `Error killing agent ${id}: ${err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/vision.ts
+function registerVisionTools(registry) {
+  const apiKey = process.env.LLM_API_KEY;
+  registry.register(
+    "analyze_image",
+    "Analyze an image using a vision-capable LLM. Accepts an image URL or base64 data URI. Returns a text description/analysis of the image.",
+    {
+      type: "object",
+      properties: {
+        image: {
+          type: "string",
+          description: "URL to the image, or a base64 data URI (e.g. 'data:image/png;base64,...')"
+        },
+        prompt: {
+          type: "string",
+          description: "What to analyze about the image (default: 'Describe this image in detail')"
+        }
+      },
+      required: ["image"]
+    },
+    async (params) => {
+      const key = apiKey || process.env.LLM_API_KEY;
+      if (!key) {
+        return "Error: No LLM_API_KEY configured. Set LLM_API_KEY env var for vision analysis.";
+      }
+      const image = params.image;
+      const prompt = params.prompt || "Describe this image in detail";
+      if (!image) {
+        return "Error: 'image' parameter is required (URL or base64 data URI).";
+      }
+      try {
+        const resp = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${key}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: "anthropic/claude-sonnet-4-20250514",
+            messages: [
+              {
+                role: "user",
+                content: [
+                  { type: "image_url", image_url: { url: image } },
+                  { type: "text", text: prompt }
+                ]
+              }
+            ]
+          })
+        });
+        if (!resp.ok) {
+          const body = await resp.text();
+          return `Vision API error (${resp.status}): ${body}`;
+        }
+        const data = await resp.json();
+        if (data.error) {
+          return `Vision API error: ${data.error.message}`;
+        }
+        const content = data.choices?.[0]?.message?.content;
+        if (!content) {
+          return "Error: No response content from vision model.";
+        }
+        return content;
+      } catch (err) {
+        return `Vision analysis error: ${err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/git.ts
+import { execSync as execSync3 } from "child_process";
+import { resolve as resolve10, normalize } from "path";
+function resolveRepoPath(workspaceDir, repoPath) {
+  if (!repoPath) return workspaceDir;
+  const resolved = resolve10(workspaceDir, repoPath);
+  const normalizedResolved = normalize(resolved);
+  const normalizedWorkspace = normalize(workspaceDir);
+  if (!normalizedResolved.startsWith(normalizedWorkspace)) {
+    throw new Error("Path traversal detected: repoPath must be within the workspace.");
+  }
+  return resolved;
+}
+function runGit(args, cwd) {
+  const output = execSync3(`git ${args}`, {
+    cwd,
+    timeout: 3e4,
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024,
+    env: { ...process.env, PATH: `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}` }
+  });
+  return output;
+}
+function registerGitTools(registry, workspaceDir) {
+  registry.register(
+    "git_status",
+    "Get repository status: modified, staged, and untracked files in a structured format.",
+    {
+      type: "object",
+      properties: {
+        repoPath: {
+          type: "string",
+          description: "Path to the git repository (relative to workspace). Defaults to workspace root."
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      try {
+        const cwd = resolveRepoPath(workspaceDir, params.repoPath);
+        const output = runGit("status --porcelain", cwd);
+        if (!output.trim()) {
+          return "Working tree clean \u2014 no changes.";
+        }
+        const staged = [];
+        const modified = [];
+        const untracked = [];
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const index = line[0];
+          const worktree = line[1];
+          const file = line.slice(3);
+          if (index === "?" && worktree === "?") {
+            untracked.push(file);
+          } else {
+            if (index !== " " && index !== "?") staged.push(`${index} ${file}`);
+            if (worktree !== " " && worktree !== "?") modified.push(`${worktree} ${file}`);
+          }
+        }
+        const sections = [];
+        if (staged.length) sections.push(`Staged (${staged.length}):
+${staged.join("\n")}`);
+        if (modified.length) sections.push(`Modified (${modified.length}):
+${modified.join("\n")}`);
+        if (untracked.length) sections.push(`Untracked (${untracked.length}):
+${untracked.join("\n")}`);
+        return sections.join("\n\n");
+      } catch (err) {
+        return `git_status error: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "git_diff",
+    "Show changes in the working directory or between commits. Returns a diff output.",
+    {
+      type: "object",
+      properties: {
+        repoPath: {
+          type: "string",
+          description: "Path to the git repository (relative to workspace). Defaults to workspace root."
+        },
+        target: {
+          type: "string",
+          description: "Diff target: a branch name, commit hash, or ref like 'HEAD~1' or 'main'."
+        },
+        staged: {
+          type: "boolean",
+          description: "If true, show staged changes (--staged). Default: false."
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      try {
+        const cwd = resolveRepoPath(workspaceDir, params.repoPath);
+        const args = ["diff"];
+        if (params.staged) args.push("--staged");
+        if (params.target) args.push(params.target);
+        let output = runGit(args.join(" "), cwd);
+        if (!output.trim()) {
+          return "No changes.";
+        }
+        if (output.length > 2e4) {
+          output = output.slice(0, 2e4) + `
+... (truncated, ${output.length} total chars)`;
+        }
+        return output;
+      } catch (err) {
+        return `git_diff error: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "git_commit",
+    "Stage and commit changes to the git repository.",
+    {
+      type: "object",
+      properties: {
+        message: {
+          type: "string",
+          description: "The commit message."
+        },
+        repoPath: {
+          type: "string",
+          description: "Path to the git repository (relative to workspace). Defaults to workspace root."
+        },
+        all: {
+          type: "boolean",
+          description: "If true, stage all tracked changes (-a). Default: false."
+        },
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Specific files to stage before committing."
+        }
+      },
+      required: ["message"]
+    },
+    async (params) => {
+      try {
+        const cwd = resolveRepoPath(workspaceDir, params.repoPath);
+        const message = params.message;
+        const files = params.files;
+        if (files && files.length > 0) {
+          const fileArgs = files.map((f) => `"${f.replace(/"/g, '\\"')}"`).join(" ");
+          runGit(`add ${fileArgs}`, cwd);
+        }
+        const commitArgs = ["commit"];
+        if (params.all) commitArgs.push("-a");
+        commitArgs.push("-m", `"${message.replace(/"/g, '\\"')}"`);
+        const output = runGit(commitArgs.join(" "), cwd);
+        const firstLine = output.split("\n")[0] || "";
+        return `Committed: ${firstLine.trim()}`;
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        return `git_commit error: ${(stdout + "\n" + stderr).trim() || err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "git_log",
+    "Show recent commit history in a concise one-line-per-commit format.",
+    {
+      type: "object",
+      properties: {
+        repoPath: {
+          type: "string",
+          description: "Path to the git repository (relative to workspace). Defaults to workspace root."
+        },
+        count: {
+          type: "number",
+          description: "Number of recent commits to show (default: 10)."
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      try {
+        const cwd = resolveRepoPath(workspaceDir, params.repoPath);
+        const count = Math.min(Math.max(params.count || 10, 1), 100);
+        const output = runGit(`log --oneline -n ${count}`, cwd);
+        if (!output.trim()) {
+          return "No commits found.";
+        }
+        return output.trim();
+      } catch (err) {
+        return `git_log error: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "git_push",
+    "Push commits to a remote repository.",
+    {
+      type: "object",
+      properties: {
+        repoPath: {
+          type: "string",
+          description: "Path to the git repository (relative to workspace). Defaults to workspace root."
+        },
+        remote: {
+          type: "string",
+          description: "Remote name (default: 'origin')."
+        },
+        branch: {
+          type: "string",
+          description: "Branch to push. Defaults to the current branch."
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      try {
+        const cwd = resolveRepoPath(workspaceDir, params.repoPath);
+        const remote = params.remote || "origin";
+        const args = ["push", remote];
+        if (params.branch) {
+          args.push(params.branch);
+        }
+        const output = runGit(args.join(" "), cwd);
+        return `Push successful.${output.trim() ? "\n" + output.trim() : ""}`;
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        const combined = (stdout + "\n" + stderr).trim();
+        if (err.status === 0 || combined.includes("->")) {
+          return `Push successful.
+${combined}`;
+        }
+        return `git_push error: ${combined || err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/browser.ts
+import { resolve as resolve11 } from "path";
+import { mkdirSync as mkdirSync8, existsSync as existsSync10 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+var MAX_OUTPUT2 = 5e4;
+var browserInstance = null;
+var lastUsed = 0;
+var idleTimer = null;
+var IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+async function getBrowser() {
+  try {
+    const modName = "playwright";
+    const pw = await Function("m", "return import(m)")(modName);
+    if (!browserInstance) {
+      browserInstance = await pw.chromium.launch({ headless: true });
+      if (!idleTimer) {
+        idleTimer = setInterval(async () => {
+          if (browserInstance && Date.now() - lastUsed > IDLE_TIMEOUT_MS) {
+            await closeBrowser();
+          }
+        }, 6e4);
+      }
+    }
+    lastUsed = Date.now();
+    return browserInstance;
+  } catch {
+    throw new Error(
+      "Playwright is not installed. Run:\n  npm install playwright\n  npx playwright install chromium"
+    );
+  }
+}
+async function closeBrowser() {
+  if (browserInstance) {
+    try {
+      await browserInstance.close();
+    } catch {
+    }
+    browserInstance = null;
+  }
+  if (idleTimer) {
+    clearInterval(idleTimer);
+    idleTimer = null;
+  }
+}
+function registerBrowserTools(registry, workspaceDir) {
+  const screenshotDir = resolve11(workspaceDir, "screenshots");
+  registry.register(
+    "browse",
+    [
+      "Navigate to a URL and interact with the page using a headless browser.",
+      "Actions:",
+      "  extract (default) \u2014 get the readable text content of the page",
+      "  screenshot \u2014 take a PNG screenshot and return the file path",
+      "  click \u2014 click an element matching a CSS selector",
+      "  type \u2014 type text into an element matching a CSS selector",
+      "  evaluate \u2014 run arbitrary JavaScript in the page and return the result",
+      "Supports waitForSelector to wait for dynamic content before acting."
+    ].join("\n"),
+    {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "URL to navigate to."
+        },
+        action: {
+          type: "string",
+          enum: ["extract", "screenshot", "click", "type", "evaluate"],
+          description: "Action to perform (default: extract)."
+        },
+        selector: {
+          type: "string",
+          description: "CSS selector for click/type actions."
+        },
+        text: {
+          type: "string",
+          description: "Text to type (for 'type' action)."
+        },
+        javascript: {
+          type: "string",
+          description: "JavaScript to evaluate in the page (for 'evaluate' action)."
+        },
+        waitForSelector: {
+          type: "string",
+          description: "CSS selector to wait for before performing the action."
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 30000)."
+        }
+      },
+      required: ["url"]
+    },
+    async (params) => {
+      const url = params.url;
+      const action = params.action || "extract";
+      const selector = params.selector;
+      const text = params.text;
+      const javascript = params.javascript;
+      const waitForSelector = params.waitForSelector;
+      const timeout = params.timeout || 3e4;
+      let browser;
+      try {
+        browser = await getBrowser();
+      } catch (err) {
+        return err.message;
+      }
+      let page;
+      try {
+        page = await browser.newPage();
+        page.setDefaultTimeout(timeout);
+        await page.goto(url, { waitUntil: "domcontentloaded", timeout });
+        if (waitForSelector) {
+          await page.waitForSelector(waitForSelector, { timeout });
+        }
+        switch (action) {
+          case "extract": {
+            const content = await page.evaluate(() => {
+              const clone = document.body.cloneNode(true);
+              clone.querySelectorAll("script, style, noscript").forEach((el) => el.remove());
+              return clone.innerText || clone.textContent || "";
+            });
+            const trimmed = content.length > MAX_OUTPUT2 ? content.slice(0, MAX_OUTPUT2) + `
+... (truncated, ${content.length} total chars)` : content;
+            return trimmed;
+          }
+          case "screenshot": {
+            if (!existsSync10(screenshotDir)) {
+              mkdirSync8(screenshotDir, { recursive: true });
+            }
+            const filename = `${randomUUID5()}.png`;
+            const filepath = resolve11(screenshotDir, filename);
+            await page.screenshot({ path: filepath, fullPage: true });
+            return `Screenshot saved: ${filepath}`;
+          }
+          case "click": {
+            if (!selector) {
+              return "Error: 'selector' parameter is required for click action.";
+            }
+            await page.click(selector);
+            return `Clicked: ${selector}`;
+          }
+          case "type": {
+            if (!selector) {
+              return "Error: 'selector' parameter is required for type action.";
+            }
+            if (text === void 0) {
+              return "Error: 'text' parameter is required for type action.";
+            }
+            await page.fill(selector, text);
+            return `Typed into ${selector}: "${text}"`;
+          }
+          case "evaluate": {
+            if (!javascript) {
+              return "Error: 'javascript' parameter is required for evaluate action.";
+            }
+            const result = await page.evaluate(javascript);
+            const str = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+            if (str.length > MAX_OUTPUT2) {
+              return str.slice(0, MAX_OUTPUT2) + `
+... (truncated, ${str.length} total chars)`;
+            }
+            return str ?? "(no result)";
+          }
+          default:
+            return `Unknown action: ${action}. Use: extract, screenshot, click, type, evaluate.`;
+        }
+      } catch (err) {
+        return `browse error: ${err.message}`;
+      } finally {
+        if (page) {
+          try {
+            await page.close();
+          } catch {
+          }
+        }
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/system.ts
+import { execSync as execSync4 } from "child_process";
+import * as os from "os";
+var MAX_OUTPUT3 = 5e4;
+function truncate(output) {
+  if (output.length > MAX_OUTPUT3) {
+    return output.slice(0, MAX_OUTPUT3) + `
+... (truncated, ${output.length} total chars)`;
+  }
+  return output;
+}
+function exec(cmd, timeoutS = 10) {
+  return execSync4(cmd, {
+    encoding: "utf-8",
+    timeout: timeoutS * 1e3,
+    maxBuffer: 10 * 1024 * 1024,
+    shell: "/bin/sh",
+    env: { ...process.env, PATH: `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}` }
+  });
+}
+function registerSystemTools(registry) {
+  registry.register(
+    "system_info",
+    "Get system information: hostname, OS, architecture, uptime, CPU, memory, and disk usage.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      try {
+        const cpus2 = os.cpus();
+        const cpuModel = cpus2.length > 0 ? cpus2[0].model : "unknown";
+        const totalMem = os.totalmem();
+        const freeMem = os.freemem();
+        let disk = "unavailable";
+        try {
+          const dfOut = exec("df -h /");
+          const lines = dfOut.trim().split("\n");
+          if (lines.length >= 2) {
+            const parts = lines[1].split(/\s+/);
+            disk = `total=${parts[1]}, used=${parts[2]}, free=${parts[3]}`;
+          }
+        } catch {
+        }
+        const info = [
+          `hostname: ${os.hostname()}`,
+          `os: ${os.platform()} ${os.release()}`,
+          `arch: ${os.arch()}`,
+          `uptime: ${Math.floor(os.uptime() / 3600)}h ${Math.floor(os.uptime() % 3600 / 60)}m`,
+          `cpu: ${cpuModel} (${cpus2.length} cores)`,
+          `memory: ${fmt(freeMem)} free / ${fmt(totalMem)} total`,
+          `disk (/): ${disk}`
+        ];
+        return info.join("\n");
+      } catch (err) {
+        return `Error getting system info: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "process_list",
+    "List running processes. Optionally filter by name and limit results.",
+    {
+      type: "object",
+      properties: {
+        filter: {
+          type: "string",
+          description: "Filter processes by name (grep pattern)"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of processes to return (default 20)"
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const filter = params.filter;
+      const limit = params.limit || 20;
+      try {
+        let cmd;
+        if (filter) {
+          cmd = `ps aux | grep -i '${filter.replace(/'/g, "\\'")}' | grep -v grep | head -n ${limit}`;
+        } else {
+          cmd = `ps aux -r | head -n ${limit + 1}`;
+        }
+        const output = exec(cmd, 15);
+        return truncate(output) || "(no matching processes)";
+      } catch (err) {
+        return `Error listing processes: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "process_kill",
+    "Kill a process by PID. Refuses to kill PID 1 or the agent's own process.",
+    {
+      type: "object",
+      properties: {
+        pid: {
+          type: "number",
+          description: "Process ID to kill"
+        },
+        signal: {
+          type: "string",
+          description: "Signal to send (default: TERM). Examples: TERM, KILL, HUP, INT"
+        }
+      },
+      required: ["pid"]
+    },
+    async (params) => {
+      const pid = params.pid;
+      const signal = params.signal || "TERM";
+      if (pid === 1) {
+        return "Error: Refusing to kill PID 1 (init/launchd).";
+      }
+      if (pid === process.pid) {
+        return "Error: Refusing to kill the agent's own process.";
+      }
+      try {
+        const sig = signal.toUpperCase().startsWith("SIG") ? signal.toUpperCase() : `SIG${signal.toUpperCase()}`;
+        process.kill(pid, sig);
+        return `Sent ${sig} to PID ${pid}.`;
+      } catch (err) {
+        return `Error killing process ${pid}: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "service_control",
+    "Control launchd services on macOS. List, start, stop, restart, or check status of services.",
+    {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["start", "stop", "restart", "status", "list"],
+          description: "Action to perform"
+        },
+        service: {
+          type: "string",
+          description: "Service label (required for start/stop/restart/status)"
+        }
+      },
+      required: ["action"]
+    },
+    async (params) => {
+      const action = params.action;
+      const service = params.service;
+      try {
+        switch (action) {
+          case "list": {
+            const filter = service || "hivemind";
+            const output = exec(`launchctl list | grep -i '${filter.replace(/'/g, "\\'")}'`, 15);
+            return truncate(output) || `(no services matching '${filter}')`;
+          }
+          case "status": {
+            if (!service) return "Error: 'service' parameter required for status.";
+            const output = exec(`launchctl list '${service.replace(/'/g, "\\'")}'`, 15);
+            return truncate(output);
+          }
+          case "start": {
+            if (!service) return "Error: 'service' parameter required for start.";
+            exec(`launchctl start '${service.replace(/'/g, "\\'")}'`);
+            return `Started service: ${service}`;
+          }
+          case "stop": {
+            if (!service) return "Error: 'service' parameter required for stop.";
+            exec(`launchctl stop '${service.replace(/'/g, "\\'")}'`);
+            return `Stopped service: ${service}`;
+          }
+          case "restart": {
+            if (!service) return "Error: 'service' parameter required for restart.";
+            const escaped = service.replace(/'/g, "\\'");
+            exec(`launchctl stop '${escaped}'`);
+            exec(`launchctl start '${escaped}'`);
+            return `Restarted service: ${service}`;
+          }
+          default:
+            return `Error: Unknown action '${action}'. Use: start, stop, restart, status, list.`;
+        }
+      } catch (err) {
+        return `Error controlling service: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "disk_usage",
+    "Get disk usage for a directory. Returns human-readable sizes.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Directory path (default: /)"
+        },
+        depth: {
+          type: "number",
+          description: "Directory depth to report (default: 1)"
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const target = params.path || "/";
+      const depth = params.depth || 1;
+      try {
+        const output = exec(`du -d ${depth} -h '${target.replace(/'/g, "\\'")}'`, 30);
+        return truncate(output) || "(no output)";
+      } catch (err) {
+        return `Error getting disk usage: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "network_info",
+    "Get network interface information and external IP address.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      try {
+        const lines = [];
+        const interfaces = os.networkInterfaces();
+        lines.push("Local interfaces:");
+        for (const [name, addrs] of Object.entries(interfaces)) {
+          if (!addrs) continue;
+          for (const addr of addrs) {
+            if (addr.family === "IPv4") {
+              lines.push(`  ${name}: ${addr.address}`);
+            }
+          }
+        }
+        try {
+          const extIp = exec("curl -s --max-time 5 ifconfig.me", 10).trim();
+          lines.push(`
+External IP: ${extIp}`);
+        } catch {
+          lines.push("\nExternal IP: unavailable");
+        }
+        lines.push(`Hostname: ${os.hostname()}`);
+        return lines.join("\n");
+      } catch (err) {
+        return `Error getting network info: ${err.message}`;
+      }
+    }
+  );
+}
+function fmt(bytes) {
+  if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)}GB`;
+  if (bytes >= 1024 ** 2) return `${(bytes / 1024 ** 2).toFixed(0)}MB`;
+  return `${(bytes / 1024).toFixed(0)}KB`;
+}
+
+// packages/runtime/src/tools/http-server.ts
+import { createServer as createServer2 } from "http";
+import { createReadStream, existsSync as existsSync11, statSync as statSync2 } from "fs";
+import { join as join6, extname, resolve as resolve12 } from "path";
+var MAX_BODY = 5e4;
+var activeServers = /* @__PURE__ */ new Map();
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain"
+};
+function serveStatic(baseDir, req, res) {
+  const urlPath = (req.url || "/").split("?")[0];
+  let filePath = join6(baseDir, urlPath === "/" ? "index.html" : urlPath);
+  if (!resolve12(filePath).startsWith(resolve12(baseDir))) {
+    res.writeHead(403);
+    res.end("Forbidden");
+    return true;
+  }
+  if (!existsSync11(filePath)) return false;
+  const stat = statSync2(filePath);
+  if (stat.isDirectory()) {
+    filePath = join6(filePath, "index.html");
+    if (!existsSync11(filePath)) return false;
+  }
+  const ext = extname(filePath);
+  const mime = MIME_TYPES[ext] || "application/octet-stream";
+  res.writeHead(200, { "Content-Type": mime });
+  createReadStream(filePath).pipe(res);
+  return true;
+}
+function matchRoute(routes, req) {
+  const method = (req.method || "GET").toUpperCase();
+  const urlPath = (req.url || "/").split("?")[0];
+  return routes.find(
+    (r) => r.path === urlPath && r.method.toUpperCase() === method
+  );
+}
+function registerHttpTools(registry, workspaceDir) {
+  registry.register(
+    "http_serve",
+    "Start a simple HTTP server. Can serve static files from a directory and/or respond to configured routes. Returns the URL and port. The server persists until stopped with http_stop.",
+    {
+      type: "object",
+      properties: {
+        port: {
+          type: "number",
+          description: "Port to listen on (default: 8080)"
+        },
+        directory: {
+          type: "string",
+          description: "Serve static files from this directory (relative to workspace)"
+        },
+        routes: {
+          type: "array",
+          description: "Array of route handlers: { path, method, response }",
+          items: {
+            type: "object",
+            properties: {
+              path: { type: "string", description: "URL path (e.g. '/health')" },
+              method: { type: "string", description: "HTTP method (e.g. 'GET', 'POST')" },
+              response: { type: "string", description: "Response body to return" }
+            },
+            required: ["path", "method", "response"]
+          }
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const port = params.port || 8080;
+      const directory = params.directory;
+      const routes = params.routes || [];
+      if (activeServers.has(port)) {
+        return `Error: A server is already running on port ${port}. Stop it first with http_stop.`;
+      }
+      const staticDir = directory ? resolve12(workspaceDir, directory) : void 0;
+      if (staticDir && !existsSync11(staticDir)) {
+        return `Error: Directory not found: ${directory}`;
+      }
+      return new Promise((resolvePromise) => {
+        const server = createServer2((req, res) => {
+          const route = matchRoute(routes, req);
+          if (route) {
+            res.writeHead(200, { "Content-Type": "text/plain" });
+            res.end(route.response);
+            return;
+          }
+          if (staticDir && serveStatic(staticDir, req, res)) {
+            return;
+          }
+          res.writeHead(404);
+          res.end("Not Found");
+        });
+        server.on("error", (err) => {
+          resolvePromise(`Error starting server: ${err.message}`);
+        });
+        server.listen(port, () => {
+          activeServers.set(port, server);
+          const parts = [`Server started on http://localhost:${port}`];
+          if (staticDir) parts.push(`Serving static files from: ${directory}`);
+          if (routes.length > 0) parts.push(`Routes: ${routes.map((r) => `${r.method} ${r.path}`).join(", ")}`);
+          resolvePromise(parts.join("\n"));
+        });
+      });
+    }
+  );
+  registry.register(
+    "http_stop",
+    "Stop a running HTTP server by port number.",
+    {
+      type: "object",
+      properties: {
+        port: {
+          type: "number",
+          description: "Port of the server to stop"
+        }
+      },
+      required: ["port"]
+    },
+    async (params) => {
+      const port = params.port;
+      const server = activeServers.get(port);
+      if (!server) {
+        return `No server running on port ${port}. Active ports: ${activeServers.size > 0 ? [...activeServers.keys()].join(", ") : "none"}`;
+      }
+      return new Promise((resolvePromise) => {
+        server.close((err) => {
+          activeServers.delete(port);
+          if (err) {
+            resolvePromise(`Server on port ${port} stopped with warning: ${err.message}`);
+          } else {
+            resolvePromise(`Server on port ${port} stopped.`);
+          }
+        });
+      });
+    }
+  );
+  registry.register(
+    "http_request",
+    "Make an HTTP request (like curl). Supports GET, POST, PUT, PATCH, DELETE. Returns status, headers, and body.",
+    {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to request"
+        },
+        method: {
+          type: "string",
+          description: "HTTP method (default: 'GET')",
+          enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]
+        },
+        headers: {
+          type: "object",
+          description: "Request headers as key-value pairs"
+        },
+        body: {
+          type: "string",
+          description: "Request body (for POST, PUT, PATCH)"
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 30000)"
+        }
+      },
+      required: ["url"]
+    },
+    async (params) => {
+      const url = params.url;
+      const method = (params.method || "GET").toUpperCase();
+      const headers = params.headers || {};
+      const body = params.body;
+      const timeout = params.timeout || 3e4;
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body || void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        let responseBody = await response.text();
+        const truncated = responseBody.length > MAX_BODY;
+        if (truncated) {
+          responseBody = responseBody.slice(0, MAX_BODY);
+        }
+        const result = {
+          status: response.status,
+          statusText: response.statusText,
+          headers: responseHeaders,
+          body: responseBody,
+          truncated
+        };
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const message = err.message;
+        if (message.includes("abort")) {
+          return `Error: Request timed out after ${timeout}ms`;
+        }
+        return `Error: ${message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/watch.ts
+import { watch as watch3, existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7, resolve as resolve13 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+var activeWatchers = /* @__PURE__ */ new Map();
+function registerWatchTools(registry, workspaceDir, dataDir) {
+  const eventsDir = join7(dataDir, "events");
+  registry.register(
+    "watch_start",
+    "Start watching a file or directory for changes. When a change is detected, an immediate event is written to the events directory so the agent can react. Optionally specify a Sesame channel to notify.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File or directory to watch (relative to workspace)"
+        },
+        id: {
+          type: "string",
+          description: "Optional identifier for this watcher (auto-generated if omitted)"
+        },
+        channelId: {
+          type: "string",
+          description: "Sesame channel to notify when changes are detected"
+        }
+      },
+      required: ["path"]
+    },
+    async (params) => {
+      const relPath = params.path;
+      const id = params.id || randomUUID6().slice(0, 8);
+      const channelId = params.channelId;
+      if (activeWatchers.has(id)) {
+        return `Error: A watcher with id '${id}' already exists. Stop it first or use a different id.`;
+      }
+      const absolutePath = resolve13(workspaceDir, relPath);
+      if (!absolutePath.startsWith(resolve13(workspaceDir))) {
+        return "Error: Path must be within the workspace directory.";
+      }
+      if (!existsSync12(absolutePath)) {
+        return `Error: Path not found: ${relPath}`;
+      }
+      if (!existsSync12(eventsDir)) {
+        mkdirSync9(eventsDir, { recursive: true });
+      }
+      try {
+        let debounceTimer = null;
+        const fsWatcher = watch3(absolutePath, { recursive: true }, (eventType, filename) => {
+          if (debounceTimer) return;
+          debounceTimer = setTimeout(() => {
+            debounceTimer = null;
+          }, 500);
+          const event = {
+            type: "immediate",
+            channelId: channelId || "default",
+            text: `File watcher '${id}': ${eventType} detected on ${filename || relPath}`
+          };
+          const eventFile = join7(eventsDir, `watch-${id}-${Date.now()}.json`);
+          try {
+            writeFileSync5(eventFile, JSON.stringify(event, null, 2));
+          } catch {
+          }
+        });
+        const entry = {
+          id,
+          path: relPath,
+          absolutePath,
+          channelId,
+          watcher: fsWatcher,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        activeWatchers.set(id, entry);
+        return `Watcher started: id='${id}', path='${relPath}'${channelId ? `, channel='${channelId}'` : ""}`;
+      } catch (err) {
+        return `Error starting watcher: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "watch_stop",
+    "Stop a file watcher by its ID.",
+    {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Watcher ID to stop"
+        }
+      },
+      required: ["id"]
+    },
+    async (params) => {
+      const id = params.id;
+      const entry = activeWatchers.get(id);
+      if (!entry) {
+        const ids = activeWatchers.size > 0 ? [...activeWatchers.keys()].join(", ") : "none";
+        return `No watcher found with id '${id}'. Active watchers: ${ids}`;
+      }
+      entry.watcher.close();
+      activeWatchers.delete(id);
+      return `Watcher '${id}' stopped (was watching: ${entry.path}).`;
+    }
+  );
+  registry.register(
+    "watch_list",
+    "List all active file watchers with their paths and IDs.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      if (activeWatchers.size === 0) {
+        return "No active watchers.";
+      }
+      const lines = [];
+      for (const [id, entry] of activeWatchers) {
+        let line = `${id}: ${entry.path} (since ${entry.createdAt})`;
+        if (entry.channelId) line += ` \u2192 channel: ${entry.channelId}`;
+        lines.push(line);
+      }
+      return `${activeWatchers.size} active watcher(s):
+${lines.join("\n")}`;
+    }
+  );
+}
+
+// packages/runtime/src/tools/macos.ts
+import { execSync as execSync5 } from "child_process";
+import { resolve as resolve14, normalize as normalize2 } from "path";
+import { mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
+import { randomUUID as randomUUID7 } from "crypto";
+var MAX_OUTPUT4 = 5e4;
+function shellExec(command, timeoutMs) {
+  return execSync5(command, {
+    timeout: timeoutMs,
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024,
+    shell: "/bin/sh",
+    env: { ...process.env, PATH: `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}` }
+  });
+}
+function registerMacOSTools(registry, workspaceDir) {
+  registry.register(
+    "run_applescript",
+    "Execute AppleScript code via osascript. Enables controlling any Mac application (Finder, Safari, Mail, System Events, etc.).",
+    {
+      type: "object",
+      properties: {
+        script: {
+          type: "string",
+          description: "AppleScript code to execute."
+        }
+      },
+      required: ["script"]
+    },
+    async (params) => {
+      const script = params.script;
+      try {
+        const output = shellExec(`osascript -e ${escapeShellArg(script)}`, 15e3);
+        const trimmed = output.length > MAX_OUTPUT4 ? output.slice(0, MAX_OUTPUT4) + `
+... (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();
+        return `AppleScript error (exit code ${err.status ?? "unknown"}):
+${output || err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "notify",
+    "Send a macOS notification with a title, message, and optional sound.",
+    {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Notification title."
+        },
+        message: {
+          type: "string",
+          description: "Notification body text."
+        },
+        sound: {
+          type: "string",
+          description: "Sound name (e.g. 'Glass', 'Ping', 'Pop'). Default: 'default'."
+        }
+      },
+      required: ["title", "message"]
+    },
+    async (params) => {
+      const title = params.title;
+      const message = params.message;
+      const sound = params.sound || "default";
+      try {
+        const script = `display notification ${escapeAppleString(message)} with title ${escapeAppleString(title)} sound name ${escapeAppleString(sound)}`;
+        shellExec(`osascript -e ${escapeShellArg(script)}`, 1e4);
+        return `Notification sent: "${title}"`;
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        return `Notification error: ${stderr.trim() || err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "clipboard_read",
+    "Read the current contents of the macOS system clipboard.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      try {
+        const output = shellExec("pbpaste", 5e3);
+        if (!output) return "(clipboard is empty)";
+        if (output.length > MAX_OUTPUT4) {
+          return output.slice(0, MAX_OUTPUT4) + `
+... (truncated, ${output.length} total chars)`;
+        }
+        return output;
+      } catch (err) {
+        return `Clipboard read error: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "clipboard_write",
+    "Write text content to the macOS system clipboard.",
+    {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "Text to write to the clipboard."
+        }
+      },
+      required: ["content"]
+    },
+    async (params) => {
+      const content = params.content;
+      try {
+        execSync5("pbcopy", {
+          input: content,
+          timeout: 5e3,
+          encoding: "utf-8",
+          shell: "/bin/sh"
+        });
+        return `Copied ${content.length} chars to clipboard.`;
+      } catch (err) {
+        return `Clipboard write error: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "open_url",
+    "Open a URL in the default browser or a specified application.",
+    {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to open."
+        },
+        app: {
+          type: "string",
+          description: "Application name to open the URL with (e.g. 'Google Chrome', 'Safari')."
+        }
+      },
+      required: ["url"]
+    },
+    async (params) => {
+      const url = params.url;
+      const app = params.app;
+      try {
+        const args = app ? `open -a ${escapeShellArg(app)} ${escapeShellArg(url)}` : `open ${escapeShellArg(url)}`;
+        shellExec(args, 1e4);
+        return `Opened ${url}${app ? ` in ${app}` : ""}`;
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        return `open_url error: ${stderr.trim() || err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "screenshot",
+    "Take a screenshot of the screen and save it to a file.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Save path for the screenshot (relative to workspace). Defaults to screenshots/<uuid>.png."
+        },
+        region: {
+          type: "boolean",
+          description: "If true, enable interactive region selection. Default: false."
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      try {
+        let savePath;
+        if (params.path) {
+          savePath = resolve14(workspaceDir, params.path);
+          const normalizedSave = normalize2(savePath);
+          const normalizedWorkspace = normalize2(workspaceDir);
+          if (!normalizedSave.startsWith(normalizedWorkspace)) {
+            return "Error: path must be within the workspace.";
+          }
+        } else {
+          const screenshotDir = resolve14(workspaceDir, "screenshots");
+          if (!existsSync13(screenshotDir)) {
+            mkdirSync10(screenshotDir, { recursive: true });
+          }
+          savePath = resolve14(screenshotDir, `${randomUUID7()}.png`);
+        }
+        const parentDir = resolve14(savePath, "..");
+        if (!existsSync13(parentDir)) {
+          mkdirSync10(parentDir, { recursive: true });
+        }
+        const args = params.region ? `screencapture -i ${escapeShellArg(savePath)}` : `screencapture -x ${escapeShellArg(savePath)}`;
+        shellExec(args, 15e3);
+        if (!existsSync13(savePath)) {
+          return "Screenshot cancelled or failed \u2014 no file was created.";
+        }
+        return `Screenshot saved: ${savePath}`;
+      } catch (err) {
+        return `Screenshot error: ${err.message}`;
+      }
+    }
+  );
+}
+function escapeShellArg(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function escapeAppleString(s) {
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+// packages/runtime/src/tools/data.ts
+import { execSync as execSync6 } from "child_process";
+import { resolve as resolve15, normalize as normalize3, extname as extname2 } from "path";
+import { mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
+var MAX_OUTPUT5 = 5e4;
+function shellExec2(command, cwd, timeoutMs) {
+  return execSync6(command, {
+    cwd,
+    timeout: timeoutMs,
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024,
+    shell: "/bin/sh",
+    env: { ...process.env, PATH: `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}` }
+  });
+}
+function safePath(workspaceDir, filePath) {
+  const resolved = resolve15(workspaceDir, filePath);
+  const normalizedResolved = normalize3(resolved);
+  const normalizedWorkspace = normalize3(workspaceDir);
+  if (!normalizedResolved.startsWith(normalizedWorkspace)) {
+    throw new Error("Path traversal detected: path must be within the workspace.");
+  }
+  return resolved;
+}
+function escapeShellArg2(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function registerDataTools(registry, workspaceDir) {
+  registry.register(
+    "sqlite_query",
+    "Execute a SQL query against a SQLite database file. Returns JSON for SELECT queries, affected row info for INSERT/UPDATE/DELETE.",
+    {
+      type: "object",
+      properties: {
+        database: {
+          type: "string",
+          description: "Path to the .db file (relative to workspace)."
+        },
+        query: {
+          type: "string",
+          description: "SQL query to execute."
+        },
+        params: {
+          type: "array",
+          items: { type: "string" },
+          description: "Query parameters for ? placeholders."
+        }
+      },
+      required: ["database", "query"]
+    },
+    async (params) => {
+      const dbRelative = params.database;
+      const query = params.query;
+      const queryParams = params.params;
+      try {
+        const dbPath = safePath(workspaceDir, dbRelative);
+        if (!existsSync14(dbPath) && !query.trim().toUpperCase().startsWith("CREATE")) {
+          return `Error: database file not found: ${dbRelative}`;
+        }
+        let fullQuery = query;
+        if (queryParams && queryParams.length > 0) {
+          let paramIdx = 0;
+          fullQuery = query.replace(/\?/g, () => {
+            if (paramIdx < queryParams.length) {
+              const val = queryParams[paramIdx++];
+              return `'${val.replace(/'/g, "''")}'`;
+            }
+            return "?";
+          });
+        }
+        const isSelect = fullQuery.trim().toUpperCase().startsWith("SELECT") || fullQuery.trim().toUpperCase().startsWith("PRAGMA");
+        const modeFlag = isSelect ? "-json" : "";
+        const command = `sqlite3 ${modeFlag} ${escapeShellArg2(dbPath)} ${escapeShellArg2(fullQuery)}`;
+        const output = shellExec2(command, workspaceDir, 3e4);
+        if (!output.trim()) {
+          return isSelect ? "[]" : "Query executed successfully (no output).";
+        }
+        const trimmed = output.length > MAX_OUTPUT5 ? output.slice(0, MAX_OUTPUT5) + `
+... (truncated, ${output.length} total chars)` : output;
+        return trimmed;
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        const output = (stdout + "\n" + stderr).trim();
+        return `SQLite error: ${output || err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "archive_create",
+    "Create a zip or tar.gz archive from a file or directory.",
+    {
+      type: "object",
+      properties: {
+        source: {
+          type: "string",
+          description: "File or directory path to archive (relative to workspace)."
+        },
+        output: {
+          type: "string",
+          description: "Output archive path (relative to workspace)."
+        },
+        format: {
+          type: "string",
+          enum: ["zip", "tar.gz"],
+          description: "Archive format. Default: 'zip'."
+        }
+      },
+      required: ["source", "output"]
+    },
+    async (params) => {
+      const source = params.source;
+      const output = params.output;
+      const format = params.format || "zip";
+      try {
+        const sourcePath = safePath(workspaceDir, source);
+        const outputPath = safePath(workspaceDir, output);
+        if (!existsSync14(sourcePath)) {
+          return `Error: source not found: ${source}`;
+        }
+        const outputParent = resolve15(outputPath, "..");
+        if (!existsSync14(outputParent)) {
+          mkdirSync11(outputParent, { recursive: true });
+        }
+        let command;
+        if (format === "tar.gz") {
+          command = `tar czf ${escapeShellArg2(outputPath)} -C ${escapeShellArg2(resolve15(sourcePath, ".."))} ${escapeShellArg2(sourcePath.split("/").pop())}`;
+        } else {
+          command = `zip -r ${escapeShellArg2(outputPath)} ${escapeShellArg2(source)}`;
+        }
+        shellExec2(command, workspaceDir, 6e4);
+        return `Archive created: ${output}`;
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        return `Archive error: ${stderr.trim() || err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "archive_extract",
+    "Extract a zip or tar.gz archive.",
+    {
+      type: "object",
+      properties: {
+        archive: {
+          type: "string",
+          description: "Path to the archive file (relative to workspace)."
+        },
+        destination: {
+          type: "string",
+          description: "Extraction directory (relative to workspace). Defaults to workspace root."
+        }
+      },
+      required: ["archive"]
+    },
+    async (params) => {
+      const archive = params.archive;
+      const destination = params.destination;
+      try {
+        const archivePath = safePath(workspaceDir, archive);
+        const destPath = destination ? safePath(workspaceDir, destination) : workspaceDir;
+        if (!existsSync14(archivePath)) {
+          return `Error: archive not found: ${archive}`;
+        }
+        if (!existsSync14(destPath)) {
+          mkdirSync11(destPath, { recursive: true });
+        }
+        const ext = extname2(archivePath).toLowerCase();
+        const isGz = archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz");
+        let command;
+        if (isGz || ext === ".tar") {
+          const flags = isGz ? "xzf" : "xf";
+          command = `tar ${flags} ${escapeShellArg2(archivePath)} -C ${escapeShellArg2(destPath)}`;
+        } else if (ext === ".zip") {
+          command = `unzip -o ${escapeShellArg2(archivePath)} -d ${escapeShellArg2(destPath)}`;
+        } else {
+          return `Error: unsupported archive format: ${ext}. Supported: .zip, .tar, .tar.gz, .tgz`;
+        }
+        const output = shellExec2(command, workspaceDir, 6e4);
+        const trimmed = output.length > MAX_OUTPUT5 ? output.slice(0, MAX_OUTPUT5) + `
+... (truncated)` : output;
+        return `Extracted to ${destination || "workspace root"}.
+${trimmed}`.trim();
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        return `Extract error: ${stderr.trim() || err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "pdf_extract",
+    "Extract text content from a PDF file. Tries pdftotext (poppler), then textutil, then basic string extraction.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the PDF file (relative to workspace)."
+        }
+      },
+      required: ["path"]
+    },
+    async (params) => {
+      const filePath = params.path;
+      try {
+        const pdfPath = safePath(workspaceDir, filePath);
+        if (!existsSync14(pdfPath)) {
+          return `Error: PDF not found: ${filePath}`;
+        }
+        try {
+          const output = shellExec2(`pdftotext ${escapeShellArg2(pdfPath)} -`, workspaceDir, 3e4);
+          if (output.trim()) {
+            return truncate2(output);
+          }
+        } catch {
+        }
+        try {
+          const output = shellExec2(`textutil -convert txt -stdout ${escapeShellArg2(pdfPath)}`, workspaceDir, 3e4);
+          if (output.trim()) {
+            return truncate2(output);
+          }
+        } catch {
+        }
+        try {
+          const output = shellExec2(`strings ${escapeShellArg2(pdfPath)} | head -1000`, workspaceDir, 15e3);
+          if (output.trim()) {
+            return `(basic extraction \u2014 install poppler for better results)
+${truncate2(output)}`;
+          }
+        } catch {
+        }
+        return "Error: could not extract text from PDF. Install poppler (brew install poppler) for best results.";
+      } catch (err) {
+        return `PDF extraction error: ${err.message}`;
+      }
+    }
+  );
+}
+function truncate2(text) {
+  if (text.length > MAX_OUTPUT5) {
+    return text.slice(0, MAX_OUTPUT5) + `
+... (truncated, ${text.length} total chars)`;
+  }
+  return text;
+}
+
+// packages/runtime/src/tools/register.ts
+import { resolve as resolve16 } from "path";
+import { mkdirSync as mkdirSync12, existsSync as existsSync15 } from "fs";
+function registerAllTools(hivemindHome, config) {
+  const registry = new ToolRegistry();
+  if (config?.enabled === false) {
+    return registry;
+  }
+  const workspaceDir = resolve16(hivemindHome, config?.workspace || "workspace");
+  if (!existsSync15(workspaceDir)) {
+    mkdirSync12(workspaceDir, { recursive: true });
+  }
+  registerShellTool(registry, workspaceDir);
+  registerFileTools(registry, workspaceDir);
+  registerWebTools(registry, { braveApiKey: config?.braveApiKey });
+  registerMemoryTools(registry, config?.memoryDaemonUrl || "http://localhost:3434");
+  const dataDir = resolve16(hivemindHome, "data");
+  registerEventTools(registry, dataDir);
+  if (config?.configPath && !process.env.SPAWN_TASK) {
+    registerSpawnTools(registry, hivemindHome, dataDir, config.configPath);
+  }
+  registerVisionTools(registry);
+  registerGitTools(registry, workspaceDir);
+  registerBrowserTools(registry, workspaceDir);
+  registerSystemTools(registry);
+  registerHttpTools(registry, workspaceDir);
+  registerWatchTools(registry, workspaceDir, dataDir);
+  registerMacOSTools(registry, workspaceDir);
+  registerDataTools(registry, workspaceDir);
+  return registry;
+}
+
+// packages/runtime/src/tools/messaging.ts
+function registerMessagingTools(registry, sesame) {
+  registry.register(
+    "send_message",
+    "Send a message to a Sesame channel. Use this to proactively reach out to a user or group, not just reply to incoming messages.",
+    {
+      type: "object",
+      properties: {
+        channelId: {
+          type: "string",
+          description: "The Sesame channel ID to send the message to"
+        },
+        content: {
+          type: "string",
+          description: "The message content to send"
+        }
+      },
+      required: ["channelId", "content"]
+    },
+    async (params) => {
+      const channelId = params.channelId;
+      const content = params.content;
+      try {
+        await sesame.sendMessage(channelId, content);
+        return `Message sent to channel ${channelId}`;
+      } catch (err) {
+        return `Error sending message: ${err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/skills-tools.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync13, writeFileSync as writeFileSync6, rmSync } from "fs";
+import { resolve as resolve17 } from "path";
+function registerSkillsTools(registry, skillsEngine, workspaceDir) {
+  const skillsDir = resolve17(workspaceDir, "skills");
+  registry.register(
+    "skill_list",
+    "List all loaded skills with their registered tools and status.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      const skills = skillsEngine.listSkills();
+      if (skills.length === 0) {
+        return "No skills loaded. Create one with skill_create or add a SKILL.md to workspace/skills/<name>/.";
+      }
+      const lines = [];
+      for (const skill of skills) {
+        let line = `${skill.dirName} \u2014 "${skill.name}"`;
+        if (skill.description) line += `: ${skill.description}`;
+        if (skill.tools.length > 0) {
+          line += `
+  tools: ${skill.tools.join(", ")}`;
+        } else {
+          line += `
+  tools: (none)`;
+        }
+        lines.push(line);
+      }
+      return `${skills.length} skill(s) loaded:
+
+${lines.join("\n\n")}`;
+    }
+  );
+  registry.register(
+    "skill_create",
+    "Create a new skill with optional tool definitions. Creates the skill directory, SKILL.md, and optionally tools.json, then auto-loads it.",
+    {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Directory name for the skill (lowercase, hyphens ok)"
+        },
+        description: {
+          type: "string",
+          description: "Human-readable description of what the skill does"
+        },
+        tools: {
+          type: "array",
+          description: "Optional array of tool definitions (each with name, description, parameters, command)",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              description: { type: "string" },
+              parameters: { type: "object" },
+              command: { type: "string" }
+            },
+            required: ["name", "command"]
+          }
+        }
+      },
+      required: ["name", "description"]
+    },
+    async (params) => {
+      const name = params.name;
+      const description = params.description;
+      const tools = params.tools;
+      const skillDir = resolve17(skillsDir, name);
+      if (existsSync16(skillDir)) {
+        return `Error: Skill directory "${name}" already exists. Use skill_reload to update it.`;
+      }
+      mkdirSync13(skillDir, { recursive: true });
+      const skillMd = `---
+name: "${name}"
+description: "${description}"
+---
+
+# ${name}
+
+${description}
+`;
+      writeFileSync6(resolve17(skillDir, "SKILL.md"), skillMd);
+      if (tools && tools.length > 0) {
+        const toolsDef = {
+          tools: tools.map((t) => ({
+            name: t.name,
+            description: t.description || `Tool from skill "${name}"`,
+            parameters: t.parameters || { type: "object", properties: {}, required: [] },
+            command: t.command
+          }))
+        };
+        writeFileSync6(resolve17(skillDir, "tools.json"), JSON.stringify(toolsDef, null, 2) + "\n");
+      }
+      try {
+        await skillsEngine.loadSkill(name);
+      } catch (err) {
+        return `Skill files created at ${skillDir} but failed to load: ${err.message}`;
+      }
+      const toolSuffix = tools && tools.length > 0 ? ` with ${tools.length} tool(s): ${tools.map((t) => t.name).join(", ")}` : "";
+      return `Skill "${name}" created${toolSuffix} and loaded.
+Path: ${skillDir}`;
+    }
+  );
+  registry.register(
+    "skill_reload",
+    "Reload a skill to pick up file changes (re-reads SKILL.md and tools.json, re-runs setup.sh).",
+    {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "The directory name of the skill to reload"
+        }
+      },
+      required: ["name"]
+    },
+    async (params) => {
+      const name = params.name;
+      try {
+        await skillsEngine.reloadSkill(name);
+        const skill = skillsEngine.getSkill(name);
+        if (!skill) return `Error: Skill "${name}" not found after reload.`;
+        const toolSuffix = skill.tools.length > 0 ? ` (tools: ${skill.tools.join(", ")})` : " (no tools)";
+        return `Skill "${skill.name}" reloaded${toolSuffix}.`;
+      } catch (err) {
+        return `Error reloading skill "${name}": ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "skill_delete",
+    "Delete a skill entirely \u2014 unloads it, removes its tools, and deletes the skill directory.",
+    {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "The directory name of the skill to delete"
+        }
+      },
+      required: ["name"]
+    },
+    async (params) => {
+      const name = params.name;
+      const skillDir = resolve17(skillsDir, name);
+      if (!existsSync16(skillDir)) {
+        return `Error: Skill directory "${name}" does not exist.`;
+      }
+      try {
+        await skillsEngine.unloadSkill(name);
+      } catch (err) {
+        console.warn(`[skills] Error during unload of "${name}":`, err.message);
+      }
+      try {
+        rmSync(skillDir, { recursive: true, force: true });
+      } catch (err) {
+        return `Skill unloaded but failed to delete directory: ${err.message}`;
+      }
+      return `Skill "${name}" deleted.`;
+    }
+  );
+}
+
+// packages/runtime/src/pipeline.ts
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3 } from "fs";
+import { resolve as resolve18, dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var PACKAGE_VERSION = "unknown";
+try {
+  const __dirname2 = dirname7(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync12(resolve18(__dirname2, "../package.json"), "utf-8"));
+  PACKAGE_VERSION = pkg.version ?? "unknown";
+} catch {
+}
+var sesameConnected = false;
+var memoryConnected = false;
+var startTime = Date.now();
+function startHealthServer(port) {
+  const server = createServer3((req, res) => {
+    if (req.method === "GET" && req.url === HEALTH_PATH) {
+      const status = {
+        status: sesameConnected ? "ok" : "degraded",
+        pid: process.pid,
+        uptime_s: Math.floor((Date.now() - startTime) / 1e3),
+        sesame_connected: sesameConnected,
+        memory_connected: memoryConnected,
+        version: PACKAGE_VERSION
+      };
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(status));
+    } else {
+      res.writeHead(404);
+      res.end();
+    }
+  });
+  server.listen(port, "127.0.0.1", () => {
+    console.log(`[hivemind] Health endpoint listening on http://127.0.0.1:${port}${HEALTH_PATH}`);
+  });
+  return server;
+}
+function writePidFile(path) {
+  writeFileSync7(path, String(process.pid));
+  console.log(`[hivemind] PID file written: ${path}`);
+}
+function cleanupPidFile(path) {
+  try {
+    unlinkSync3(path);
+  } catch {
+  }
+}
+async function startPipeline(configPath) {
+  const config = loadConfig(configPath);
+  if (process.env.SPAWN_TASK) {
+    await runSpawnTask(config, configPath);
+    return;
+  }
+  const sentinel = config.sentinel ?? defaultSentinelConfig();
+  const healthPort = sentinel.health_port || HEALTH_PORT;
+  const pidFile = sentinel.pid_file;
+  console.log(`[hivemind] Starting ${config.agent.name} (pid ${process.pid})`);
+  writePidFile(pidFile);
+  const healthServer = startHealthServer(healthPort);
+  const cleanupOnExit = () => {
+    cleanupPidFile(pidFile);
+    healthServer.close();
+  };
+  process.on("exit", cleanupOnExit);
+  const memory = new MemoryClient(config.memory);
+  const memoryOk = await memory.healthCheck();
+  if (!memoryOk) {
+    console.warn("[hivemind] Memory daemon unreachable at", config.memory.daemon_url);
+    console.warn("[hivemind] Continuing without persistent memory \u2014 episodes will not be stored");
+  } else {
+    memoryConnected = true;
+    console.log("[hivemind] Memory daemon connected");
+  }
+  const requestLogger = new RequestLogger(resolve18(dirname7(configPath), "data", "dashboard.db"));
+  startDashboardServer(requestLogger, config.memory);
+  const agent = new Agent(config);
+  agent.setRequestLogger(requestLogger);
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve18(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,
+    configPath
+  });
+  const workspaceDir = resolve18(hivemindHome, config.agent.workspace || "workspace");
+  const skillsEngine = new SkillsEngine(workspaceDir, toolRegistry);
+  await skillsEngine.loadAll();
+  registerSkillsTools(toolRegistry, skillsEngine, workspaceDir);
+  skillsEngine.startWatching();
+  process.on("exit", () => skillsEngine.stopWatching());
+  agent.setToolRegistry(toolRegistry);
+  console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
+  const dataDir = resolve18(hivemindHome, "data");
+  if (config.sesame.api_key) {
+    await startSesameLoop(config, agent, toolRegistry, dataDir);
+  } else {
+    console.log("[hivemind] No Sesame API key configured \u2014 running in stdin mode");
+    await startStdinLoop(agent);
+  }
+}
+async function startSesameLoop(config, agent, toolRegistry, dataDir) {
+  const sesame = new SesameClient2(config.sesame);
+  registerMessagingTools(toolRegistry, sesame);
+  let eventsWatcher = null;
+  if (dataDir) {
+    eventsWatcher = new EventsWatcher(dataDir, async (channelId, text, filename, eventType) => {
+      console.log(`[events] Firing ${eventType} event from ${filename}`);
+      const eventMessage = `[EVENT:${filename}:${eventType}] ${text}`;
+      try {
+        const response = await agent.processMessage(eventMessage);
+        if (response.content.trim() === "[SILENT]" || response.content.trim().startsWith("[SILENT]")) {
+          console.log(`[events] Silent response for ${filename}`);
+          return;
+        }
+        if (response.content.trim() === "__SKIP__") return;
+        if (channelId) {
+          await sesame.sendMessage(channelId, response.content);
+        }
+      } catch (err) {
+        console.error(`[events] Error processing event ${filename}:`, err.message);
+      }
+    });
+    eventsWatcher.start();
+  }
+  let shuttingDown = false;
+  const shutdown = (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(`
+[hivemind] Received ${signal}, shutting down...`);
+    try {
+      sesame.updatePresence("offline", { emoji: "\u2B58" });
+      sesame.disconnect();
+      console.log("[hivemind] Sesame disconnected cleanly");
+    } catch (err) {
+      console.error("[hivemind] Error during disconnect:", err.message);
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  const processedIds = /* @__PURE__ */ new Set();
+  const MAX_SEEN = 500;
+  let processing = false;
+  const messageQueue = [];
+  async function processQueue() {
+    if (processing || messageQueue.length === 0) return;
+    processing = true;
+    while (messageQueue.length > 0) {
+      const msg = messageQueue.shift();
+      await handleMessage(msg);
+    }
+    processing = false;
+  }
+  sesame.onMessage(async (msg) => {
+    if (shuttingDown) return;
+    if (processedIds.has(msg.id)) {
+      console.log(`[sesame] Skipping duplicate message ${msg.id}`);
       return;
     }
     processedIds.add(msg.id);
@@ -3555,13 +5953,56 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve10) => {
-    rl.on("close", resolve10);
+  return new Promise((resolve19) => {
+    rl.on("close", resolve19);
+  });
+}
+async function runSpawnTask(config, configPath) {
+  const task = process.env.SPAWN_TASK;
+  const spawnId = process.env.SPAWN_ID || "unknown";
+  const context = process.env.SPAWN_CONTEXT || `spawn-${spawnId.slice(0, 8)}`;
+  const channelId = process.env.SPAWN_CHANNEL_ID;
+  const spawnDir = process.env.SPAWN_DIR;
+  console.log(`[spawn] Sub-agent starting (id: ${spawnId}, context: ${context})`);
+  const agent = new Agent(config, context);
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve18(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);
+  try {
+    const response = await agent.processMessage(task);
+    const result = response.content;
+    console.log(`[spawn] Task completed (context: ${response.context})`);
+    if (spawnDir) {
+      writeFileSync7(resolve18(spawnDir, "result.txt"), result);
+    }
+    if (channelId && config.sesame.api_key) {
+      try {
+        const sesame = new SesameClient2(config.sesame);
+        await sesame.connect();
+        await sesame.sendMessage(channelId, result);
+        sesame.disconnect();
+        console.log(`[spawn] Result sent to channel ${channelId}`);
+      } catch (err) {
+        console.error(`[spawn] Failed to send result to channel:`, err.message);
+      }
+    }
+  } catch (err) {
+    const errorMsg = `[SPAWN ERROR] ${err.message}`;
+    console.error(`[spawn] ${errorMsg}`);
+    if (spawnDir) {
+      writeFileSync7(resolve18(spawnDir, "result.txt"), errorMsg);
+    }
+    process.exitCode = 1;
+  }
 }
 
 // packages/runtime/src/fleet/worker-server.ts
-import { createServer as createServer3 } from "http";
+import { createServer as createServer4 } from "http";
 var WorkerServer = class {
   server = null;
   workerId;
@@ -3585,20 +6026,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve10, reject) => {
-      this.server = createServer3((req, res) => this.handleRequest(req, res));
+    return new Promise((resolve19, reject) => {
+      this.server = createServer4((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve10());
+      this.server.listen(this.port, () => resolve19());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve10) => {
+    return new Promise((resolve19) => {
       if (!this.server) {
-        resolve10();
+        resolve19();
         return;
       }
-      this.server.close(() => resolve10());
+      this.server.close(() => resolve19());
     });
   }
   getPort() {
@@ -3721,10 +6162,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve19, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve10(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve19(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -3998,7 +6439,7 @@ export {
   buildSystemPrompt,
   buildMessages,
   SessionStore,
-  estimateTokens,
+  estimateTokens2 as estimateTokens,
   estimateMessageTokens,
   getModelContextWindow,
   CompactionManager,
@@ -4008,6 +6449,7 @@ export {
   loadConfig,
   SesameClient2 as SesameClient,
   HEALTH_PATH,
+  SkillsEngine,
   startPipeline,
   PRIMARY_ROUTES,
   WORKER_ROUTES,
@@ -4057,4 +6499,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-G6PPTVAS.js.map
+//# sourceMappingURL=chunk-A7X4FKQZ.js.map