@sesamespace/hivemind 0.5.5 → 0.5.7

package/dist/chunk-4U4GKI3X.js

@@ -0,0 +1,2413 @@
+import {
+  SesameClient
+} from "./chunk-GPI4RU7N.js";
+
+// 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, readdirSync } from "fs";
+import { resolve } from "path";
+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;
+}
+var WORKSPACE_FILE_PRIORITY = [
+  "SOUL.md",
+  // Who the agent is (personality, values)
+  "IDENTITY.md",
+  // Name, avatar, creature type
+  "AGENTS.md",
+  // Operating instructions
+  "USER.md",
+  // About the human(s)
+  "TOOLS.md"
+  // Tool-specific notes
+];
+var workspaceCache = null;
+var WORKSPACE_CACHE_TTL_MS = 6e4;
+function loadWorkspaceFiles(dir) {
+  const now = Date.now();
+  if (workspaceCache && workspaceCache.dir === dir && now - workspaceCache.loadedAt < WORKSPACE_CACHE_TTL_MS) {
+    return workspaceCache.files;
+  }
+  const files = /* @__PURE__ */ new Map();
+  if (!existsSync(dir)) return files;
+  for (const filename of WORKSPACE_FILE_PRIORITY) {
+    const filePath = resolve(dir, filename);
+    if (existsSync(filePath)) {
+      try {
+        files.set(filename, readFileSync(filePath, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry.endsWith(".md") && !files.has(entry) && !entry.startsWith(".")) {
+        const filePath = resolve(dir, entry);
+        try {
+          files.set(entry, readFileSync(filePath, "utf-8"));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  workspaceCache = { dir, files, loadedAt: now };
+  const names = [...files.keys()].join(", ");
+  if (files.size > 0) {
+    console.log(`[workspace] Loaded ${files.size} files: ${names}`);
+  }
+  return files;
+}
+function buildSystemPrompt(config, episodes, contextName = "global", l3Knowledge = []) {
+  let prompt = `You are ${config.name}. ${config.personality}
+`;
+  if (config.workspace) {
+    const wsFiles = loadWorkspaceFiles(config.workspace);
+    if (wsFiles.size > 0) {
+      prompt += "\n# Workspace Context\n";
+      for (const [filename, content] of wsFiles) {
+        prompt += `
+## ${filename}
+${content}
+`;
+      }
+    }
+  }
+  if (config.team_charter && !config.workspace) {
+    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 as resolve2, dirname } from "path";
+
+// node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/util.js
+function isEscaped(str, ptr) {
+  let i = 0;
+  while (str[ptr - ++i] === "\\")
+    ;
+  return --i && i % 2;
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf("\n", start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "\n")
+      return i;
+    if (c === "\r" && str[i + 1] === "\n")
+      return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
+    ptr++;
+  return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+function getStringEnd(str, seek) {
+  let first = str[seek];
+  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+  seek += target.length - 1;
+  do
+    seek = str.indexOf(target, ++seek);
+  while (seek > -1 && first !== "'" && isEscaped(str, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str[seek] === first)
+        seek++;
+      if (str[seek] === first)
+        seek++;
+    }
+  }
+  return seek;
+}
+
+// node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+var ESC_MAP = {
+  b: "\b",
+  t: "	",
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  e: "\x1B",
+  '"': '"',
+  "\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+  let isLiteral = str[ptr] === "'";
+  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str[ptr += 2] === "\r")
+      ptr++;
+    if (str[ptr] === "\n")
+      ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str[ptr++];
+    if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+      if (!isMultiline) {
+        throw new TomlError("newlines are not allowed in strings", {
+          toml: str,
+          ptr: ptr - 1
+        });
+      }
+    } else if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    }
+    if (isEscape) {
+      isEscape = false;
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+        ptr = skipVoid(str, ptr - 1, true);
+        if (str[ptr] !== "\n" && str[ptr] !== "\r") {
+          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        ptr = skipVoid(str, ptr);
+      } else if (c in ESC_MAP) {
+        parsed += ESC_MAP[c];
+      } else {
+        throw new TomlError("unrecognized escape sequence", {
+          toml: str,
+          ptr: tmp
+        });
+      }
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
+}
+
+// node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str, ptr);
+    let parsed = parseString(str, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str, endPtr);
+      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr
+        });
+      }
+      endPtr += +(str[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    endPtr += +(str[endPtr] === ",");
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+
+// node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "	") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let eos = getStringEnd(str, ptr);
+        if (eos < 0) {
+          throw new TomlError("unfinished string encountered", {
+            toml: str,
+            ptr
+          });
+        }
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(parseString(str, ptr, eos));
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+
+// node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(
+        k[0],
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(
+        k[0],
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+
+// packages/runtime/src/config.ts
+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 defaultSentinelConfig() {
+  return {
+    poll_interval_ms: 5e3,
+    health_timeout_ms: 3e3,
+    max_restart_attempts: 5,
+    backoff_base_ms: 5e3,
+    backoff_max_ms: 3e5,
+    agent_startup_grace_ms: 15e3,
+    health_port: 9484,
+    pid_file: "/tmp/hivemind-agent.pid",
+    stop_flag_file: "/tmp/hivemind-agent.stopped"
+  };
+}
+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 = resolve2(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;
+  }
+  if (process.env.SENTINEL_POLL_INTERVAL_MS) {
+    if (!parsed.sentinel) parsed.sentinel = defaultSentinelConfig();
+    parsed.sentinel.poll_interval_ms = parseInt(process.env.SENTINEL_POLL_INTERVAL_MS, 10);
+  }
+  if (process.env.SENTINEL_HEALTH_PORT) {
+    if (!parsed.sentinel) parsed.sentinel = defaultSentinelConfig();
+    parsed.sentinel.health_port = parseInt(process.env.SENTINEL_HEALTH_PORT, 10);
+  }
+  if (process.env.SENTINEL_PID_FILE) {
+    if (!parsed.sentinel) parsed.sentinel = defaultSentinelConfig();
+    parsed.sentinel.pid_file = process.env.SENTINEL_PID_FILE;
+  }
+  if (process.env.SENTINEL_STOP_FLAG_FILE) {
+    if (!parsed.sentinel) parsed.sentinel = defaultSentinelConfig();
+    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);
+  }
+  return parsed;
+}
+
+// packages/runtime/src/sesame.ts
+import { readFileSync as readFileSync3 } from "fs";
+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"));
+  RUNTIME_VERSION = pkg.version ?? "unknown";
+} catch {
+}
+var SesameClient2 = class {
+  config;
+  sdk;
+  messageHandler = null;
+  upgradeHandler = null;
+  restartHandler = null;
+  agentId = null;
+  channels = /* @__PURE__ */ new Map();
+  typingIntervals = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+    this.sdk = new SesameClient({
+      apiUrl: config.api_url.replace(/\/api\/v1$/, ""),
+      wsUrl: config.ws_url,
+      apiKey: config.api_key
+    });
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onUpgrade(handler) {
+    this.upgradeHandler = handler;
+  }
+  onRestart(handler) {
+    this.restartHandler = 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.updatePresence("online", { emoji: "\u{1F7E2}" });
+    this.sdk.on("upgrade.request", (event) => {
+      console.log(`[sesame] Upgrade request received: ${event.packageName}@${event.targetVersion}`);
+      if (this.upgradeHandler) {
+        this.upgradeHandler({
+          targetVersion: event.targetVersion,
+          packageName: event.packageName,
+          requestedBy: event.requestedBy,
+          requestId: event.requestId
+        });
+      }
+    });
+    this.sdk.on("restart.request", (event) => {
+      console.log(`[sesame] Restart requested by ${event.requestedBy}`);
+      if (this.restartHandler) {
+        this.restartHandler({
+          requestedBy: event.requestedBy,
+          requestId: event.requestId
+        });
+      }
+    });
+    this.sdk.on("control", (event) => {
+      console.log(`[sesame] Control event: ${event.action}`, event.payload);
+    });
+    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");
+    const ws = this.sdk.ws;
+    if (ws?.readyState === 1) {
+      ws.send(JSON.stringify({ type: "meta", runtime: "hivemind", version: RUNTIME_VERSION }));
+      console.log(`[sesame] Reported version: hivemind@${RUNTIME_VERSION}`);
+    }
+  }
+  // ── Typing Indicators ──
+  /**
+   * Start sending typing indicators for a channel.
+   * Sends immediately, then every 2.5s until stopTyping() is called.
+   */
+  startTyping(channelId) {
+    if (this.typingIntervals.has(channelId)) return;
+    this.sdk.sendTyping(channelId);
+    const interval = setInterval(() => {
+      this.sdk.sendTyping(channelId);
+    }, 2500);
+    this.typingIntervals.set(channelId, interval);
+  }
+  /**
+   * Stop sending typing indicators for a channel.
+   */
+  stopTyping(channelId) {
+    const interval = this.typingIntervals.get(channelId);
+    if (interval) {
+      clearInterval(interval);
+      this.typingIntervals.delete(channelId);
+    }
+  }
+  /**
+   * Stop all active typing indicators.
+   */
+  stopAllTyping() {
+    for (const [channelId, interval] of this.typingIntervals) {
+      clearInterval(interval);
+    }
+    this.typingIntervals.clear();
+  }
+  // ── Presence ──
+  /**
+   * Update agent presence/status.
+   * @param status - "online" | "thinking" | "working" | "idle" | "offline"
+   * @param options - Optional detail text, progress (0-100), emoji
+   */
+  updatePresence(status, options) {
+    if (typeof this.sdk.updatePresence === "function") {
+      this.sdk.updatePresence(status, options);
+    } else {
+      const ws = this.sdk.ws;
+      if (ws?.readyState === 1) {
+        ws.send(JSON.stringify({ type: "status", status, ...options }));
+      }
+    }
+  }
+  // ── Read Receipts ──
+  /**
+   * Mark a channel as read up to a given sequence number.
+   */
+  async markRead(channelId, seq) {
+    await this.sdk.markRead(channelId, seq);
+  }
+  // ── Messages ──
+  async sendMessage(channelId, content) {
+    await this.sdk.sendMessage(channelId, { content });
+  }
+  getAgentId() {
+    return this.agentId;
+  }
+  getChannelInfo(channelId) {
+    return this.channels.get(channelId);
+  }
+  disconnect() {
+    this.stopAllTyping();
+    this.updatePresence("offline");
+    this.sdk.disconnect();
+  }
+};
+
+// packages/runtime/src/pipeline.ts
+import { createServer } 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";
+import { fileURLToPath as fileURLToPath2 } 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"));
+  PACKAGE_VERSION = pkg.version ?? "unknown";
+} catch {
+}
+var sesameConnected = false;
+var memoryConnected = false;
+var startTime = Date.now();
+function startHealthServer(port) {
+  const server = createServer((req, res) => {
+    if (req.method === "GET" && req.url === HEALTH_PATH) {
+      const status = {
+        status: sesameConnected ? "ok" : "degraded",
+        pid: process.pid,
+        uptime_s: Math.floor((Date.now() - startTime) / 1e3),
+        sesame_connected: sesameConnected,
+        memory_connected: memoryConnected,
+        version: PACKAGE_VERSION
+      };
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(status));
+    } else {
+      res.writeHead(404);
+      res.end();
+    }
+  });
+  server.listen(port, "127.0.0.1", () => {
+    console.log(`[hivemind] Health endpoint listening on http://127.0.0.1:${port}${HEALTH_PATH}`);
+  });
+  return server;
+}
+function writePidFile(path) {
+  writeFileSync(path, String(process.pid));
+  console.log(`[hivemind] PID file written: ${path}`);
+}
+function cleanupPidFile(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+async function startPipeline(configPath) {
+  const config = loadConfig(configPath);
+  const sentinel = config.sentinel ?? defaultSentinelConfig();
+  const healthPort = sentinel.health_port || HEALTH_PORT;
+  const pidFile = sentinel.pid_file;
+  console.log(`[hivemind] Starting ${config.agent.name} (pid ${process.pid})`);
+  writePidFile(pidFile);
+  const healthServer = startHealthServer(healthPort);
+  const cleanupOnExit = () => {
+    cleanupPidFile(pidFile);
+    healthServer.close();
+  };
+  process.on("exit", cleanupOnExit);
+  const memory = new MemoryClient(config.memory);
+  const memoryOk = await memory.healthCheck();
+  if (!memoryOk) {
+    console.warn("[hivemind] Memory daemon unreachable at", config.memory.daemon_url);
+    console.warn("[hivemind] Continuing without persistent memory \u2014 episodes will not be stored");
+  } else {
+    memoryConnected = true;
+    console.log("[hivemind] Memory daemon connected");
+  }
+  const 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 SesameClient2(config.sesame);
+  let shuttingDown = false;
+  const shutdown = (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(`
+[hivemind] Received ${signal}, shutting down...`);
+    try {
+      sesame.updatePresence("offline", { emoji: "\u2B58" });
+      sesame.disconnect();
+      console.log("[hivemind] Sesame disconnected cleanly");
+    } catch (err) {
+      console.error("[hivemind] Error during disconnect:", err.message);
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  sesame.onMessage(async (msg) => {
+    if (shuttingDown) return;
+    console.log(`[sesame] ${msg.author.handle} (${msg.channelKind}): ${msg.content}`);
+    sesame.startTyping(msg.channelId);
+    sesame.updatePresence("thinking", { detail: `Replying to ${msg.author.handle}`, emoji: "\u{1F4AD}" });
+    try {
+      const prefix = msg.channelKind === "group" ? `[${msg.author.handle} in group chat]: ` : `[${msg.author.handle}]: `;
+      const response = await agent.processMessage(prefix + msg.content);
+      sesame.stopTyping(msg.channelId);
+      if (response.content.trim() === "__SKIP__") {
+        console.log(`[sesame] ${config.agent.name}: skipped (${msg.author.handle} in ${msg.channelKind})`);
+        sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
+        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)}...`);
+      sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
+    } catch (err) {
+      sesame.stopTyping(msg.channelId);
+      sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
+      console.error("[sesame] Error processing message:", err.message);
+    }
+  });
+  await sesame.connect();
+  sesameConnected = true;
+  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((resolve5) => {
+    rl.on("close", resolve5);
+  });
+}
+
+// packages/runtime/src/fleet/worker-server.ts
+import { createServer as createServer2 } 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((resolve5, reject) => {
+      this.server = createServer2((req, res) => this.handleRequest(req, res));
+      this.server.on("error", reject);
+      this.server.listen(this.port, () => resolve5());
+    });
+  }
+  /** Stop the server. */
+  async stop() {
+    return new Promise((resolve5) => {
+      if (!this.server) {
+        resolve5();
+        return;
+      }
+      this.server.close(() => resolve5());
+    });
+  }
+  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((resolve5, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve5(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,
+  defaultSentinelConfig,
+  loadConfig,
+  SesameClient2 as SesameClient,
+  HEALTH_PATH,
+  startPipeline,
+  PRIMARY_ROUTES,
+  WORKER_ROUTES,
+  DEFAULT_HEALTH_INTERVAL_MS,
+  HEALTH_TIMEOUT_MS,
+  DEFAULT_SYNC_INTERVAL_MS,
+  WorkerServer,
+  WorkerRuntime,
+  startWorker
+};
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/date.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/
+//# sourceMappingURL=chunk-4U4GKI3X.js.map