@sesamespace/hivemind 0.2.0 → 0.3.0

package/dist/chunk-2I2O6X5D.js

@@ -1,1408 +0,0 @@
-// packages/runtime/src/llm-client.ts
-var LLMClient = class {
-  baseUrl;
-  model;
-  maxTokens;
-  temperature;
-  apiKey;
-  constructor(config) {
-    this.baseUrl = config.base_url;
-    this.model = config.model;
-    this.maxTokens = config.max_tokens;
-    this.temperature = config.temperature;
-    this.apiKey = config.api_key ?? "";
-  }
-  async chat(messages) {
-    const resp = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
-      },
-      body: JSON.stringify({
-        model: this.model,
-        messages,
-        max_tokens: this.maxTokens,
-        temperature: this.temperature
-      })
-    });
-    if (!resp.ok) {
-      const body = await resp.text();
-      throw new Error(`LLM request failed: ${resp.status} ${body}`);
-    }
-    const data = await resp.json();
-    return {
-      content: data.choices[0].message.content,
-      model: data.model,
-      usage: data.usage
-    };
-  }
-};
-
-// packages/runtime/src/memory-client.ts
-var MemoryClient = class {
-  baseUrl;
-  topK;
-  constructor(config) {
-    this.baseUrl = config.daemon_url;
-    this.topK = config.top_k;
-  }
-  async storeEpisode(input) {
-    const resp = await fetch(`${this.baseUrl}/episodes`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input)
-    });
-    if (!resp.ok) {
-      throw new Error(`Memory store failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async search(query, context, limit) {
-    const params = new URLSearchParams({ q: query });
-    if (context) params.set("context", context);
-    params.set("limit", String(limit ?? this.topK));
-    const resp = await fetch(`${this.baseUrl}/search?${params}`);
-    if (!resp.ok) {
-      throw new Error(`Memory search failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.episodes;
-  }
-  async getContext(name) {
-    const resp = await fetch(`${this.baseUrl}/contexts/${encodeURIComponent(name)}`);
-    if (!resp.ok) {
-      throw new Error(`Get context failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async createContext(name, description = "") {
-    const resp = await fetch(`${this.baseUrl}/contexts`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ name, description })
-    });
-    if (!resp.ok) {
-      throw new Error(`Create context failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async deleteContext(name) {
-    const resp = await fetch(`${this.baseUrl}/contexts/${encodeURIComponent(name)}`, {
-      method: "DELETE"
-    });
-    if (!resp.ok) {
-      throw new Error(`Delete context failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async listContexts() {
-    const resp = await fetch(`${this.baseUrl}/contexts`);
-    if (!resp.ok) {
-      throw new Error(`List contexts failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.contexts;
-  }
-  async searchCrossContext(query, limit) {
-    const params = new URLSearchParams({ q: query });
-    params.set("limit", String(limit ?? this.topK));
-    const resp = await fetch(`${this.baseUrl}/search/cross-context?${params}`);
-    if (!resp.ok) {
-      throw new Error(`Cross-context search failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.results;
-  }
-  async shareEpisode(episodeId, targetContext) {
-    const resp = await fetch(`${this.baseUrl}/episodes/${encodeURIComponent(episodeId)}/share`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ target_context: targetContext })
-    });
-    if (!resp.ok) {
-      throw new Error(`Share episode failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async runPromotion(contextName) {
-    const params = new URLSearchParams();
-    if (contextName) params.set("context", contextName);
-    const resp = await fetch(`${this.baseUrl}/promotion/run?${params}`, {
-      method: "POST"
-    });
-    if (!resp.ok) {
-      throw new Error(`Promotion failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async getL3Knowledge(contextName) {
-    const resp = await fetch(
-      `${this.baseUrl}/promotion/l3?context=${encodeURIComponent(contextName)}`
-    );
-    if (!resp.ok) {
-      throw new Error(`Get L3 failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.entries;
-  }
-  async setContextScoring(contextName, halfLifeHours) {
-    const resp = await fetch(
-      `${this.baseUrl}/contexts/${encodeURIComponent(contextName)}/scoring`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ half_life_hours: halfLifeHours })
-      }
-    );
-    if (!resp.ok) {
-      throw new Error(`Set scoring failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async recordAccess(episodeId) {
-    const resp = await fetch(`${this.baseUrl}/episodes/${encodeURIComponent(episodeId)}/access`, {
-      method: "POST"
-    });
-    if (!resp.ok) {
-      throw new Error(`Record access failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async recordCoAccess(episodeIds) {
-    const resp = await fetch(`${this.baseUrl}/episodes/co-access`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ episode_ids: episodeIds })
-    });
-    if (!resp.ok) {
-      throw new Error(`Co-access failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  // Task engine methods
-  async createTask(input) {
-    const resp = await fetch(`${this.baseUrl}/tasks`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input)
-    });
-    if (!resp.ok) {
-      throw new Error(`Create task failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async listTasks(contextName, status) {
-    const params = new URLSearchParams({ context: contextName });
-    if (status) params.set("status", status);
-    const resp = await fetch(`${this.baseUrl}/tasks?${params}`);
-    if (!resp.ok) {
-      throw new Error(`List tasks failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.tasks;
-  }
-  async updateTask(taskId, updates) {
-    const resp = await fetch(`${this.baseUrl}/tasks/${encodeURIComponent(taskId)}`, {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(updates)
-    });
-    if (!resp.ok) {
-      throw new Error(`Update task failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async getNextTask(contextName) {
-    const resp = await fetch(`${this.baseUrl}/tasks/next?context=${encodeURIComponent(contextName)}`);
-    if (!resp.ok) {
-      if (resp.status === 404) return null;
-      throw new Error(`Get next task failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async healthCheck() {
-    try {
-      const resp = await fetch(`${this.baseUrl}/health`);
-      return resp.ok;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// packages/runtime/src/context.ts
-var SWITCH_PATTERNS = [
-  /^switch\s+to\s+(\S+)/i,
-  /^context:\s*(\S+)/i,
-  /^@(\S+)\s/,
-  /^working\s+on\s+(\S+)/i
-];
-var ContextManager = class {
-  contexts = /* @__PURE__ */ new Map();
-  activeContext = "global";
-  memory;
-  constructor(memory) {
-    this.memory = memory;
-    this.contexts.set("global", {
-      name: "global",
-      description: "Global context \u2014 identity, preferences, cross-cutting knowledge",
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      last_active: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  async createContext(name, description = "") {
-    if (this.contexts.has(name)) {
-      return this.contexts.get(name);
-    }
-    const metadata = {
-      name,
-      description,
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      last_active: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.contexts.set(name, metadata);
-    try {
-      await this.memory.createContext(name, description);
-    } catch (err) {
-      console.error(`Failed to register context '${name}' with daemon:`, err.message);
-    }
-    return metadata;
-  }
-  async deleteContext(name) {
-    if (name === "global") {
-      console.error("Cannot delete global context");
-      return false;
-    }
-    if (!this.contexts.has(name)) {
-      return false;
-    }
-    this.contexts.delete(name);
-    if (this.activeContext === name) {
-      this.activeContext = "global";
-    }
-    try {
-      await this.memory.deleteContext(name);
-    } catch (err) {
-      console.error(`Failed to delete context '${name}' from daemon:`, err.message);
-    }
-    return true;
-  }
-  listContexts() {
-    return Array.from(this.contexts.values());
-  }
-  getContext(name) {
-    return this.contexts.get(name);
-  }
-  getActiveContext() {
-    return this.activeContext;
-  }
-  switchContext(name) {
-    const previousContext = this.activeContext;
-    const isNew = !this.contexts.has(name);
-    if (isNew) {
-      this.contexts.set(name, {
-        name,
-        description: "",
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        last_active: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-    this.activeContext = name;
-    this.touchContext(name);
-    return { previousContext, activeContext: name, isNew };
-  }
-  /**
-   * Parse a message and determine if it's a context switch command.
-   * Returns the context name if a switch is detected, null otherwise.
-   */
-  parseContextSwitch(message) {
-    for (const pattern of SWITCH_PATTERNS) {
-      const match = message.match(pattern);
-      if (match) {
-        return match[1].toLowerCase();
-      }
-    }
-    return null;
-  }
-  /**
-   * Infer context from message content by checking known context names.
-   * Returns the best matching context or current active context.
-   */
-  inferContext(message) {
-    const lower = message.toLowerCase();
-    for (const [name] of this.contexts) {
-      if (name === "global") continue;
-      if (lower.includes(name.toLowerCase())) {
-        return name;
-      }
-    }
-    return this.activeContext;
-  }
-  /**
-   * Route a message: check for explicit switch, then infer context.
-   * Returns the resolved context name and whether a switch happened.
-   */
-  routeMessage(message) {
-    const switchTarget = this.parseContextSwitch(message);
-    if (switchTarget) {
-      const result = this.switchContext(switchTarget);
-      return { context: switchTarget, switched: true, switchedTo: result.activeContext };
-    }
-    const inferred = this.inferContext(message);
-    if (inferred !== this.activeContext) {
-      this.touchContext(inferred);
-      return { context: inferred, switched: false };
-    }
-    this.touchContext(this.activeContext);
-    return { context: this.activeContext, switched: false };
-  }
-  /**
-   * Returns contexts that should be searched: active context + global.
-   */
-  getSearchContexts() {
-    const contexts = [this.activeContext];
-    if (this.activeContext !== "global") {
-      contexts.push("global");
-    }
-    return contexts;
-  }
-  hasContext(name) {
-    return this.contexts.has(name);
-  }
-  touchContext(name) {
-    const ctx = this.contexts.get(name);
-    if (ctx) {
-      ctx.last_active = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
-};
-
-// packages/runtime/src/task-engine.ts
-var TaskEngine = class {
-  contextName;
-  memory;
-  constructor(options) {
-    this.contextName = options.contextName;
-    this.memory = options.memory;
-  }
-  async addTask(title, description, blockedBy = []) {
-    return this.memory.createTask({
-      context_name: this.contextName,
-      title,
-      description,
-      status: "planned",
-      blocked_by: blockedBy
-    });
-  }
-  async listTasks(status) {
-    return this.memory.listTasks(this.contextName, status);
-  }
-  async startTask(taskId) {
-    return this.memory.updateTask(taskId, { status: "active" });
-  }
-  async completeTask(taskId) {
-    return this.memory.updateTask(taskId, { status: "complete" });
-  }
-  async archiveTask(taskId) {
-    return this.memory.updateTask(taskId, { status: "archived" });
-  }
-  async getNextTask() {
-    return this.memory.getNextTask(this.contextName);
-  }
-  async pickAndStartNextTask() {
-    const next = await this.getNextTask();
-    if (next) {
-      return this.startTask(next.id);
-    }
-    return null;
-  }
-  setContext(contextName) {
-    this.contextName = contextName;
-  }
-  /**
-   * Parse a task command from a chat message.
-   * Returns the action and parsed parameters, or null if not a task command.
-   */
-  static parseTaskCommand(message) {
-    const lower = message.trim().toLowerCase();
-    const addMatch = message.match(/^(?:add|create)\s+task[:\s]+(.+)/i);
-    if (addMatch) {
-      return { action: "add", title: addMatch[1].trim() };
-    }
-    if (/^list\s+tasks/i.test(lower)) {
-      const statusMatch = lower.match(/list\s+tasks\s+(\w+)/);
-      return { action: "list", statusFilter: statusMatch?.[1] };
-    }
-    const completeMatch = message.match(/^complete\s+task\s+(\S+)/i);
-    if (completeMatch) {
-      return { action: "complete", taskId: completeMatch[1] };
-    }
-    const startMatch = message.match(/^start\s+task\s+(\S+)/i);
-    if (startMatch) {
-      return { action: "start", taskId: startMatch[1] };
-    }
-    if (/^next\s+task/i.test(lower)) {
-      return { action: "next" };
-    }
-    const archiveMatch = message.match(/^archive\s+task\s+(\S+)/i);
-    if (archiveMatch) {
-      return { action: "archive", taskId: archiveMatch[1] };
-    }
-    return null;
-  }
-};
-
-// packages/runtime/src/prompt.ts
-import { readFileSync, existsSync } from "fs";
-var charterCache = null;
-function loadCharter(path) {
-  if (charterCache && charterCache.path === path) return charterCache.content;
-  if (!existsSync(path)) return "";
-  const content = readFileSync(path, "utf-8");
-  charterCache = { path, content };
-  return content;
-}
-function buildSystemPrompt(config, episodes, contextName = "global", l3Knowledge = []) {
-  let prompt = `You are ${config.name}. ${config.personality}
-`;
-  if (config.team_charter) {
-    const charter = loadCharter(config.team_charter);
-    if (charter) {
-      prompt += `
-${charter}
-`;
-    }
-  }
-  prompt += `
-## Communication
-Messages are prefixed with [sender_handle]: or [sender_handle in group chat]: to tell you who's talking.
-In group chats, multiple people (humans and agents) may be present. Address them by name when relevant.
-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__
-`;
-  if (contextName !== "global") {
-    prompt += `
-## Active Context: ${contextName}
-You are currently working in the "${contextName}" project context.
-`;
-  }
-  if (l3Knowledge.length > 0) {
-    prompt += "\n## Established Knowledge (learned patterns)\n\n";
-    for (const entry of l3Knowledge) {
-      prompt += `- ${entry.content}
-`;
-    }
-  }
-  if (episodes.length > 0) {
-    prompt += "\n## Relevant memories from previous conversations\n\n";
-    for (const ep of episodes) {
-      const timeAgo = formatTimeAgo(ep.timestamp);
-      const ctxLabel = ep.context_name !== contextName ? ` [from: ${ep.context_name}]` : "";
-      prompt += `[${timeAgo}]${ctxLabel} ${ep.role}: ${ep.content}
-`;
-    }
-    prompt += "\nUse these memories naturally \u2014 reference past conversations when relevant, but don't force it.\n";
-  }
-  return prompt;
-}
-function buildMessages(systemPrompt, conversationHistory, currentMessage) {
-  return [
-    { role: "system", content: systemPrompt },
-    ...conversationHistory,
-    { role: "user", content: currentMessage }
-  ];
-}
-function formatTimeAgo(timestamp) {
-  const date = new Date(timestamp);
-  const now = /* @__PURE__ */ new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffMins = Math.floor(diffMs / 6e4);
-  const diffHours = Math.floor(diffMs / 36e5);
-  const diffDays = Math.floor(diffMs / 864e5);
-  if (diffMins < 1) return "just now";
-  if (diffMins < 60) return `${diffMins}m ago`;
-  if (diffHours < 24) return `${diffHours}h ago`;
-  if (diffDays < 7) return `${diffDays}d ago`;
-  return date.toLocaleDateString();
-}
-
-// packages/runtime/src/agent.ts
-var Agent = class {
-  config;
-  llm;
-  memory;
-  contextManager;
-  // Per-context conversation histories
-  conversationHistories = /* @__PURE__ */ new Map();
-  messageCount = 0;
-  PROMOTION_INTERVAL = 10;
-  // Run promotion every N messages
-  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);
-    if (contextName !== "global") {
-      this.contextManager.switchContext(contextName);
-    }
-  }
-  async processMessage(userMessage) {
-    const specialResult = await this.handleSpecialCommand(userMessage);
-    if (specialResult) return specialResult;
-    const routing = this.contextManager.routeMessage(userMessage);
-    const contextName = routing.context;
-    if (routing.switched) {
-      try {
-        await this.memory.createContext(contextName);
-      } catch {
-      }
-    }
-    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) => {
-      console.error("Memory search failed, continuing without context:", err.message);
-      return [];
-    });
-    if (relevantEpisodes.length > 0) {
-      const episodeIds = relevantEpisodes.map((e) => e.id);
-      this.memory.recordCoAccess(episodeIds).catch(() => {
-      });
-      for (const ep of relevantEpisodes) {
-        this.memory.recordAccess(ep.id).catch(() => {
-        });
-      }
-    }
-    const l3Knowledge = await this.memory.getL3Knowledge(contextName).catch(() => []);
-    const systemPrompt = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
-    const messages = buildMessages(systemPrompt, conversationHistory, userMessage);
-    const response = await this.llm.chat(messages);
-    conversationHistory.push(
-      { role: "user", content: userMessage },
-      { role: "assistant", content: response.content }
-    );
-    if (conversationHistory.length > 40) {
-      const trimmed = conversationHistory.slice(-40);
-      this.conversationHistories.set(contextName, trimmed);
-    }
-    await this.storeEpisodes(contextName, userMessage, response.content);
-    this.messageCount++;
-    if (this.messageCount % this.PROMOTION_INTERVAL === 0) {
-      this.memory.runPromotion(contextName).catch((err) => {
-        console.error("Promotion run failed:", err.message);
-      });
-    }
-    return {
-      content: response.content,
-      model: response.model,
-      context: contextName,
-      contextSwitched: routing.switched
-    };
-  }
-  async storeEpisodes(contextName, userMessage, assistantResponse) {
-    try {
-      await Promise.all([
-        this.memory.storeEpisode({
-          context_name: contextName,
-          role: "user",
-          content: userMessage
-        }),
-        this.memory.storeEpisode({
-          context_name: contextName,
-          role: "assistant",
-          content: assistantResponse
-        })
-      ]);
-    } catch (err) {
-      console.error("Failed to store episodes:", err.message);
-    }
-  }
-  async handleSpecialCommand(message) {
-    const activeCtx = this.contextManager.getActiveContext();
-    const searchAllMatch = message.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
-    if (searchAllMatch) {
-      const query = searchAllMatch[1].trim();
-      try {
-        const results = await this.memory.searchCrossContext(query);
-        let response = "## Cross-Context Search Results\n\n";
-        if (results.length === 0) {
-          response += "No results found across any context.";
-        } else {
-          for (const group of results) {
-            response += `### Context: ${group.context}
-`;
-            for (const ep of group.episodes) {
-              response += `- [${ep.role}] ${ep.content.slice(0, 200)}${ep.content.length > 200 ? "..." : ""} (score: ${ep.score.toFixed(3)})
-`;
-            }
-            response += "\n";
-          }
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Cross-context search failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const shareMatch = message.match(/^share\s+(\S+)\s+with\s+(\S+)/i);
-    if (shareMatch) {
-      const episodeId = shareMatch[1];
-      const targetContext = shareMatch[2];
-      try {
-        await this.memory.shareEpisode(episodeId, targetContext);
-        return { content: `Shared episode ${episodeId} with context "${targetContext}".`, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Failed to share: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const taskCmd = TaskEngine.parseTaskCommand(message);
-    if (taskCmd) {
-      const engine = new TaskEngine({ contextName: activeCtx, memory: this.memory });
-      try {
-        switch (taskCmd.action) {
-          case "add": {
-            const task = await engine.addTask(taskCmd.title || "Untitled", taskCmd.description || "");
-            return { content: `Task created: [${task.id.slice(0, 8)}] ${task.title} (status: ${task.status})`, model: "system", context: activeCtx };
-          }
-          case "list": {
-            const tasks = await engine.listTasks(taskCmd.statusFilter);
-            if (tasks.length === 0) {
-              return { content: `No tasks${taskCmd.statusFilter ? ` with status "${taskCmd.statusFilter}"` : ""} in context "${activeCtx}".`, model: "system", context: activeCtx };
-            }
-            let response = `## Tasks in ${activeCtx}
-
-`;
-            for (const t of tasks) {
-              const blockedBy = Array.isArray(t.blocked_by) ? t.blocked_by : JSON.parse(String(t.blocked_by) || "[]");
-              const blockedStr = blockedBy.length > 0 ? ` (blocked by: ${blockedBy.map((b) => b.slice(0, 8)).join(", ")})` : "";
-              response += `- [${t.status}] ${t.id.slice(0, 8)}: ${t.title}${blockedStr}
-`;
-            }
-            return { content: response, model: "system", context: activeCtx };
-          }
-          case "start": {
-            const task = await engine.startTask(taskCmd.taskId);
-            return { content: task ? `Task ${taskCmd.taskId.slice(0, 8)} started.` : "Task not found.", model: "system", context: activeCtx };
-          }
-          case "complete": {
-            const task = await engine.completeTask(taskCmd.taskId);
-            return { content: task ? `Task ${taskCmd.taskId.slice(0, 8)} completed.` : "Task not found.", model: "system", context: activeCtx };
-          }
-          case "archive": {
-            const task = await engine.archiveTask(taskCmd.taskId);
-            return { content: task ? `Task ${taskCmd.taskId.slice(0, 8)} archived.` : "Task not found.", model: "system", context: activeCtx };
-          }
-          case "next": {
-            const task = await engine.pickAndStartNextTask();
-            if (task) {
-              return { content: `Picked up next task: [${task.id.slice(0, 8)}] ${task.title}`, model: "system", context: activeCtx };
-            }
-            return { content: "No available tasks to pick up.", model: "system", context: activeCtx };
-          }
-        }
-      } catch (err) {
-        return { content: `Task command failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    return null;
-  }
-  getMemoryClient() {
-    return this.memory;
-  }
-  getContextManager() {
-    return this.contextManager;
-  }
-  setContext(name) {
-    this.contextManager.switchContext(name);
-  }
-  getActiveContext() {
-    return this.contextManager.getActiveContext();
-  }
-};
-
-// packages/runtime/src/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve, dirname } from "path";
-import { parse } from "@iarna/toml";
-function defaultWorkerConfig() {
-  return {
-    enabled: false,
-    primary_url: "http://localhost:3000",
-    worker_port: 3100,
-    worker_id: `worker-${process.pid}`,
-    max_contexts: 4,
-    task_poll_interval_ms: 5e3,
-    status_report_interval_ms: 15e3
-  };
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object") {
-      result[key] = deepMerge(target[key], source[key]);
-    } else if (source[key] !== void 0 && source[key] !== "") {
-      result[key] = source[key];
-    }
-  }
-  return result;
-}
-function loadConfig(path) {
-  const raw = readFileSync2(path, "utf-8");
-  let parsed = parse(raw);
-  const configDir = dirname(path);
-  const localPath = resolve(configDir, "local.toml");
-  if (existsSync2(localPath)) {
-    const localRaw = readFileSync2(localPath, "utf-8");
-    const localParsed = parse(localRaw);
-    parsed = deepMerge(parsed, localParsed);
-    console.log(`[config] Merged overrides from ${localPath}`);
-  }
-  if (process.env.AGENT_NAME) {
-    parsed.agent.name = process.env.AGENT_NAME;
-  }
-  if (process.env.LLM_API_KEY) {
-    parsed.llm.api_key = process.env.LLM_API_KEY;
-  }
-  if (process.env.LLM_BASE_URL) {
-    parsed.llm.base_url = process.env.LLM_BASE_URL;
-  }
-  if (process.env.SESAME_API_KEY) {
-    parsed.sesame.api_key = process.env.SESAME_API_KEY;
-  }
-  if (process.env.MEMORY_DAEMON_URL) {
-    parsed.memory.daemon_url = process.env.MEMORY_DAEMON_URL;
-  }
-  if (process.env.WORKER_PRIMARY_URL) {
-    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
-    parsed.worker.primary_url = process.env.WORKER_PRIMARY_URL;
-  }
-  if (process.env.WORKER_PORT) {
-    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
-    parsed.worker.worker_port = parseInt(process.env.WORKER_PORT, 10);
-  }
-  if (process.env.WORKER_ID) {
-    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
-    parsed.worker.worker_id = process.env.WORKER_ID;
-  }
-  return parsed;
-}
-
-// packages/runtime/src/sesame.ts
-import { SesameClient as SesameSDK } from "@sesamespace/sdk";
-var SesameClient = class {
-  config;
-  sdk;
-  messageHandler = null;
-  agentId = null;
-  channels = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-    this.sdk = new SesameSDK({
-      apiUrl: config.api_url.replace(/\/api\/v1$/, ""),
-      wsUrl: config.ws_url,
-      apiKey: config.api_key
-    });
-  }
-  onMessage(handler) {
-    this.messageHandler = handler;
-  }
-  async connect() {
-    const manifest = await this.sdk.getManifest();
-    this.agentId = manifest.agent.id;
-    console.log(`[sesame] Authenticated as ${manifest.agent.handle} (${this.agentId})`);
-    for (const ch of manifest.channels) {
-      this.channels.set(ch.id, { kind: ch.kind, name: ch.name ?? void 0 });
-      const label = ch.name || ch.id.slice(0, 8);
-      console.log(`[sesame] Channel: ${label} (${ch.kind})`);
-    }
-    this.sdk.on("message", (event) => {
-      const msg = event.data || event.message || event;
-      const senderId = msg.senderId || msg.sender?.id;
-      if (senderId === this.agentId) return;
-      if (!this.messageHandler || !msg.content) return;
-      const channelInfo = this.channels.get(msg.channelId);
-      this.messageHandler({
-        id: msg.id || "unknown",
-        channelId: msg.channelId || "unknown",
-        channelKind: channelInfo?.kind || "dm",
-        content: msg.content,
-        author: {
-          id: senderId || "unknown",
-          handle: msg.senderHandle || msg.metadata?.senderHandle || "unknown"
-        },
-        timestamp: msg.createdAt || (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    await this.sdk.connect();
-    console.log("[sesame] WebSocket connected");
-  }
-  async sendMessage(channelId, content) {
-    await this.sdk.sendMessage(channelId, { content });
-  }
-  getAgentId() {
-    return this.agentId;
-  }
-  getChannelInfo(channelId) {
-    return this.channels.get(channelId);
-  }
-  disconnect() {
-    this.sdk.disconnect();
-  }
-};
-
-// packages/runtime/src/pipeline.ts
-async function startPipeline(configPath) {
-  const config = loadConfig(configPath);
-  console.log(`[hivemind] Starting ${config.agent.name} (pid ${process.pid})`);
-  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 {
-    console.log("[hivemind] Memory daemon connected");
-  }
-  const agent = new Agent(config);
-  console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
-  if (config.sesame.api_key) {
-    await startSesameLoop(config, agent);
-  } else {
-    console.log("[hivemind] No Sesame API key configured \u2014 running in stdin mode");
-    await startStdinLoop(agent);
-  }
-}
-async function startSesameLoop(config, agent) {
-  const sesame = new SesameClient(config.sesame);
-  let shuttingDown = false;
-  const shutdown = (signal) => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    console.log(`
-[hivemind] Received ${signal}, shutting down...`);
-    try {
-      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"));
-  sesame.onMessage(async (msg) => {
-    if (shuttingDown) return;
-    console.log(`[sesame] ${msg.author.handle} (${msg.channelKind}): ${msg.content}`);
-    try {
-      const prefix = msg.channelKind === "group" ? `[${msg.author.handle} in group chat]: ` : `[${msg.author.handle}]: `;
-      const response = await agent.processMessage(prefix + msg.content);
-      if (response.content.trim() === "__SKIP__") {
-        console.log(`[sesame] ${config.agent.name}: skipped (${msg.author.handle} in ${msg.channelKind})`);
-        return;
-      }
-      const ctxPrefix = response.contextSwitched ? `[switched to ${response.context}] ` : "";
-      await sesame.sendMessage(msg.channelId, ctxPrefix + response.content);
-      console.log(`[sesame] ${config.agent.name} (${response.context}): ${response.content.slice(0, 100)}...`);
-    } catch (err) {
-      console.error("[sesame] Error processing message:", err.message);
-    }
-  });
-  await sesame.connect();
-  console.log("[hivemind] Listening for Sesame messages");
-  await new Promise(() => {
-  });
-}
-async function startStdinLoop(agent) {
-  const readline = await import("readline");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  console.log("[hivemind] Ready. Type a message (Ctrl+C to exit)");
-  console.log("[hivemind] Commands: 'switch to <name>', 'list contexts', 'create context <name>'\n");
-  rl.on("line", async (line) => {
-    const input = line.trim();
-    if (!input) return;
-    if (input.toLowerCase() === "list contexts") {
-      const contexts = agent.getContextManager().listContexts();
-      console.log("\nContexts:");
-      for (const ctx of contexts) {
-        const active = ctx.name === agent.getActiveContext() ? " (active)" : "";
-        console.log(`  - ${ctx.name}${active}: ${ctx.description || "(no description)"}`);
-      }
-      console.log();
-      return;
-    }
-    const createMatch = input.match(/^create context (\S+)\s*(.*)?$/i);
-    if (createMatch) {
-      const name = createMatch[1];
-      const desc = createMatch[2] || "";
-      await agent.getContextManager().createContext(name, desc);
-      console.log(`
-Created context: ${name}
-`);
-      return;
-    }
-    try {
-      const response = await agent.processMessage(input);
-      if (response.contextSwitched) {
-        console.log(`
-[switched to context: ${response.context}]`);
-      }
-      console.log(`
-${response.content}
-`);
-    } catch (err) {
-      console.error("Error:", err.message);
-    }
-  });
-  return new Promise((resolve2) => {
-    rl.on("close", resolve2);
-  });
-}
-
-// packages/runtime/src/fleet/worker-server.ts
-import { createServer } from "http";
-var WorkerServer = class {
-  server = null;
-  workerId;
-  port;
-  startTime;
-  assignedContexts = /* @__PURE__ */ new Map();
-  activeContext = null;
-  currentTask = null;
-  maxContexts;
-  memoryDaemonUrl;
-  ollamaUrl;
-  onAssignCallback = null;
-  onSyncPushCallback = null;
-  constructor(opts) {
-    this.workerId = opts.workerId;
-    this.port = opts.port;
-    this.startTime = Date.now();
-    this.maxContexts = opts.maxContexts ?? 4;
-    this.memoryDaemonUrl = opts.memoryDaemonUrl ?? null;
-    this.ollamaUrl = opts.ollamaUrl ?? null;
-  }
-  /** Start listening. */
-  async start() {
-    return new Promise((resolve2, reject) => {
-      this.server = createServer((req, res) => this.handleRequest(req, res));
-      this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve2());
-    });
-  }
-  /** Stop the server. */
-  async stop() {
-    return new Promise((resolve2) => {
-      if (!this.server) {
-        resolve2();
-        return;
-      }
-      this.server.close(() => resolve2());
-    });
-  }
-  getPort() {
-    return this.port;
-  }
-  getAssignedContexts() {
-    return Array.from(this.assignedContexts.keys());
-  }
-  setActiveContext(name) {
-    this.activeContext = name;
-  }
-  setCurrentTask(taskId) {
-    this.currentTask = taskId;
-  }
-  /** Register a callback for when a new context is assigned. */
-  onContextAssigned(cb) {
-    this.onAssignCallback = cb;
-  }
-  /** Register a handler for incoming sync push requests from Primary. */
-  onSyncPush(cb) {
-    this.onSyncPushCallback = cb;
-  }
-  // --- Request Router ---
-  async handleRequest(req, res) {
-    const url = new URL(req.url ?? "/", `http://localhost:${this.port}`);
-    const path = url.pathname;
-    const method = req.method ?? "GET";
-    try {
-      if (method === "GET" && path === "/health") {
-        return this.handleHealth(res);
-      }
-      if (method === "POST" && path === "/assign") {
-        const body = await readBody(req);
-        return this.handleAssign(body, res);
-      }
-      if (method === "DELETE" && path.startsWith("/assign/")) {
-        const contextName = decodeURIComponent(path.slice("/assign/".length));
-        return this.handleUnassign(contextName, res);
-      }
-      if (method === "GET" && path === "/status") {
-        return this.handleStatus(res);
-      }
-      if (method === "POST" && path === "/sync/push") {
-        const body = await readBody(req);
-        return this.handleSyncPush(body, res);
-      }
-      sendJson(res, 404, { error: "Not found" });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      sendJson(res, 500, { error: msg });
-    }
-  }
-  // --- Handlers ---
-  handleHealth(res) {
-    const uptimeMs = Date.now() - this.startTime;
-    const body = {
-      worker_id: this.workerId,
-      status: "healthy",
-      uptime_seconds: Math.floor(uptimeMs / 1e3),
-      assigned_contexts: Array.from(this.assignedContexts.keys()),
-      active_context: this.activeContext,
-      memory_daemon_ok: this.memoryDaemonUrl !== null,
-      ollama_ok: this.ollamaUrl !== null
-    };
-    sendJson(res, 200, body);
-  }
-  handleAssign(raw, res) {
-    const req = JSON.parse(raw);
-    if (this.assignedContexts.size >= this.maxContexts) {
-      const body2 = {
-        context_name: req.context_name,
-        accepted: false,
-        reason: "Worker at max context capacity"
-      };
-      sendJson(res, 200, body2);
-      return;
-    }
-    const assignment = {
-      context_name: req.context_name,
-      context_description: req.context_description,
-      assigned_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.assignedContexts.set(req.context_name, assignment);
-    if (this.onAssignCallback) {
-      this.onAssignCallback(req.context_name, req.context_description);
-    }
-    const body = {
-      context_name: req.context_name,
-      accepted: true
-    };
-    sendJson(res, 200, body);
-  }
-  handleUnassign(contextName, res) {
-    const existed = this.assignedContexts.delete(contextName);
-    if (this.activeContext === contextName) {
-      this.activeContext = null;
-      this.currentTask = null;
-    }
-    sendJson(res, existed ? 200 : 404, {
-      context_name: contextName,
-      removed: existed
-    });
-  }
-  handleStatus(res) {
-    const report = {
-      activity: this.currentTask ? "working" : "idle",
-      current_context: this.activeContext,
-      current_task: this.currentTask
-    };
-    sendJson(res, 200, report);
-  }
-  async handleSyncPush(raw, res) {
-    if (!this.onSyncPushCallback) {
-      sendJson(res, 501, { error: "Sync push handler not registered" });
-      return;
-    }
-    const req = JSON.parse(raw);
-    const result = await this.onSyncPushCallback(req);
-    sendJson(res, 200, result);
-  }
-};
-function readBody(req) {
-  return new Promise((resolve2, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", reject);
-  });
-}
-function sendJson(res, status, body) {
-  const payload = JSON.stringify(body);
-  res.writeHead(status, {
-    "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(payload)
-  });
-  res.end(payload);
-}
-
-// packages/runtime/src/fleet/worker-protocol.ts
-var WORKER_API_PREFIX = "/workers";
-var PRIMARY_ROUTES = {
-  register: `${WORKER_API_PREFIX}/register`,
-  status: (workerId) => `${WORKER_API_PREFIX}/${encodeURIComponent(workerId)}/status`,
-  syncPull: `${WORKER_API_PREFIX}/sync/pull`
-};
-var WORKER_ROUTES = {
-  health: "/health",
-  assign: "/assign",
-  unassign: (contextName) => `/assign/${encodeURIComponent(contextName)}`,
-  status: "/status",
-  syncPush: "/sync/push"
-};
-var DEFAULT_HEALTH_INTERVAL_MS = 3e4;
-var HEALTH_TIMEOUT_MS = 5e3;
-var DEFAULT_SYNC_INTERVAL_MS = 6e4;
-
-// packages/runtime/src/worker.ts
-var WorkerRuntime = class {
-  config;
-  workerConfig;
-  server;
-  memory;
-  agent;
-  taskPollTimer = null;
-  statusReportTimer = null;
-  registeredWorkerId = null;
-  running = false;
-  executing = false;
-  constructor(opts) {
-    this.config = opts.config;
-    this.workerConfig = opts.workerConfig;
-    this.server = new WorkerServer({
-      workerId: this.workerConfig.worker_id,
-      port: this.workerConfig.worker_port,
-      maxContexts: this.workerConfig.max_contexts,
-      memoryDaemonUrl: this.config.memory.daemon_url,
-      ollamaUrl: this.config.ollama.base_url
-    });
-    this.memory = new MemoryClient(this.config.memory);
-    this.agent = new Agent(this.config);
-  }
-  /**
-   * Start the worker: HTTP server, register with Primary, begin task loop.
-   */
-  async start() {
-    this.running = true;
-    this.server.onContextAssigned((contextName, description) => {
-      console.log(`[worker] Context assigned: "${contextName}" \u2014 ${description || "(no description)"}`);
-      this.memory.createContext(contextName, description).catch((err) => {
-        console.warn(`[worker] Failed to create context "${contextName}" in daemon:`, err.message);
-      });
-    });
-    await this.server.start();
-    console.log(`[worker] HTTP server listening on port ${this.workerConfig.worker_port}`);
-    const memoryOk = await this.memory.healthCheck();
-    if (memoryOk) {
-      console.log("[worker] Local memory daemon connected");
-    } else {
-      console.warn("[worker] Memory daemon unreachable at", this.config.memory.daemon_url);
-      console.warn("[worker] Continuing \u2014 episodes will not be stored until daemon is available");
-    }
-    await this.registerWithPrimary();
-    this.startTaskLoop();
-    this.startStatusReporting();
-    console.log("[worker] Ready \u2014 waiting for context assignments");
-  }
-  /**
-   * Stop the worker gracefully.
-   */
-  async stop() {
-    this.running = false;
-    if (this.taskPollTimer) {
-      clearInterval(this.taskPollTimer);
-      this.taskPollTimer = null;
-    }
-    if (this.statusReportTimer) {
-      clearInterval(this.statusReportTimer);
-      this.statusReportTimer = null;
-    }
-    await this.server.stop();
-    console.log("[worker] Stopped");
-  }
-  /**
-   * Register this worker with the Primary node.
-   */
-  async registerWithPrimary() {
-    const workerUrl = `http://localhost:${this.workerConfig.worker_port}`;
-    const registration = {
-      url: workerUrl,
-      capabilities: {
-        max_contexts: this.workerConfig.max_contexts,
-        has_ollama: true,
-        has_memory_daemon: true,
-        available_models: [this.config.memory.embedding_model]
-      }
-    };
-    try {
-      const resp = await fetch(
-        `${this.workerConfig.primary_url}${PRIMARY_ROUTES.register}`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(registration)
-        }
-      );
-      if (!resp.ok) {
-        console.error(`[worker] Registration failed: ${resp.status} ${await resp.text()}`);
-        return null;
-      }
-      const result = await resp.json();
-      this.registeredWorkerId = result.worker_id;
-      console.log(`[worker] Registered with Primary as ${result.worker_id}`);
-      return result;
-    } catch (err) {
-      console.error("[worker] Could not reach Primary at", this.workerConfig.primary_url);
-      console.error("[worker] Will continue in standalone mode \u2014 retry registration manually");
-      return null;
-    }
-  }
-  /**
-   * Start the task execution polling loop.
-   * Iterates assigned contexts and picks up tasks from each queue.
-   */
-  startTaskLoop() {
-    this.taskPollTimer = setInterval(() => {
-      if (!this.running || this.executing) return;
-      this.executeNextTask().catch((err) => {
-        console.error("[worker] Task execution error:", err.message);
-      });
-    }, this.workerConfig.task_poll_interval_ms);
-  }
-  /**
-   * Find and execute the next available task across all assigned contexts.
-   */
-  async executeNextTask() {
-    const contexts = this.server.getAssignedContexts();
-    if (contexts.length === 0) return;
-    for (const contextName of contexts) {
-      const engine = new TaskEngine({ contextName, memory: this.memory });
-      const task = await engine.getNextTask();
-      if (task) {
-        this.executing = true;
-        try {
-          this.server.setActiveContext(contextName);
-          this.server.setCurrentTask(task.id);
-          console.log(`[worker] Executing task [${task.id.slice(0, 8)}] "${task.title}" in context "${contextName}"`);
-          await engine.startTask(task.id);
-          this.agent.setContext(contextName);
-          try {
-            await this.memory.createContext(contextName);
-          } catch {
-          }
-          const taskPrompt = buildTaskPrompt(task.title, task.description);
-          const response = await this.agent.processMessage(taskPrompt);
-          console.log(`[worker] Task [${task.id.slice(0, 8)}] completed. Response: ${response.content.slice(0, 100)}...`);
-          await engine.completeTask(task.id);
-          await this.reportStatus("working", contextName, task.id);
-        } catch (err) {
-          console.error(`[worker] Task [${task.id.slice(0, 8)}] failed:`, err.message);
-          await this.reportStatus("error", contextName, task.id, err.message);
-        } finally {
-          this.executing = false;
-          this.server.setCurrentTask(null);
-        }
-        return;
-      }
-    }
-    if (this.server.getAssignedContexts().length > 0) {
-      this.server.setActiveContext(null);
-      this.server.setCurrentTask(null);
-    }
-  }
-  /**
-   * Periodically report status back to Primary.
-   */
-  startStatusReporting() {
-    this.statusReportTimer = setInterval(() => {
-      if (!this.running || !this.registeredWorkerId) return;
-      const contexts = this.server.getAssignedContexts();
-      if (contexts.length === 0) return;
-      this.reportStatus(
-        this.executing ? "working" : "idle",
-        this.executing ? contexts[0] : null,
-        null
-      ).catch(() => {
-      });
-    }, this.workerConfig.status_report_interval_ms);
-  }
-  /**
-   * Send a status report to the Primary.
-   */
-  async reportStatus(activity, currentContext, currentTask, error) {
-    if (!this.registeredWorkerId) return;
-    const report = {
-      activity,
-      current_context: currentContext,
-      current_task: currentTask,
-      error
-    };
-    try {
-      const statusUrl = `${this.workerConfig.primary_url}${PRIMARY_ROUTES.status(this.registeredWorkerId)}`;
-      await fetch(statusUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(report)
-      });
-    } catch {
-    }
-  }
-  // --- Accessors for testing ---
-  getServer() {
-    return this.server;
-  }
-  getAgent() {
-    return this.agent;
-  }
-  getMemoryClient() {
-    return this.memory;
-  }
-  isRunning() {
-    return this.running;
-  }
-  isExecuting() {
-    return this.executing;
-  }
-  getRegisteredWorkerId() {
-    return this.registeredWorkerId;
-  }
-};
-function buildTaskPrompt(title, description) {
-  let prompt = `[TASK] ${title}`;
-  if (description) {
-    prompt += `
-
-${description}`;
-  }
-  prompt += "\n\nPlease work on this task. Use your memory and knowledge to provide a thorough response.";
-  return prompt;
-}
-async function startWorker(config) {
-  if (!config.worker || !config.worker.enabled) {
-    throw new Error("Worker mode is not enabled in config. Set [worker] enabled = true.");
-  }
-  const runtime = new WorkerRuntime({
-    config,
-    workerConfig: config.worker
-  });
-  await runtime.start();
-  return runtime;
-}
-
-export {
-  LLMClient,
-  MemoryClient,
-  ContextManager,
-  TaskEngine,
-  buildSystemPrompt,
-  buildMessages,
-  Agent,
-  loadConfig,
-  SesameClient,
-  startPipeline,
-  PRIMARY_ROUTES,
-  WORKER_ROUTES,
-  DEFAULT_HEALTH_INTERVAL_MS,
-  HEALTH_TIMEOUT_MS,
-  DEFAULT_SYNC_INTERVAL_MS,
-  WorkerServer,
-  WorkerRuntime,
-  startWorker
-};
-//# sourceMappingURL=chunk-2I2O6X5D.js.map