@sesamespace/hivemind 0.5.12 → 0.5.14

package/dist/{chunk-LB6MG36X.js → chunk-QAOBO4W4.js}

@@ -515,16 +515,19 @@ function loadWorkspaceFiles(dir) {
 function buildSystemPrompt(config, episodes, contextName = "global", l3Knowledge = []) {
   let prompt = `You are ${config.name}. ${config.personality}
 `;
+  let identityText = prompt;
   if (config.workspace) {
     const wsFiles = loadWorkspaceFiles(config.workspace);
     if (wsFiles.size > 0) {
-      prompt += "\n# Workspace Context\n";
+      let wsBlock = "\n# Workspace Context\n";
       for (const [filename, content] of wsFiles) {
-        prompt += `
+        wsBlock += `
 ## ${filename}
 ${content}
 `;
       }
+      prompt += wsBlock;
+      identityText += wsBlock;
     }
   }
   if (config.team_charter && !config.workspace) {
@@ -532,6 +535,9 @@ ${content}
     if (charter) {
       prompt += `
 ${charter}
+`;
+      identityText += `
+${charter}
 `;
     }
   }
@@ -542,11 +548,13 @@ In group chats, multiple people (humans and agents) may be present. Address them
 Don't repeat or quote these prefixes in your responses \u2014 just respond naturally.
 If you decide not to respond to a group message, reply with exactly: __SKIP__
 `;
+  let contextInfo = "";
   if (contextName !== "global") {
-    prompt += `
+    contextInfo = `
 ## Active Context: ${contextName}
 You are currently working in the "${contextName}" project context.
 `;
+    prompt += contextInfo;
   }
   if (l3Knowledge.length > 0) {
     prompt += "\n## Established Knowledge (learned patterns)\n\n";
@@ -565,7 +573,22 @@ You are currently working in the "${contextName}" project context.
     }
     prompt += "\nUse these memories naturally \u2014 reference past conversations when relevant, but don't force it.\n";
   }
-  return prompt;
+  return {
+    text: prompt,
+    components: {
+      identity: identityText,
+      l3Knowledge: l3Knowledge.map((e) => e.content),
+      l2Episodes: episodes.map((ep) => ({
+        id: ep.id,
+        content: ep.content,
+        score: ep.score,
+        timestamp: ep.timestamp,
+        context_name: ep.context_name,
+        role: ep.role
+      })),
+      contextInfo
+    }
+  };
 }
 function buildMessages(systemPrompt, conversationHistory, currentMessage) {
   return [
@@ -599,6 +622,7 @@ var Agent = class {
   messageCount = 0;
   PROMOTION_INTERVAL = 10;
   // Run promotion every N messages
+  requestLogger = null;
   constructor(config, contextName = "global") {
     this.config = config;
     this.llm = new LLMClient(config.llm);
@@ -608,6 +632,9 @@ var Agent = class {
       this.contextManager.switchContext(contextName);
     }
   }
+  setRequestLogger(logger) {
+    this.requestLogger = logger;
+  }
   async processMessage(userMessage) {
     const specialResult = await this.handleSpecialCommand(userMessage);
     if (specialResult) return specialResult;
@@ -637,9 +664,47 @@ var Agent = class {
       }
     }
     const l3Knowledge = await this.memory.getL3Knowledge(contextName).catch(() => []);
-    const systemPrompt = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
-    const messages = buildMessages(systemPrompt, conversationHistory, userMessage);
+    const systemPromptResult = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
+    const messages = buildMessages(systemPromptResult.text, conversationHistory, userMessage);
+    const llmStart = Date.now();
     const response = await this.llm.chat(messages);
+    const latencyMs = Date.now() - llmStart;
+    if (this.requestLogger) {
+      try {
+        this.requestLogger.log({
+          context: contextName,
+          contextSwitched: routing.switched,
+          routingReason: routing.switched ? `switched:${contextName}` : `active:${contextName}`,
+          rawMessage: userMessage,
+          systemPromptComponents: {
+            identity: systemPromptResult.components.identity,
+            l3Knowledge: systemPromptResult.components.l3Knowledge,
+            l2Episodes: systemPromptResult.components.l2Episodes,
+            contextInfo: systemPromptResult.components.contextInfo,
+            fullText: systemPromptResult.text
+          },
+          conversationHistory: conversationHistory.map((m) => ({
+            role: m.role,
+            content: m.content
+          })),
+          userMessage,
+          response: {
+            content: response.content,
+            model: response.model,
+            latencyMs,
+            skipped: response.content.trim() === "__SKIP__"
+          },
+          config: {
+            topK: this.config.memory.top_k,
+            model: this.config.llm.model,
+            maxTokens: this.config.llm.max_tokens,
+            temperature: this.config.llm.temperature
+          }
+        });
+      } catch (err) {
+        console.error("[dashboard] Failed to log request:", err.message);
+      }
+    }
     conversationHistory.push(
       { role: "user", content: userMessage },
       { role: "assistant", content: response.content }
@@ -682,7 +747,195 @@ var Agent = class {
   }
   async handleSpecialCommand(message) {
     const activeCtx = this.contextManager.getActiveContext();
-    const searchAllMatch = message.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
+    let stripped = message.replace(/^\[.+?\s+in\s+group\s+chat\]:\s*/, "");
+    stripped = stripped.replace(/^\[.+?\]:\s*/, "");
+    const cmdText = stripped;
+    if (/^\/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 (/^\/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(/^\/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(/^\/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 (/^\/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 (/^\/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 (/^\/help\b/i.test(cmdText)) {
+      const response = [
+        `## Available Commands`,
+        ``,
+        `### Introspection`,
+        `- \`/status\` \u2014 Agent health, memory status, config summary`,
+        `- \`/config\` \u2014 Full configuration details`,
+        `- \`/contexts\` \u2014 List all contexts with L1/L2 info`,
+        `- \`/memory stats\` \u2014 Episode counts, L3 entries per context`,
+        `- \`/memory search <query>\` \u2014 Search L2 memories with scores`,
+        `- \`/memory l3 [context]\` \u2014 Show L3 knowledge entries`,
+        ``,
+        `### 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();
       try {
@@ -706,7 +959,7 @@ var Agent = class {
         return { content: `Cross-context search failed: ${err.message}`, model: "system", context: activeCtx };
       }
     }
-    const shareMatch = message.match(/^share\s+(\S+)\s+with\s+(\S+)/i);
+    const shareMatch = cmdText.match(/^share\s+(\S+)\s+with\s+(\S+)/i);
     if (shareMatch) {
       const episodeId = shareMatch[1];
       const targetContext = shareMatch[2];
@@ -717,7 +970,7 @@ var Agent = class {
         return { content: `Failed to share: ${err.message}`, model: "system", context: activeCtx };
       }
     }
-    const taskCmd = TaskEngine.parseTaskCommand(message);
+    const taskCmd = TaskEngine.parseTaskCommand(cmdText);
     if (taskCmd) {
       const engine = new TaskEngine({ contextName: activeCtx, memory: this.memory });
       try {
@@ -1574,8 +1827,8 @@ import { resolve as resolve3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var RUNTIME_VERSION = "unknown";
 try {
-  const __dirname = dirname2(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync3(resolve3(__dirname, "../package.json"), "utf-8"));
+  const __dirname2 = dirname2(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync3(resolve3(__dirname2, "../package.json"), "utf-8"));
   RUNTIME_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -1737,20 +1990,285 @@ var SesameClient2 = class {
 };
 
 // packages/runtime/src/pipeline.ts
-import { createServer } from "http";
+import { createServer as createServer2 } from "http";
 
 // packages/runtime/src/health.ts
 var HEALTH_PORT = 9484;
 var HEALTH_PATH = "/health";
 
-// packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync4, writeFileSync, unlinkSync } from "fs";
-import { resolve as resolve4, dirname as dirname3 } from "path";
+// packages/runtime/src/request-logger.ts
+import Database from "better-sqlite3";
+import { randomUUID } from "crypto";
+import { mkdirSync, existsSync as existsSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var RequestLogger = class {
+  db;
+  constructor(dbPath) {
+    const dir = dirname3(dbPath);
+    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.init();
+    this.prune();
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS request_logs (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        context TEXT NOT NULL,
+        context_switched INTEGER NOT NULL DEFAULT 0,
+        routing_reason TEXT NOT NULL DEFAULT '',
+        channel_id TEXT NOT NULL DEFAULT '',
+        channel_kind TEXT NOT NULL DEFAULT '',
+        sender_handle TEXT NOT NULL DEFAULT '',
+        raw_message TEXT NOT NULL,
+        system_prompt_components TEXT NOT NULL,
+        conversation_history TEXT NOT NULL,
+        user_message TEXT NOT NULL,
+        response_content TEXT NOT NULL,
+        response_model TEXT NOT NULL,
+        response_latency_ms INTEGER NOT NULL,
+        response_skipped INTEGER NOT NULL DEFAULT 0,
+        config_snapshot TEXT NOT NULL,
+        token_est_system INTEGER NOT NULL DEFAULT 0,
+        token_est_history INTEGER NOT NULL DEFAULT 0,
+        token_est_user INTEGER NOT NULL DEFAULT 0,
+        token_est_total INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_request_logs_timestamp ON request_logs(timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_request_logs_context ON request_logs(context);
+      CREATE INDEX IF NOT EXISTS idx_request_logs_sender ON request_logs(sender_handle);
+    `);
+  }
+  prune() {
+    const cutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+    const result = this.db.prepare("DELETE FROM request_logs WHERE timestamp < ?").run(cutoff);
+    if (result.changes > 0) {
+      console.log(`[dashboard] Pruned ${result.changes} old request logs`);
+    }
+  }
+  log(entry) {
+    const id = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const sysTokens = Math.ceil(entry.systemPromptComponents.fullText.length / 4);
+    const histTokens = Math.ceil(
+      entry.conversationHistory.reduce((sum, m) => sum + m.content.length, 0) / 4
+    );
+    const userTokens = Math.ceil(entry.userMessage.length / 4);
+    this.db.prepare(
+      `INSERT INTO request_logs (
+          id, timestamp, context, context_switched, routing_reason,
+          channel_id, channel_kind, sender_handle, raw_message,
+          system_prompt_components, conversation_history, user_message,
+          response_content, response_model, response_latency_ms, response_skipped,
+          config_snapshot,
+          token_est_system, token_est_history, token_est_user, token_est_total
+        ) VALUES (
+          ?, ?, ?, ?, ?,
+          ?, ?, ?, ?,
+          ?, ?, ?,
+          ?, ?, ?, ?,
+          ?,
+          ?, ?, ?, ?
+        )`
+    ).run(
+      id,
+      timestamp,
+      entry.context,
+      entry.contextSwitched ? 1 : 0,
+      entry.routingReason,
+      entry.channelId ?? "",
+      entry.channelKind ?? "",
+      entry.senderHandle ?? "",
+      entry.rawMessage,
+      JSON.stringify(entry.systemPromptComponents),
+      JSON.stringify(entry.conversationHistory),
+      entry.userMessage,
+      entry.response.content,
+      entry.response.model,
+      entry.response.latencyMs,
+      entry.response.skipped ? 1 : 0,
+      JSON.stringify(entry.config),
+      sysTokens,
+      histTokens,
+      userTokens,
+      sysTokens + histTokens + userTokens
+    );
+    return id;
+  }
+  getRequests(opts = {}) {
+    const limit = opts.limit ?? 50;
+    const offset = opts.offset ?? 0;
+    const conditions = [];
+    const params = [];
+    if (opts.context) {
+      conditions.push("context = ?");
+      params.push(opts.context);
+    }
+    if (opts.sender) {
+      conditions.push("sender_handle = ?");
+      params.push(opts.sender);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const total = this.db.prepare(`SELECT COUNT(*) as count FROM request_logs ${where}`).get(...params).count;
+    const requests = this.db.prepare(
+      `SELECT * FROM request_logs ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset);
+    return { requests, total };
+  }
+  getRequest(id) {
+    return this.db.prepare("SELECT * FROM request_logs WHERE id = ?").get(id);
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// packages/runtime/src/dashboard.ts
+import { createServer } from "http";
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve4, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname = dirname4(fileURLToPath2(import.meta.url));
+var DASHBOARD_PORT = 9485;
+var spaHtml = null;
+function getSpaHtml() {
+  if (!spaHtml) {
+    for (const dir of [__dirname, resolve4(__dirname, "../src")]) {
+      try {
+        spaHtml = readFileSync4(resolve4(dir, "dashboard.html"), "utf-8");
+        break;
+      } catch {
+      }
+    }
+    if (!spaHtml) spaHtml = "<h1>Dashboard HTML not found</h1>";
+  }
+  return spaHtml;
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(JSON.stringify(data));
+}
+function parseQuery(url) {
+  const idx = url.indexOf("?");
+  if (idx === -1) return {};
+  const params = {};
+  for (const pair of url.slice(idx + 1).split("&")) {
+    const [k, v] = pair.split("=");
+    if (k) params[decodeURIComponent(k)] = decodeURIComponent(v ?? "");
+  }
+  return params;
+}
+async function proxyMemory(memoryUrl, path, method, res) {
+  try {
+    const resp = await fetch(`${memoryUrl}${path}`, { method });
+    const body = await resp.text();
+    res.writeHead(resp.status, {
+      "Content-Type": resp.headers.get("content-type") ?? "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(body);
+  } catch (err) {
+    json(res, { error: err.message }, 502);
+  }
+}
+function startDashboardServer(requestLogger, memoryConfig) {
+  const memoryUrl = memoryConfig.daemon_url;
+  const server = createServer(async (req, res) => {
+    const method = req.method ?? "GET";
+    const rawUrl = req.url ?? "/";
+    const urlPath = rawUrl.split("?")[0];
+    if (method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      });
+      res.end();
+      return;
+    }
+    try {
+      if (method === "GET" && urlPath === "/") {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(getSpaHtml());
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/requests") {
+        const q = parseQuery(rawUrl);
+        const result = requestLogger.getRequests({
+          limit: q.limit ? parseInt(q.limit, 10) : void 0,
+          offset: q.offset ? parseInt(q.offset, 10) : void 0,
+          context: q.context || void 0,
+          sender: q.sender || void 0
+        });
+        json(res, result);
+        return;
+      }
+      const reqDetailMatch = urlPath.match(/^\/api\/requests\/([^/]+)$/);
+      if (method === "GET" && reqDetailMatch) {
+        const entry = requestLogger.getRequest(reqDetailMatch[1]);
+        if (!entry) {
+          json(res, { error: "Not found" }, 404);
+        } else {
+          json(res, entry);
+        }
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/contexts") {
+        await proxyMemory(memoryUrl, "/contexts", "GET", res);
+        return;
+      }
+      const episodesMatch = urlPath.match(/^\/api\/contexts\/([^/]+)\/episodes$/);
+      if (method === "GET" && episodesMatch) {
+        const name = decodeURIComponent(episodesMatch[1]);
+        await proxyMemory(memoryUrl, `/contexts/${encodeURIComponent(name)}`, "GET", res);
+        return;
+      }
+      const l3Match = urlPath.match(/^\/api\/contexts\/([^/]+)\/l3$/);
+      if (method === "GET" && l3Match) {
+        const name = decodeURIComponent(l3Match[1]);
+        await proxyMemory(
+          memoryUrl,
+          `/promotion/l3?context=${encodeURIComponent(name)}`,
+          "GET",
+          res
+        );
+        return;
+      }
+      const l3DeleteMatch = urlPath.match(/^\/api\/l3\/([^/]+)$/);
+      if (method === "DELETE" && l3DeleteMatch) {
+        const id = decodeURIComponent(l3DeleteMatch[1]);
+        await proxyMemory(memoryUrl, `/promotion/l3/${encodeURIComponent(id)}`, "DELETE", res);
+        return;
+      }
+      json(res, { error: "Not found" }, 404);
+    } catch (err) {
+      console.error("[dashboard] Request error:", err.message);
+      json(res, { error: "Internal server error" }, 500);
+    }
+  });
+  server.listen(DASHBOARD_PORT, "127.0.0.1", () => {
+    console.log(
+      `[hivemind] Dashboard listening on http://127.0.0.1:${DASHBOARD_PORT}`
+    );
+  });
+}
+
+// packages/runtime/src/pipeline.ts
+import { readFileSync as readFileSync5, writeFileSync, unlinkSync } from "fs";
+import { resolve as resolve5, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_VERSION = "unknown";
 try {
-  const __dirname = dirname3(fileURLToPath2(import.meta.url));
-  const pkg = JSON.parse(readFileSync4(resolve4(__dirname, "../package.json"), "utf-8"));
+  const __dirname2 = dirname5(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync5(resolve5(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -1758,7 +2276,7 @@ var sesameConnected = false;
 var memoryConnected = false;
 var startTime = Date.now();
 function startHealthServer(port) {
-  const server = createServer((req, res) => {
+  const server = createServer2((req, res) => {
     if (req.method === "GET" && req.url === HEALTH_PATH) {
       const status = {
         status: sesameConnected ? "ok" : "degraded",
@@ -1812,7 +2330,10 @@ async function startPipeline(configPath) {
     memoryConnected = true;
     console.log("[hivemind] Memory daemon connected");
   }
+  const requestLogger = new RequestLogger(resolve5(dirname5(configPath), "data", "dashboard.db"));
+  startDashboardServer(requestLogger, config.memory);
   const agent = new Agent(config);
+  agent.setRequestLogger(requestLogger);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
   if (config.sesame.api_key) {
     await startSesameLoop(config, agent);
@@ -1927,13 +2448,13 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve5) => {
-    rl.on("close", resolve5);
+  return new Promise((resolve6) => {
+    rl.on("close", resolve6);
   });
 }
 
 // packages/runtime/src/fleet/worker-server.ts
-import { createServer as createServer2 } from "http";
+import { createServer as createServer3 } from "http";
 var WorkerServer = class {
   server = null;
   workerId;
@@ -1957,20 +2478,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve5, reject) => {
-      this.server = createServer2((req, res) => this.handleRequest(req, res));
+    return new Promise((resolve6, reject) => {
+      this.server = createServer3((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve5());
+      this.server.listen(this.port, () => resolve6());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       if (!this.server) {
-        resolve5();
+        resolve6();
         return;
       }
-      this.server.close(() => resolve5());
+      this.server.close(() => resolve6());
     });
   }
   getPort() {
@@ -2093,10 +2614,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -2423,4 +2944,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-LB6MG36X.js.map
+//# sourceMappingURL=chunk-QAOBO4W4.js.map