@sesamespace/hivemind 0.6.0 → 0.7.0

package/dist/{chunk-LQ7CYHSQ.js → chunk-DXQ3GROV.js}

@@ -37,27 +37,43 @@ var LLMClient = class {
       body.tools = tools;
       body.tool_choice = "auto";
     }
-    const resp = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
-      },
-      body: JSON.stringify(body)
-    });
-    if (!resp.ok) {
-      const text = await resp.text();
-      throw new Error(`LLM request failed: ${resp.status} ${text}`);
+    const RETRYABLE_CODES = [429, 500, 502, 503, 529];
+    const MAX_RETRIES = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      if (attempt > 0) {
+        const delayMs = Math.pow(2, attempt) * 1e3;
+        console.log(`[llm] Retry ${attempt}/${MAX_RETRIES} after ${delayMs}ms...`);
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+      const resp = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+        },
+        body: JSON.stringify(body)
+      });
+      if (!resp.ok) {
+        const text = await resp.text();
+        lastError = new Error(`LLM request failed: ${resp.status} ${text}`);
+        if (RETRYABLE_CODES.includes(resp.status) && attempt < MAX_RETRIES) {
+          console.warn(`[llm] Retryable error ${resp.status}: ${text.slice(0, 200)}`);
+          continue;
+        }
+        throw lastError;
+      }
+      const data = await resp.json();
+      const choice = data.choices[0];
+      return {
+        content: choice.message.content ?? "",
+        model: data.model,
+        tool_calls: choice.message.tool_calls,
+        finish_reason: choice.finish_reason,
+        usage: data.usage
+      };
     }
-    const data = await resp.json();
-    const choice = data.choices[0];
-    return {
-      content: choice.message.content ?? "",
-      model: data.model,
-      tool_calls: choice.message.tool_calls,
-      finish_reason: choice.finish_reason,
-      usage: data.usage
-    };
+    throw lastError ?? new Error("LLM request failed after retries");
   }
 };
 
@@ -472,6 +488,92 @@ var TaskEngine = class {
 // packages/runtime/src/prompt.ts
 import { readFileSync, existsSync, readdirSync } from "fs";
 import { resolve } from "path";
+function loadMemoryFiles(workspace, contextName) {
+  const result = { global: null, context: null };
+  if (!workspace) return result;
+  const globalPath = resolve(workspace, "MEMORY.md");
+  if (existsSync(globalPath)) {
+    try {
+      const content = readFileSync(globalPath, "utf-8").trim();
+      if (content) result.global = content;
+    } catch {
+    }
+  }
+  if (contextName !== "global") {
+    const contextPath = resolve(workspace, "contexts", contextName, "MEMORY.md");
+    if (existsSync(contextPath)) {
+      try {
+        const content = readFileSync(contextPath, "utf-8").trim();
+        if (content) result.context = content;
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function discoverSkills(workspace) {
+  if (!workspace) return [];
+  const skillsDir = resolve(workspace, "skills");
+  if (!existsSync(skillsDir)) return [];
+  const skills = [];
+  try {
+    const entries = readdirSync(skillsDir);
+    for (const entry of entries) {
+      const skillMdPath = resolve(skillsDir, entry, "SKILL.md");
+      if (!existsSync(skillMdPath)) continue;
+      try {
+        const content = readFileSync(skillMdPath, "utf-8");
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        let name = entry;
+        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, "");
+        }
+        skills.push({ name, description, path: skillMdPath });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+function buildEventsDoc(dataDir) {
+  if (!dataDir) return "";
+  return `
+## Events (Scheduling)
+You can schedule events by writing JSON files to the events directory.
+
+### Event Types
+- **immediate**: Triggers as soon as the file is created
+  \`{"type": "immediate", "channelId": "<channel>", "text": "Your message"}\`
+- **one-shot**: Triggers once at a specific time, then auto-deletes
+  \`{"type": "one-shot", "channelId": "<channel>", "text": "Reminder text", "at": "2026-03-01T09:00:00-08:00"}\`
+- **periodic**: Triggers on a cron schedule
+  \`{"type": "periodic", "channelId": "<channel>", "text": "Check inbox", "schedule": "0 9 * * 1-5", "timezone": "America/Los_Angeles"}\`
+
+### Cron Format
+\`minute hour day-of-month month day-of-week\`
+- \`0 9 * * *\` = daily at 9:00
+- \`0 9 * * 1-5\` = weekdays at 9:00
+- \`*/30 * * * *\` = every 30 minutes
+
+### Creating Events
+Use the write_file tool to create JSON files in the events directory.
+Use unique filenames (include timestamp or description): \`reminder-dentist-1709312400.json\`
+
+### Managing Events
+- List: use shell tool \`ls ~/hivemind/data/events/\`
+- Delete/cancel: use shell tool \`rm ~/hivemind/data/events/filename.json\`
+
+### Silent Completion
+For periodic events with nothing to report, respond with exactly \`[SILENT]\` (no other text).
+This prevents spamming the channel.
+`;
+}
 var charterCache = null;
 function loadCharter(path) {
   if (charterCache && charterCache.path === path) return charterCache.content;
@@ -530,7 +632,19 @@ function loadWorkspaceFiles(dir) {
   }
   return files;
 }
-function buildSystemPrompt(config, episodes, contextName = "global", l3Knowledge = []) {
+function buildSystemPrompt(configOrOpts, episodes, contextName = "global", l3Knowledge = []) {
+  let config;
+  let dataDir;
+  if ("config" in configOrOpts) {
+    config = configOrOpts.config;
+    episodes = configOrOpts.episodes;
+    contextName = configOrOpts.contextName ?? "global";
+    l3Knowledge = configOrOpts.l3Knowledge ?? [];
+    dataDir = configOrOpts.dataDir;
+  } else {
+    config = configOrOpts;
+  }
+  const resolvedEpisodes = episodes ?? [];
   let prompt = `You are ${config.name}. ${config.personality}
 `;
   let identityText = prompt;
@@ -575,6 +689,36 @@ You are currently working in the "${contextName}" project context.
 `;
     prompt += contextInfo;
   }
+  const memoryFiles = loadMemoryFiles(config.workspace, contextName);
+  if (memoryFiles.global || memoryFiles.context) {
+    prompt += "\n## Working Memory (agent-managed)\n";
+    if (memoryFiles.global) {
+      prompt += `
+### Global Memory
+${memoryFiles.global}
+`;
+    }
+    if (memoryFiles.context) {
+      prompt += `
+### ${contextName} Memory
+${memoryFiles.context}
+`;
+    }
+    prompt += "\nUpdate these files with write_file when you learn something important. They persist across sessions.\n";
+  }
+  const skills = discoverSkills(config.workspace);
+  if (skills.length > 0) {
+    prompt += "\n## Available Skills\n\n";
+    for (const skill of skills) {
+      prompt += `- **${skill.name}**: ${skill.description} \u2192 read \`${skill.path}\` for instructions
+`;
+    }
+    prompt += "\nTo use a skill, read its SKILL.md with read_file. To create a new skill, write a SKILL.md to workspace/skills/<name>/SKILL.md\n";
+  }
+  const eventsDoc = buildEventsDoc(dataDir);
+  if (eventsDoc) {
+    prompt += eventsDoc;
+  }
   if (l3Knowledge.length > 0) {
     prompt += "\n## Established Knowledge (learned patterns)\n\n";
     for (const entry of l3Knowledge) {
@@ -582,9 +726,9 @@ You are currently working in the "${contextName}" project context.
 `;
     }
   }
-  if (episodes.length > 0) {
+  if (resolvedEpisodes.length > 0) {
     prompt += "\n## Relevant memories from previous conversations\n\n";
-    for (const ep of episodes) {
+    for (const ep of resolvedEpisodes) {
       const timeAgo = formatTimeAgo(ep.timestamp);
       const ctxLabel = ep.context_name !== contextName ? ` [from: ${ep.context_name}]` : "";
       prompt += `[${timeAgo}]${ctxLabel} ${ep.role}: ${ep.content}
@@ -597,7 +741,7 @@ You are currently working in the "${contextName}" project context.
     components: {
       identity: identityText,
       l3Knowledge: l3Knowledge.map((e) => e.content),
-      l2Episodes: episodes.map((ep) => ({
+      l2Episodes: resolvedEpisodes.map((ep) => ({
         id: ep.id,
         content: ep.content,
         score: ep.score,
@@ -630,7 +774,260 @@ function formatTimeAgo(timestamp) {
   return date.toLocaleDateString();
 }
 
+// packages/runtime/src/session.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, appendFileSync } from "fs";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+var SessionStore = class {
+  sessionDir;
+  constructor(dataDir) {
+    this.sessionDir = join2(dataDir, "sessions");
+    if (!existsSync2(this.sessionDir)) {
+      mkdirSync(this.sessionDir, { recursive: true });
+    }
+  }
+  filePath(contextName) {
+    const safe = contextName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join2(this.sessionDir, `${safe}.jsonl`);
+  }
+  /**
+   * Append a message to the session JSONL file.
+   */
+  append(contextName, message, parentId) {
+    const fp = this.filePath(contextName);
+    const entry = {
+      id: randomUUID(),
+      parentId: parentId ?? null,
+      role: message.role,
+      content: message.content,
+      tool_calls: message.tool_calls,
+      tool_call_id: message.tool_call_id,
+      timestamp: Date.now()
+    };
+    appendFileSync(fp, JSON.stringify(entry) + "\n");
+    return entry.id;
+  }
+  /**
+   * Load all messages from a context's session file.
+   */
+  load(contextName) {
+    const fp = this.filePath(contextName);
+    if (!existsSync2(fp)) return [];
+    const lines = readFileSync2(fp, "utf-8").trim().split("\n").filter(Boolean);
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        const msg = {
+          role: entry.role,
+          content: entry.content
+        };
+        if (entry.tool_calls) msg.tool_calls = entry.tool_calls;
+        if (entry.tool_call_id) msg.tool_call_id = entry.tool_call_id;
+        messages.push(msg);
+      } catch {
+      }
+    }
+    return messages;
+  }
+  /**
+   * Get the N most recent messages from a context.
+   */
+  getRecentMessages(contextName, n) {
+    const all = this.load(contextName);
+    return all.slice(-n);
+  }
+  /**
+   * Simple string search across a context's history.
+   * Returns matching entries with timestamps.
+   */
+  grep(contextName, query, limit = 20) {
+    const fp = this.filePath(contextName);
+    if (!existsSync2(fp)) return [];
+    const lines = readFileSync2(fp, "utf-8").trim().split("\n").filter(Boolean);
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.content && entry.content.toLowerCase().includes(lowerQuery)) {
+          results.push({
+            role: entry.role,
+            content: entry.content,
+            timestamp: entry.timestamp
+          });
+        }
+      } catch {
+      }
+    }
+    return results.slice(-limit);
+  }
+  /**
+   * Get total message count for a context.
+   */
+  messageCount(contextName) {
+    const fp = this.filePath(contextName);
+    if (!existsSync2(fp)) return 0;
+    const content = readFileSync2(fp, "utf-8").trim();
+    if (!content) return 0;
+    return content.split("\n").length;
+  }
+};
+function estimateTokens(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.tool_calls) {
+      for (const call of msg.tool_calls) {
+        total += estimateTokens(call.function.name);
+        total += estimateTokens(call.function.arguments);
+      }
+    }
+  }
+  total += messages.length * 4;
+  return total;
+}
+var MODEL_CONTEXT_WINDOWS = {
+  "claude-sonnet-4.5": 2e5,
+  "claude-sonnet-4-5": 2e5,
+  "anthropic/claude-sonnet-4.5": 2e5,
+  "anthropic/claude-sonnet-4-5-20250514": 2e5,
+  "claude-opus-4": 2e5,
+  "anthropic/claude-opus-4": 2e5,
+  "claude-3.5-sonnet": 2e5,
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gemini-2.5-pro": 1e6,
+  "gemini-2.0-flash": 1e6
+};
+function getModelContextWindow(model) {
+  if (MODEL_CONTEXT_WINDOWS[model]) return MODEL_CONTEXT_WINDOWS[model];
+  const parts = model.split("/");
+  const modelName = parts[parts.length - 1];
+  if (MODEL_CONTEXT_WINDOWS[modelName]) return MODEL_CONTEXT_WINDOWS[modelName];
+  for (const [key, value] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
+    if (model.includes(key)) return value;
+  }
+  return 2e5;
+}
+
+// packages/runtime/src/compaction.ts
+var CompactionManager = class {
+  /** Compact when total tokens exceed this fraction of context window */
+  COMPACT_THRESHOLD = 0.75;
+  /** Keep this many recent turns (turn = user + assistant) */
+  KEEP_RECENT_TURNS = 15;
+  /** Reserve tokens for response */
+  RESERVE_TOKENS = 16384;
+  /**
+   * Check if compaction is needed.
+   */
+  shouldCompact(messages, systemPromptTokens, model) {
+    const contextWindow = getModelContextWindow(model);
+    const messageTokens = estimateMessageTokens(messages);
+    const totalTokens = systemPromptTokens + messageTokens;
+    const threshold = (contextWindow - this.RESERVE_TOKENS) * this.COMPACT_THRESHOLD;
+    return totalTokens > threshold;
+  }
+  /**
+   * Perform lossless compaction:
+   * 1. Save all old messages to L2 (full preservation)
+   * 2. Ask LLM to summarize old messages
+   * 3. Return summary + recent messages
+   */
+  async compact(messages, contextName, memoryClient, llmClient, model) {
+    const tokensBefore = estimateMessageTokens(messages);
+    const keepCount = this.KEEP_RECENT_TURNS * 2;
+    const splitIndex = Math.max(0, messages.length - keepCount);
+    if (splitIndex <= 2) {
+      return {
+        messages,
+        compactedCount: 0,
+        tokensBefore,
+        tokensAfter: tokensBefore,
+        episodesSaved: 0
+      };
+    }
+    const oldMessages = messages.slice(0, splitIndex);
+    const recentMessages = messages.slice(splitIndex);
+    let episodesSaved = 0;
+    if (memoryClient) {
+      for (const msg of oldMessages) {
+        if (msg.content && (msg.role === "user" || msg.role === "assistant")) {
+          try {
+            await memoryClient.storeEpisode({
+              context_name: contextName,
+              role: msg.role,
+              content: `[compacted] ${msg.content}`
+            });
+            episodesSaved++;
+          } catch {
+          }
+        }
+      }
+      console.log(`[compaction] Saved ${episodesSaved} episodes to L2 before compacting`);
+    }
+    const summaryPrompt = [
+      {
+        role: "system",
+        content: `You are a context compactor. Summarize the following conversation into a concise but complete context summary. Preserve:
+- Key decisions and their reasoning
+- Important facts, names, and technical details mentioned
+- The current state of any ongoing work
+- Any commitments or action items
+- The emotional/social tone if relevant
+
+Be concise but don't lose critical information. Write in present tense as a context briefing.`
+      },
+      {
+        role: "user",
+        content: `Summarize this conversation:
+
+${oldMessages.filter((m) => m.content).map((m) => `[${m.role}]: ${m.content}`).join("\n\n")}`
+      }
+    ];
+    let summary;
+    try {
+      const response = await llmClient.chat(summaryPrompt);
+      summary = response.content;
+    } catch (err) {
+      console.error("[compaction] LLM summary failed, using fallback:", err.message);
+      summary = oldMessages.filter((m) => m.content && m.role !== "system").map((m) => `[${m.role}]: ${m.content.slice(0, 200)}`).join("\n");
+    }
+    const compactedMessages = [
+      {
+        role: "user",
+        content: `[Context from earlier conversation \u2014 ${oldMessages.length} messages compacted]
+
+${summary}`
+      },
+      {
+        role: "assistant",
+        content: "Understood. I have the context from our earlier conversation. Continuing from where we left off."
+      },
+      ...recentMessages
+    ];
+    const tokensAfter = estimateMessageTokens(compactedMessages);
+    console.log(
+      `[compaction] Compacted ${oldMessages.length} messages (${tokensBefore} \u2192 ${tokensAfter} tokens, saved ${episodesSaved} episodes to L2)`
+    );
+    return {
+      messages: compactedMessages,
+      compactedCount: oldMessages.length,
+      tokensBefore,
+      tokensAfter,
+      episodesSaved
+    };
+  }
+};
+
 // packages/runtime/src/agent.ts
+import { resolve as resolve2 } from "path";
 var Agent = class {
   config;
   llm;
@@ -644,14 +1041,34 @@ var Agent = class {
   // Run promotion every N messages
   MAX_TOOL_ITERATIONS = 25;
   requestLogger = null;
+  sessionStore;
+  compactionManager;
+  dataDir;
   constructor(config, contextName = "global") {
     this.config = config;
     this.llm = new LLMClient(config.llm);
     this.memory = new MemoryClient(config.memory);
     this.contextManager = new ContextManager(this.memory);
+    this.dataDir = resolve2(
+      process.env.HIVEMIND_HOME || resolve2(process.env.HOME || "/root", "hivemind"),
+      "data"
+    );
+    this.sessionStore = new SessionStore(this.dataDir);
+    this.compactionManager = new CompactionManager();
     if (contextName !== "global") {
       this.contextManager.switchContext(contextName);
     }
+    this.restoreFromSession(contextName);
+  }
+  /**
+   * Restore L1 conversation history from persisted session.
+   */
+  restoreFromSession(contextName) {
+    const messages = this.sessionStore.getRecentMessages(contextName, 40);
+    if (messages.length > 0) {
+      this.conversationHistories.set(contextName, messages);
+      console.log(`[session] Restored ${messages.length} messages for context "${contextName}"`);
+    }
   }
   setToolRegistry(registry) {
     this.toolRegistry = registry;
@@ -675,7 +1092,10 @@ var Agent = class {
       }
     }
     if (!this.conversationHistories.has(contextName)) {
-      this.conversationHistories.set(contextName, []);
+      this.restoreFromSession(contextName);
+      if (!this.conversationHistories.has(contextName)) {
+        this.conversationHistories.set(contextName, []);
+      }
     }
     const conversationHistory = this.conversationHistories.get(contextName);
     const relevantEpisodes = await this.memory.search(userMessage, contextName, this.config.memory.top_k).catch((err) => {
@@ -692,7 +1112,28 @@ var Agent = class {
       }
     }
     const l3Knowledge = await this.memory.getL3Knowledge(contextName).catch(() => []);
-    const systemPromptResult = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
+    const systemPromptResult = buildSystemPrompt({
+      config: this.config.agent,
+      episodes: relevantEpisodes,
+      contextName,
+      l3Knowledge,
+      dataDir: this.dataDir
+    });
+    const systemPromptTokens = estimateTokens(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(
+        conversationHistory,
+        contextName,
+        this.memory,
+        this.llm,
+        this.config.llm.model
+      );
+      this.conversationHistories.set(contextName, result.messages);
+      const updatedHistory = this.conversationHistories.get(contextName);
+      conversationHistory.length = 0;
+      conversationHistory.push(...updatedHistory);
+    }
     const messages = buildMessages(systemPromptResult.text, conversationHistory, userMessage);
     const llmStart = Date.now();
     const toolDefs = this.toolRegistry?.getDefinitions() ?? [];
@@ -737,7 +1178,7 @@ var Agent = class {
           },
           conversationHistory: conversationHistory.map((m) => ({
             role: m.role,
-            content: m.content
+            content: m.content ?? ""
           })),
           userMessage,
           response: {
@@ -761,6 +1202,12 @@ var Agent = class {
       { role: "user", content: userMessage },
       { role: "assistant", content: response.content }
     );
+    try {
+      this.sessionStore.append(contextName, { role: "user", content: userMessage });
+      this.sessionStore.append(contextName, { role: "assistant", content: response.content });
+    } catch (err) {
+      console.error("[session] Failed to persist messages:", err.message);
+    }
     if (conversationHistory.length > 40) {
       const trimmed = conversationHistory.slice(-40);
       this.conversationHistories.set(contextName, trimmed);
@@ -802,192 +1249,6 @@ var Agent = class {
     let stripped = message.replace(/^\[.+?\s+in\s+group\s+chat\]:\s*/, "");
     stripped = stripped.replace(/^\[.+?\]:\s*/, "");
     const cmdText = stripped;
-    if (/^hm[:\s]status\b/i.test(cmdText)) {
-      const memoryOk = await this.memory.healthCheck();
-      const contexts = this.contextManager.listContexts();
-      let contextStats = "";
-      try {
-        const daemonContexts = await this.memory.listContexts();
-        contextStats = daemonContexts.map((c) => `  - ${c.name}: ${c.episode_count} episodes`).join("\n");
-      } catch {
-        contextStats = "  (unable to query memory daemon)";
-      }
-      const response = [
-        `## Agent Status`,
-        ``,
-        `**Name:** ${this.config.agent.name}`,
-        `**Active Context:** ${activeCtx}`,
-        `**Memory Daemon:** ${memoryOk ? "\u2705 connected" : "\u274C unreachable"} (${this.config.memory.daemon_url})`,
-        `**Model:** ${this.config.llm.model}`,
-        `**Temperature:** ${this.config.llm.temperature}`,
-        `**Max Tokens:** ${this.config.llm.max_tokens}`,
-        `**Memory Top-K:** ${this.config.memory.top_k}`,
-        `**Messages Processed:** ${this.messageCount}`,
-        `**L1 Contexts in Memory:** ${this.conversationHistories.size}`,
-        ``,
-        `### Contexts`,
-        contextStats
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]memory\s+stats\b/i.test(cmdText)) {
-      try {
-        const contexts = await this.memory.listContexts();
-        let totalEpisodes = 0;
-        let totalL3 = 0;
-        let lines = [];
-        for (const ctx of contexts) {
-          totalEpisodes += ctx.episode_count;
-          let l3Count = 0;
-          try {
-            const l3 = await this.memory.getL3Knowledge(ctx.name);
-            l3Count = l3.length;
-            totalL3 += l3Count;
-          } catch {
-          }
-          lines.push(`  - **${ctx.name}**: ${ctx.episode_count} L2 episodes, ${l3Count} L3 entries`);
-        }
-        const response = [
-          `## Memory Stats`,
-          ``,
-          `**Total L2 Episodes:** ${totalEpisodes}`,
-          `**Total L3 Knowledge:** ${totalL3}`,
-          `**Contexts:** ${contexts.length}`,
-          ``,
-          `### Per Context`,
-          ...lines
-        ].join("\n");
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Memory stats failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const memSearchMatch = cmdText.match(/^hm[:\s]memory\s+search\s+(.+)/i);
-    if (memSearchMatch) {
-      const query = memSearchMatch[1].trim();
-      try {
-        const results = await this.memory.search(query, activeCtx, this.config.memory.top_k);
-        if (results.length === 0) {
-          return { content: `No memories found for "${query}" in context "${activeCtx}".`, model: "system", context: activeCtx };
-        }
-        let response = `## Memory Search: "${query}"
-
-`;
-        for (const ep of results) {
-          const ctxLabel = ep.context_name !== activeCtx ? ` [from: ${ep.context_name}]` : "";
-          response += `- **[${ep.role}]** (score: ${ep.score.toFixed(3)})${ctxLabel} ${ep.content.slice(0, 300)}${ep.content.length > 300 ? "..." : ""}
-`;
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Memory search failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const l3Match = cmdText.match(/^hm[:\s]memory\s+l3(?:\s+(\S+))?/i);
-    if (l3Match) {
-      const targetCtx = l3Match[1] || activeCtx;
-      try {
-        const entries = await this.memory.getL3Knowledge(targetCtx);
-        if (entries.length === 0) {
-          return { content: `No L3 knowledge in context "${targetCtx}".`, model: "system", context: activeCtx };
-        }
-        let response = `## L3 Knowledge: ${targetCtx}
-
-`;
-        for (const entry of entries) {
-          response += `- **[${entry.id.slice(0, 8)}]** (density: ${entry.connection_density}, accesses: ${entry.access_count})
-  ${entry.content}
-`;
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `L3 query failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    if (/^hm[:\s]config\b/i.test(cmdText)) {
-      const response = [
-        `## Configuration`,
-        ``,
-        `**Agent:** ${this.config.agent.name}`,
-        `**Personality:** ${this.config.agent.personality}`,
-        `**Workspace:** ${this.config.agent.workspace || "(none)"}`,
-        ``,
-        `### LLM`,
-        `- Model: ${this.config.llm.model}`,
-        `- Base URL: ${this.config.llm.base_url}`,
-        `- Max Tokens: ${this.config.llm.max_tokens}`,
-        `- Temperature: ${this.config.llm.temperature}`,
-        ``,
-        `### Memory`,
-        `- Daemon URL: ${this.config.memory.daemon_url}`,
-        `- Top-K: ${this.config.memory.top_k}`,
-        `- Embedding Model: ${this.config.memory.embedding_model}`,
-        ``,
-        `### Sesame`,
-        `- API: ${this.config.sesame.api_url}`,
-        `- WebSocket: ${this.config.sesame.ws_url}`,
-        `- API Key: ${this.config.sesame.api_key ? "***" + this.config.sesame.api_key.slice(-4) : "(not set)"}`
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]contexts\b/i.test(cmdText)) {
-      const localContexts = this.contextManager.listContexts();
-      let daemonInfo = "";
-      try {
-        const daemonContexts = await this.memory.listContexts();
-        daemonInfo = "\n### Memory Daemon Contexts\n" + daemonContexts.map(
-          (c) => `  - **${c.name}**: ${c.episode_count} episodes (created: ${c.created_at})`
-        ).join("\n");
-      } catch {
-        daemonInfo = "\n(Memory daemon unreachable)";
-      }
-      const localInfo = localContexts.map((c) => {
-        const active = c.name === activeCtx ? " \u2190 active" : "";
-        const historyLen = this.conversationHistories.get(c.name)?.length || 0;
-        return `  - **${c.name}**${active}: ${historyLen / 2} turns in L1`;
-      }).join("\n");
-      const response = [
-        `## Contexts`,
-        ``,
-        `**Active:** ${activeCtx}`,
-        ``,
-        `### Local (L1 Working Memory)`,
-        localInfo,
-        daemonInfo
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]help\b/i.test(cmdText)) {
-      const response = [
-        `## Available Commands`,
-        ``,
-        `### Introspection`,
-        `- \`hm:status\` \u2014 Agent health, memory status, config summary`,
-        `- \`hm:config\` \u2014 Full configuration details`,
-        `- \`hm:contexts\` \u2014 List all contexts with L1/L2 info`,
-        `- \`hm:memory stats\` \u2014 Episode counts, L3 entries per context`,
-        `- \`hm:memory search <query>\` \u2014 Search L2 memories with scores`,
-        `- \`hm:memory l3 [context]\` \u2014 Show L3 knowledge entries`,
-        `- \`hm:help\` \u2014 This help message`,
-        ``,
-        `### Context Management`,
-        `- \`switch to <name>\` \u2014 Switch active context`,
-        `- \`create context <name>\` \u2014 Create a new context`,
-        `- \`list contexts\` \u2014 List contexts (legacy)`,
-        ``,
-        `### Memory`,
-        `- \`search all: <query>\` \u2014 Cross-context search`,
-        `- \`share <episode_id> with <context>\` \u2014 Share episode across contexts`,
-        ``,
-        `### Tasks`,
-        `- \`task add <title>\` \u2014 Create a task`,
-        `- \`task list [status]\` \u2014 List tasks`,
-        `- \`task start <id>\` \u2014 Start a task`,
-        `- \`task complete <id>\` \u2014 Complete a task`,
-        `- \`task next\` \u2014 Pick up next available task`
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
     const searchAllMatch = cmdText.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
     if (searchAllMatch) {
       const query = searchAllMatch[1].trim();
@@ -1088,9 +1349,219 @@ var Agent = class {
   }
 };
 
+// packages/runtime/src/events.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, unlinkSync, watch } from "fs";
+import { join as join3 } from "path";
+function matchCronField(field, value, _max) {
+  if (field === "*") return true;
+  for (const part of field.split(",")) {
+    if (part.includes("-")) {
+      const [lo, hi] = part.split("-").map(Number);
+      if (value >= lo && value <= hi) return true;
+    } else if (part.includes("/")) {
+      const [base, step] = part.split("/");
+      const stepN = Number(step);
+      const baseN = base === "*" ? 0 : Number(base);
+      if ((value - baseN) % stepN === 0 && value >= baseN) return true;
+    } else {
+      if (Number(part) === value) return true;
+    }
+  }
+  return false;
+}
+function cronMatches(expr, date) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return false;
+  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+  return matchCronField(minute, date.getMinutes(), 59) && matchCronField(hour, date.getHours(), 23) && matchCronField(dayOfMonth, date.getDate(), 31) && matchCronField(month, date.getMonth() + 1, 12) && matchCronField(dayOfWeek, date.getDay(), 6);
+}
+var EventsWatcher = class {
+  eventsDir;
+  handler;
+  watcher = null;
+  cronInterval = null;
+  oneShotTimers = /* @__PURE__ */ new Map();
+  knownFiles = /* @__PURE__ */ new Set();
+  startTime;
+  debounceTimers = /* @__PURE__ */ new Map();
+  constructor(dataDir, handler) {
+    this.eventsDir = join3(dataDir, "events");
+    this.handler = handler;
+    this.startTime = Date.now();
+  }
+  start() {
+    if (!existsSync3(this.eventsDir)) {
+      mkdirSync2(this.eventsDir, { recursive: true });
+    }
+    console.log(`[events] Watching ${this.eventsDir}`);
+    this.scanExisting();
+    this.watcher = watch(this.eventsDir, (_eventType, filename) => {
+      if (!filename || !filename.endsWith(".json")) return;
+      this.debounce(filename, () => this.handleFileChange(filename));
+    });
+    this.cronInterval = setInterval(() => this.checkPeriodicEvents(), 6e4);
+    console.log(`[events] Started, tracking ${this.knownFiles.size} files`);
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.cronInterval) {
+      clearInterval(this.cronInterval);
+      this.cronInterval = null;
+    }
+    for (const timer of this.oneShotTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.oneShotTimers.clear();
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  debounce(filename, fn) {
+    const existing = this.debounceTimers.get(filename);
+    if (existing) clearTimeout(existing);
+    this.debounceTimers.set(
+      filename,
+      setTimeout(() => {
+        this.debounceTimers.delete(filename);
+        fn();
+      }, 200)
+    );
+  }
+  scanExisting() {
+    try {
+      const files = readdirSync2(this.eventsDir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        this.knownFiles.add(file);
+        this.processEventFile(file);
+      }
+    } catch {
+    }
+  }
+  handleFileChange(filename) {
+    const filePath = join3(this.eventsDir, filename);
+    if (!existsSync3(filePath)) {
+      this.knownFiles.delete(filename);
+      const timer = this.oneShotTimers.get(filename);
+      if (timer) {
+        clearTimeout(timer);
+        this.oneShotTimers.delete(filename);
+      }
+      return;
+    }
+    if (!this.knownFiles.has(filename)) {
+      this.knownFiles.add(filename);
+    }
+    this.processEventFile(filename);
+  }
+  processEventFile(filename) {
+    const filePath = join3(this.eventsDir, filename);
+    let event;
+    try {
+      const content = readFileSync3(filePath, "utf-8");
+      event = JSON.parse(content);
+    } catch (err) {
+      console.error(`[events] Failed to parse ${filename}:`, err.message);
+      return;
+    }
+    if (!event.type || !event.channelId || !event.text) {
+      console.warn(`[events] Invalid event in ${filename}: missing required fields`);
+      return;
+    }
+    switch (event.type) {
+      case "immediate":
+        this.handleImmediate(filename, event);
+        break;
+      case "one-shot":
+        this.scheduleOneShot(filename, event);
+        break;
+      case "periodic":
+        console.log(`[events] Registered periodic event: ${filename} (${event.schedule})`);
+        break;
+      default:
+        console.warn(`[events] Unknown event type in ${filename}: ${event.type}`);
+    }
+  }
+  async handleImmediate(filename, event) {
+    console.log(`[events] Triggering immediate event: ${filename}`);
+    try {
+      await this.handler(event.channelId, event.text, filename, "immediate");
+    } catch (err) {
+      console.error(`[events] Handler error for ${filename}:`, err.message);
+    }
+    this.deleteEvent(filename);
+  }
+  scheduleOneShot(filename, event) {
+    const targetTime = new Date(event.at).getTime();
+    const now = Date.now();
+    const delay = targetTime - now;
+    if (delay <= 0) {
+      console.log(`[events] One-shot event ${filename} is past due, triggering now`);
+      this.handler(event.channelId, event.text, filename, "one-shot").catch((err) => {
+        console.error(`[events] Handler error for ${filename}:`, err.message);
+      });
+      this.deleteEvent(filename);
+      return;
+    }
+    const existing = this.oneShotTimers.get(filename);
+    if (existing) clearTimeout(existing);
+    console.log(`[events] Scheduled one-shot: ${filename} in ${Math.round(delay / 1e3)}s`);
+    const timer = setTimeout(async () => {
+      this.oneShotTimers.delete(filename);
+      try {
+        await this.handler(event.channelId, event.text, filename, "one-shot");
+      } catch (err) {
+        console.error(`[events] Handler error for ${filename}:`, err.message);
+      }
+      this.deleteEvent(filename);
+    }, delay);
+    this.oneShotTimers.set(filename, timer);
+  }
+  checkPeriodicEvents() {
+    const now = /* @__PURE__ */ new Date();
+    for (const filename of this.knownFiles) {
+      const filePath = join3(this.eventsDir, filename);
+      if (!existsSync3(filePath)) continue;
+      try {
+        const event = JSON.parse(readFileSync3(filePath, "utf-8"));
+        if (event.type !== "periodic") continue;
+        let checkDate = now;
+        if (event.timezone) {
+          try {
+            const tzStr = now.toLocaleString("en-US", { timeZone: event.timezone });
+            checkDate = new Date(tzStr);
+          } catch {
+          }
+        }
+        if (cronMatches(event.schedule, checkDate)) {
+          console.log(`[events] Triggering periodic event: ${filename}`);
+          this.handler(event.channelId, event.text, filename, "periodic").catch((err) => {
+            console.error(`[events] Handler error for ${filename}:`, err.message);
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  deleteEvent(filename) {
+    try {
+      const filePath = join3(this.eventsDir, filename);
+      if (existsSync3(filePath)) {
+        unlinkSync(filePath);
+      }
+      this.knownFiles.delete(filename);
+    } catch (err) {
+      console.error(`[events] Failed to delete ${filename}:`, err.message);
+    }
+  }
+};
+
 // packages/runtime/src/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve as resolve2, dirname } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { resolve as resolve3, dirname as dirname2 } from "path";
 
 // node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -1814,12 +2285,12 @@ function deepMerge(target, source) {
   return result;
 }
 function loadConfig(path) {
-  const raw = readFileSync2(path, "utf-8");
+  const raw = readFileSync4(path, "utf-8");
   let parsed = parse(raw);
-  const configDir = dirname(path);
-  const localPath = resolve2(configDir, "local.toml");
-  if (existsSync2(localPath)) {
-    const localRaw = readFileSync2(localPath, "utf-8");
+  const configDir = dirname2(path);
+  const localPath = resolve3(configDir, "local.toml");
+  if (existsSync4(localPath)) {
+    const localRaw = readFileSync4(localPath, "utf-8");
     const localParsed = parse(localRaw);
     parsed = deepMerge(parsed, localParsed);
     console.log(`[config] Merged overrides from ${localPath}`);
@@ -1868,20 +2339,20 @@ function loadConfig(path) {
     parsed.sentinel.stop_flag_file = process.env.SENTINEL_STOP_FLAG_FILE;
   }
   if (parsed.agent.workspace && !parsed.agent.workspace.startsWith("/")) {
-    const configDir2 = dirname(path);
-    parsed.agent.workspace = resolve2(configDir2, "..", parsed.agent.workspace);
+    const configDir2 = dirname2(path);
+    parsed.agent.workspace = resolve3(configDir2, "..", parsed.agent.workspace);
   }
   return parsed;
 }
 
 // packages/runtime/src/sesame.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve3, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve4, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var RUNTIME_VERSION = "unknown";
 try {
-  const __dirname2 = dirname2(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync3(resolve3(__dirname2, "../package.json"), "utf-8"));
+  const __dirname2 = dirname3(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync5(resolve4(__dirname2, "../package.json"), "utf-8"));
   RUNTIME_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -1947,12 +2418,7 @@ var SesameClient2 = class {
     this.sdk.on("message", (event) => {
       const msg = event.data || event.message || event;
       const senderId = msg.senderId || msg.sender?.id;
-      if (senderId === this.agentId) {
-        const content = msg.content?.trim() || "";
-        const isHmCommand = /^hm[:\s]/i.test(content);
-        const isTextCommand = /^(?:list contexts|switch to|create context|search all:|task )/i.test(content);
-        if (!isHmCommand && !isTextCommand) return;
-      }
+      if (senderId === this.agentId) return;
       if (!this.messageHandler || !msg.content) return;
       const channelInfo = this.channels.get(msg.channelId);
       this.messageHandler({
@@ -2055,24 +2521,24 @@ var HEALTH_PORT = 9484;
 var HEALTH_PATH = "/health";
 
 // packages/runtime/src/request-logger.ts
-import { randomUUID } from "crypto";
-import { mkdirSync, existsSync as existsSync3, appendFileSync, readFileSync as readFileSync4, writeFileSync } from "fs";
-import { dirname as dirname3 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync3, existsSync as existsSync5, appendFileSync as appendFileSync2, readFileSync as readFileSync6, writeFileSync } from "fs";
+import { dirname as dirname4 } from "path";
 var RequestLogger = class {
   logPath;
   maxAgeDays = 7;
   constructor(dbPath) {
     this.logPath = dbPath.replace(/\.db$/, ".jsonl");
     if (this.logPath === dbPath) this.logPath = dbPath + ".jsonl";
-    const dir = dirname3(this.logPath);
-    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
+    const dir = dirname4(this.logPath);
+    if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
     this.prune();
   }
   prune() {
-    if (!existsSync3(this.logPath)) return;
+    if (!existsSync5(this.logPath)) return;
     const cutoff = new Date(Date.now() - this.maxAgeDays * 24 * 60 * 60 * 1e3).toISOString();
     try {
-      const lines = readFileSync4(this.logPath, "utf-8").split("\n").filter(Boolean);
+      const lines = readFileSync6(this.logPath, "utf-8").split("\n").filter(Boolean);
       const kept = [];
       let pruned = 0;
       for (const line of lines) {
@@ -2094,7 +2560,7 @@ var RequestLogger = class {
     }
   }
   log(entry) {
-    const id = randomUUID();
+    const id = randomUUID2();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const sysTokens = Math.ceil(entry.systemPromptComponents.fullText.length / 4);
     const histTokens = Math.ceil(
@@ -2124,7 +2590,7 @@ var RequestLogger = class {
       token_est_user: userTokens,
       token_est_total: sysTokens + histTokens + userTokens
     };
-    appendFileSync(this.logPath, JSON.stringify(record) + "\n");
+    appendFileSync2(this.logPath, JSON.stringify(record) + "\n");
     return id;
   }
   getRequests(opts = {}) {
@@ -2148,9 +2614,9 @@ var RequestLogger = class {
   close() {
   }
   readAll() {
-    if (!existsSync3(this.logPath)) return [];
+    if (!existsSync5(this.logPath)) return [];
     try {
-      const lines = readFileSync4(this.logPath, "utf-8").split("\n").filter(Boolean);
+      const lines = readFileSync6(this.logPath, "utf-8").split("\n").filter(Boolean);
       const entries = [];
       for (const line of lines) {
         try {
@@ -2167,17 +2633,17 @@ var RequestLogger = class {
 
 // packages/runtime/src/dashboard.ts
 import { createServer } from "http";
-import { readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve4, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve5, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname = dirname4(fileURLToPath2(import.meta.url));
+var __dirname = dirname5(fileURLToPath2(import.meta.url));
 var DASHBOARD_PORT = 9485;
 var spaHtml = null;
 function getSpaHtml() {
   if (!spaHtml) {
-    for (const dir of [__dirname, resolve4(__dirname, "../src")]) {
+    for (const dir of [__dirname, resolve5(__dirname, "../src")]) {
       try {
-        spaHtml = readFileSync5(resolve4(dir, "dashboard.html"), "utf-8");
+        spaHtml = readFileSync7(resolve5(dir, "dashboard.html"), "utf-8");
         break;
       } catch {
       }
@@ -2349,7 +2815,7 @@ var ToolRegistry = class {
 
 // packages/runtime/src/tools/shell.ts
 import { execSync } from "child_process";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 var MAX_OUTPUT = 5e4;
 function registerShellTool(registry, workspaceDir) {
   registry.register(
@@ -2376,7 +2842,7 @@ function registerShellTool(registry, workspaceDir) {
     async (params) => {
       const command = params.command;
       const timeout = (params.timeout || 30) * 1e3;
-      const cwd = params.workdir ? resolve5(workspaceDir, params.workdir) : workspaceDir;
+      const cwd = params.workdir ? resolve6(workspaceDir, params.workdir) : workspaceDir;
       try {
         const output = execSync(command, {
           cwd,
@@ -2403,8 +2869,8 @@ ${output || err.message}`;
 }
 
 // packages/runtime/src/tools/files.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { resolve as resolve6, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { resolve as resolve7, dirname as dirname6 } from "path";
 var MAX_READ = 1e5;
 function registerFileTools(registry, workspaceDir) {
   registry.register(
@@ -2430,11 +2896,11 @@ function registerFileTools(registry, workspaceDir) {
     },
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
-      if (!existsSync4(filePath)) {
+      if (!existsSync6(filePath)) {
         return `Error: File not found: ${filePath}`;
       }
       try {
-        let content = readFileSync6(filePath, "utf-8");
+        let content = readFileSync8(filePath, "utf-8");
         if (params.offset || params.limit) {
           const lines = content.split("\n");
           const start = (params.offset || 1) - 1;
@@ -2471,8 +2937,8 @@ function registerFileTools(registry, workspaceDir) {
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
       try {
-        const dir = dirname5(filePath);
-        if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+        const dir = dirname6(filePath);
+        if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
         writeFileSync2(filePath, params.content);
         return `Written ${params.content.length} bytes to ${filePath}`;
       } catch (err) {
@@ -2503,11 +2969,11 @@ function registerFileTools(registry, workspaceDir) {
     },
     async (params) => {
       const filePath = resolvePath(workspaceDir, params.path);
-      if (!existsSync4(filePath)) {
+      if (!existsSync6(filePath)) {
         return `Error: File not found: ${filePath}`;
       }
       try {
-        const content = readFileSync6(filePath, "utf-8");
+        const content = readFileSync8(filePath, "utf-8");
         const oldText = params.old_text;
         const newText = params.new_text;
         if (!content.includes(oldText)) {
@@ -2535,18 +3001,18 @@ function registerFileTools(registry, workspaceDir) {
       required: []
     },
     async (params) => {
-      const { readdirSync: readdirSync2, statSync } = await import("fs");
+      const { readdirSync: readdirSync3, statSync: statSync2 } = await import("fs");
       const dirPath = params.path ? resolvePath(workspaceDir, params.path) : workspaceDir;
-      if (!existsSync4(dirPath)) {
+      if (!existsSync6(dirPath)) {
         return `Error: Directory not found: ${dirPath}`;
       }
       try {
-        const entries = readdirSync2(dirPath);
+        const entries = readdirSync3(dirPath);
         const results = [];
         for (const entry of entries) {
           if (entry.startsWith(".")) continue;
           try {
-            const stat = statSync(resolve6(dirPath, entry));
+            const stat = statSync2(resolve7(dirPath, entry));
             results.push(stat.isDirectory() ? `${entry}/` : entry);
           } catch {
             results.push(entry);
@@ -2563,7 +3029,7 @@ function resolvePath(workspace, path) {
   if (path.startsWith("/") || path.startsWith("~")) {
     return path.replace(/^~/, process.env.HOME || "/root");
   }
-  return resolve6(workspace, path);
+  return resolve7(workspace, path);
 }
 
 // packages/runtime/src/tools/web.ts
@@ -2664,32 +3130,184 @@ function registerWebTools(registry, config) {
   );
 }
 
+// packages/runtime/src/tools/memory.ts
+function registerMemoryTools(registry, daemonUrl) {
+  registry.register(
+    "memory_search",
+    "Search your episodic memory for relevant past conversations and experiences. Returns scored results from your memory system. Use this when you want to recall something from a previous conversation or check what you know about a topic.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What to search for in memory"
+        },
+        context: {
+          type: "string",
+          description: "Context to search in (default: current active context)"
+        },
+        top_k: {
+          type: "number",
+          description: "Number of results to return (default: 10)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      const query = params.query;
+      const context = params.context || "global";
+      const topK = params.top_k || 10;
+      try {
+        const resp = await fetch(`${daemonUrl}/api/search`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query, context_name: context, top_k: topK })
+        });
+        if (!resp.ok) return `Memory search failed: ${resp.status}`;
+        const data = await resp.json();
+        if (!data.results?.length) return `No memories found for "${query}" in context "${context}".`;
+        return data.results.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.context_name}] [${r.role}] ${r.content.slice(0, 200)}`).join("\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_stats",
+    "Get statistics about your memory system \u2014 episode counts, contexts, L3 knowledge entries. Use for self-diagnosis or understanding your memory state.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      try {
+        const healthResp = await fetch(`${daemonUrl}/health`);
+        const health = healthResp.ok ? await healthResp.json() : { status: "unreachable" };
+        const ctxResp = await fetch(`${daemonUrl}/api/contexts`);
+        const contexts = ctxResp.ok ? (await ctxResp.json()).contexts : [];
+        const l3Counts = {};
+        for (const ctx of contexts) {
+          try {
+            const l3Resp = await fetch(`${daemonUrl}/api/l3/${encodeURIComponent(ctx.name)}`);
+            if (l3Resp.ok) {
+              const l3Data = await l3Resp.json();
+              l3Counts[ctx.name] = l3Data.entries?.length ?? 0;
+            }
+          } catch {
+          }
+        }
+        const totalEpisodes = contexts.reduce((sum, c) => sum + c.episode_count, 0);
+        const totalL3 = Object.values(l3Counts).reduce((sum, c) => sum + c, 0);
+        let output = `Memory Daemon: ${health.status || "unknown"}
+`;
+        output += `Total Episodes (L2): ${totalEpisodes}
+`;
+        output += `Total Knowledge (L3): ${totalL3}
+`;
+        output += `
+Contexts:
+`;
+        for (const ctx of contexts) {
+          output += `  - ${ctx.name}: ${ctx.episode_count} episodes, ${l3Counts[ctx.name] ?? 0} L3 entries
+`;
+        }
+        return output;
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_l3",
+    "View your promoted L3 knowledge \u2014 high-level patterns, decisions, and insights that have been distilled from your episodic memories. This is your 'long-term wisdom'.",
+    {
+      type: "object",
+      properties: {
+        context: {
+          type: "string",
+          description: "Context to get L3 knowledge for (default: global)"
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const context = params.context || "global";
+      try {
+        const resp = await fetch(`${daemonUrl}/api/l3/${encodeURIComponent(context)}`);
+        if (!resp.ok) return `L3 query failed: ${resp.status}`;
+        const data = await resp.json();
+        if (!data.entries?.length) return `No L3 knowledge in context "${context}".`;
+        return data.entries.map((e, i) => `${i + 1}. ${e.content} (from ${e.source_episodes} episodes, ${e.created_at})`).join("\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_cross_search",
+    "Search across ALL memory contexts at once. Useful when you're not sure which context a memory belongs to.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What to search for across all contexts"
+        },
+        top_k: {
+          type: "number",
+          description: "Number of results (default: 10)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      const query = params.query;
+      const topK = params.top_k || 10;
+      try {
+        const resp = await fetch(`${daemonUrl}/api/search/cross-context`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query, top_k: topK })
+        });
+        if (!resp.ok) return `Cross-context search failed: ${resp.status}`;
+        const data = await resp.json();
+        if (!data.results?.length) return `No memories found across any context for "${query}".`;
+        return data.results.map((r, i) => `${i + 1}. [${r.score.toFixed(3)}] [${r.context_name}] ${r.content.slice(0, 200)}`).join("\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+}
+
 // packages/runtime/src/tools/register.ts
-import { resolve as resolve7 } from "path";
-import { mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
+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;
   }
-  const workspaceDir = resolve7(hivemindHome, config?.workspace || "workspace");
-  if (!existsSync5(workspaceDir)) {
-    mkdirSync3(workspaceDir, { 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 readFileSync7, writeFileSync as writeFileSync3, unlinkSync } from "fs";
-import { resolve as resolve8, dirname as dirname6 } from "path";
+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 = dirname6(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync7(resolve8(__dirname2, "../package.json"), "utf-8"));
+  const __dirname2 = dirname7(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync9(resolve9(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -2725,7 +3343,7 @@ function writePidFile(path) {
 }
 function cleanupPidFile(path) {
   try {
-    unlinkSync(path);
+    unlinkSync2(path);
   } catch {
   }
 }
@@ -2751,27 +3369,50 @@ async function startPipeline(configPath) {
     memoryConnected = true;
     console.log("[hivemind] Memory daemon connected");
   }
-  const requestLogger = new RequestLogger(resolve8(dirname6(configPath), "data", "dashboard.db"));
+  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 || resolve8(process.env.HOME || "/root", "hivemind");
+  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
+    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(dirname7(configPath), "data");
   if (config.sesame.api_key) {
-    await startSesameLoop(config, agent);
+    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) {
+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}`;
+      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;
@@ -2836,6 +3477,11 @@ async function startSesameLoop(config, agent) {
         sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
         return;
       }
+      if (response.content.trim() === "[SILENT]" || response.content.trim().startsWith("[SILENT]")) {
+        console.log(`[sesame] ${config.agent.name}: silent response`);
+        sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
+        return;
+      }
       const ctxPrefix = response.contextSwitched ? `[switched to ${response.context}] ` : "";
       let content = response.content;
       const prefixPatterns = [
@@ -2909,8 +3555,8 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve9) => {
-    rl.on("close", resolve9);
+  return new Promise((resolve10) => {
+    rl.on("close", resolve10);
   });
 }
 
@@ -2939,20 +3585,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       this.server = createServer3((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve9());
+      this.server.listen(this.port, () => resolve10());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       if (!this.server) {
-        resolve9();
+        resolve10();
         return;
       }
-      this.server.close(() => resolve9());
+      this.server.close(() => resolve10());
     });
   }
   getPort() {
@@ -3075,10 +3721,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve9(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve10(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -3351,7 +3997,13 @@ export {
   TaskEngine,
   buildSystemPrompt,
   buildMessages,
+  SessionStore,
+  estimateTokens,
+  estimateMessageTokens,
+  getModelContextWindow,
+  CompactionManager,
   Agent,
+  EventsWatcher,
   defaultSentinelConfig,
   loadConfig,
   SesameClient2 as SesameClient,
@@ -3405,4 +4057,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-LQ7CYHSQ.js.map
+//# sourceMappingURL=chunk-DXQ3GROV.js.map