@sesamespace/hivemind 0.12.5 → 0.12.7

package/dist/{chunk-PGLO6WA5.js → chunk-CEJEBZTB.js}

@@ -3049,7 +3049,7 @@ var SesameClient = class {
    * Connect to the real-time WebSocket gateway.
    */
   connect() {
-    return new Promise((resolve21, reject) => {
+    return new Promise((resolve22, reject) => {
       try {
         this.ws = new WebSocket(`${this.config.wsUrl}/v1/connect`);
         this.ws.on("open", () => {
@@ -3063,7 +3063,7 @@ var SesameClient = class {
               this.authenticated = true;
               this.startHeartbeat(event.heartbeatIntervalMs ?? 3e4);
               this.sendReplay();
-              resolve21();
+              resolve22();
               return;
             }
             if (event.type === "pong")
@@ -3249,6 +3249,10 @@ var SesameClient2 = class {
   agentId = null;
   channels = /* @__PURE__ */ new Map();
   typingIntervals = /* @__PURE__ */ new Map();
+  /** Messages held briefly to allow streaming edits to replace initial fragments */
+  pendingMessages = /* @__PURE__ */ new Map();
+  /** How long to wait for streaming edits before delivering (ms) */
+  MESSAGE_HOLD_MS = 3e3;
   constructor(config) {
     this.config = config;
     this.sdk = new SesameClient({
@@ -3305,8 +3309,9 @@ var SesameClient2 = class {
       if (senderId === this.agentId) return;
       if (!this.messageHandler || !msg.content) return;
       const channelInfo = this.channels.get(msg.channelId);
-      this.messageHandler({
-        id: msg.id || "unknown",
+      const messageId = msg.id || "unknown";
+      const sesameMsg = {
+        id: messageId,
         channelId: msg.channelId || "unknown",
         channelKind: channelInfo?.kind || "dm",
         content: msg.content,
@@ -3315,7 +3320,52 @@ var SesameClient2 = class {
           handle: msg.senderHandle || msg.metadata?.senderHandle || "unknown"
         },
         timestamp: msg.createdAt || (/* @__PURE__ */ new Date()).toISOString()
-      });
+      };
+      const existing = this.pendingMessages.get(messageId);
+      if (existing && !existing.delivered) {
+        existing.message = sesameMsg;
+        return;
+      }
+      const pending = {
+        message: sesameMsg,
+        delivered: false,
+        timer: setTimeout(() => {
+          const p = this.pendingMessages.get(messageId);
+          if (p && !p.delivered && this.messageHandler) {
+            p.delivered = true;
+            this.messageHandler(p.message);
+          }
+          this.pendingMessages.delete(messageId);
+        }, this.MESSAGE_HOLD_MS)
+      };
+      this.pendingMessages.set(messageId, pending);
+    });
+    this.sdk.on("message.edited", (event) => {
+      const msg = event.data || event.message || event;
+      const senderId = msg.senderId || msg.sender?.id;
+      if (senderId === this.agentId) return;
+      if (event.streaming) return;
+      const messageId = msg.id || "unknown";
+      const channelInfo = this.channels.get(msg.channelId);
+      const updatedMsg = {
+        id: messageId,
+        channelId: msg.channelId || "unknown",
+        channelKind: channelInfo?.kind || "dm",
+        content: msg.content,
+        author: {
+          id: senderId || "unknown",
+          handle: msg.senderHandle || msg.metadata?.senderHandle || "unknown"
+        },
+        timestamp: msg.updatedAt || msg.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const pending = this.pendingMessages.get(messageId);
+      if (pending && !pending.delivered) {
+        pending.message = updatedMsg;
+        return;
+      }
+      if (this.messageHandler && msg.content) {
+        this.messageHandler(updatedMsg);
+      }
     });
     await this.sdk.connect();
     console.log("[sesame] WebSocket connected");
@@ -4225,12 +4275,12 @@ var LogWatcher = class extends BackgroundProcess {
   }
   savePositions() {
     try {
-      const { mkdirSync: mkdirSync16, writeFileSync: writeFileSync10 } = __require("fs");
-      const { dirname: dirname9 } = __require("path");
-      const dir = dirname9(this.positionsFile);
-      if (!existsSync7(dir)) mkdirSync16(dir, { recursive: true });
+      const { mkdirSync: mkdirSync17, writeFileSync: writeFileSync11 } = __require("fs");
+      const { dirname: dirname10 } = __require("path");
+      const dir = dirname10(this.positionsFile);
+      if (!existsSync7(dir)) mkdirSync17(dir, { recursive: true });
       const data = Object.fromEntries(this.tailPositions);
-      writeFileSync10(this.positionsFile, JSON.stringify(data));
+      writeFileSync11(this.positionsFile, JSON.stringify(data));
     } catch (err) {
       log2.warn("failed to save tail positions", {
         error: err.message
@@ -4750,10 +4800,10 @@ function parseQuery(url) {
   return params;
 }
 function readBody(req) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve21(Buffer.concat(chunks).toString()));
+    req.on("end", () => resolve22(Buffer.concat(chunks).toString()));
     req.on("error", reject);
   });
 }
@@ -5178,13 +5228,13 @@ function registerFileTools(registry, workspaceDir) {
       required: []
     },
     async (params) => {
-      const { readdirSync: readdirSync5, statSync: statSync5 } = await import("fs");
+      const { readdirSync: readdirSync6, statSync: statSync5 } = await import("fs");
       const dirPath = params.path ? resolvePath(workspaceDir, params.path) : workspaceDir;
       if (!existsSync10(dirPath)) {
         return `Error: Directory not found: ${dirPath}`;
       }
       try {
-        const entries = readdirSync5(dirPath);
+        const entries = readdirSync6(dirPath);
         const results = [];
         for (const entry of entries) {
           if (entry.startsWith(".")) continue;
@@ -7898,7 +7948,7 @@ function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
         contextBridge.on("error-encountered", errorHandler);
       }
       try {
-        const output = await new Promise((resolve21, reject) => {
+        const output = await new Promise((resolve22, reject) => {
           const child = exec2(command, {
             cwd,
             timeout: timeoutSeconds * 1e3,
@@ -7915,7 +7965,7 @@ function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
               error.stderr = stderr;
               reject(error);
             } else {
-              resolve21(stdout);
+              resolve22(stdout);
             }
           });
           child.stdin?.end();
@@ -7966,6 +8016,9 @@ ${output || err.message}`;
         if (contextBridge && errorHandler) {
           contextBridge.off("error-encountered", errorHandler);
         }
+        if (contextBridge) {
+          contextBridge.cleanupContextFile();
+        }
       }
     }
   );
@@ -8633,12 +8686,12 @@ Path: ${skillDir}`;
 }
 
 // packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
-import { resolve as resolve20, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
+import { resolve as resolve21, dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // packages/runtime/src/tools/context-bridge.ts
-import { writeFileSync as writeFileSync8, readFileSync as readFileSync15, statSync as statSync4, existsSync as existsSync20, mkdirSync as mkdirSync15, openSync, readSync, closeSync } from "fs";
+import { writeFileSync as writeFileSync8, readFileSync as readFileSync15, statSync as statSync4, existsSync as existsSync20, mkdirSync as mkdirSync15, openSync, readSync, closeSync, readdirSync as readdirSync5, unlinkSync as unlinkSync3 } from "fs";
 import { createHash as createHash2 } from "crypto";
 import { join as join8 } from "path";
 import { homedir } from "os";
@@ -8649,16 +8702,20 @@ var ClaudeContextBridge = class extends EventEmitter2 {
   logger;
   sessionLogPath;
   contextFilePath;
+  sessionArchiveDir;
   watchInterval = null;
   lastLogSize = 0;
   seenPatterns = /* @__PURE__ */ new Set();
+  currentSessionId;
   constructor(config) {
     super();
     this.workspaceDir = config.workspaceDir;
     this.memoryClient = config.memoryClient;
     this.logger = config.logger;
     this.sessionLogPath = join8(homedir(), ".claude", "session.log");
-    this.contextFilePath = join8(this.workspaceDir, "CLAUDE_CONTEXT.md");
+    this.sessionArchiveDir = join8(homedir(), ".claude", "sessions");
+    this.contextFilePath = join8(this.workspaceDir, ".claude-context-current.md");
+    this.currentSessionId = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   }
   /**
    * Initialize the context bridge
@@ -8668,10 +8725,49 @@ var ClaudeContextBridge = class extends EventEmitter2 {
     if (!existsSync20(claudeDir)) {
       mkdirSync15(claudeDir, { recursive: true });
     }
+    if (!existsSync20(this.sessionArchiveDir)) {
+      mkdirSync15(this.sessionArchiveDir, { recursive: true });
+    }
+    await this.archiveSessionLog();
     await this.setupClaudeSettings();
     this.startLogMonitoring();
     this.logger.info("Claude context bridge initialized");
   }
+  /**
+   * Archive previous session log if it exists
+   */
+  async archiveSessionLog() {
+    if (existsSync20(this.sessionLogPath)) {
+      const stats = statSync4(this.sessionLogPath);
+      if (stats.size > 0) {
+        const archivePath = join8(this.sessionArchiveDir, `${this.currentSessionId}.log`);
+        const content = readFileSync15(this.sessionLogPath, "utf-8");
+        writeFileSync8(archivePath, content);
+        writeFileSync8(this.sessionLogPath, "");
+        this.logger.info("Archived previous session log", { path: archivePath });
+        this.cleanupOldArchives();
+      }
+    }
+  }
+  /**
+   * Clean up old session archives, keeping only the most recent ones
+   */
+  cleanupOldArchives() {
+    try {
+      const files = readdirSync5(this.sessionArchiveDir).filter((f) => f.endsWith(".log")).map((f) => ({
+        name: f,
+        path: join8(this.sessionArchiveDir, f),
+        mtime: statSync4(join8(this.sessionArchiveDir, f)).mtime
+      })).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+      const toDelete = files.slice(10);
+      for (const file of toDelete) {
+        unlinkSync3(file.path);
+        this.logger.debug("Deleted old session archive", { file: file.name });
+      }
+    } catch (err) {
+      this.logger.warn("Failed to cleanup old archives", { error: String(err) });
+    }
+  }
   /**
    * Configure Claude Code to report insights via workspace CLAUDE.md
    */
@@ -8686,7 +8782,7 @@ When working on tasks, please report significant findings by writing to the sess
 - When you find reusable solutions: echo "PATTERN: [approach]" >> ~/.claude/session.log
 - When you encounter errors: echo "ERROR: [error details]" >> ~/.claude/session.log
 
-Always check CLAUDE_CONTEXT.md in the workspace for task context and requirements.`;
+Always check .claude-context-current.md in the workspace for task context and requirements.`;
     const claudeMdPath = join8(this.workspaceDir, "CLAUDE.md");
     writeFileSync8(claudeMdPath, instructions);
     this.logger.info("Claude workspace CLAUDE.md configured for context bridge");
@@ -8940,6 +9036,15 @@ ${memories.join("\n\n")}
       };
     }
   }
+  /**
+   * Clean up just the context file (for use after a session)
+   */
+  cleanupContextFile() {
+    if (existsSync20(this.contextFilePath)) {
+      unlinkSync3(this.contextFilePath);
+      this.logger.info("Cleaned up context file");
+    }
+  }
   /**
    * Clean up resources
    */
@@ -8950,6 +9055,7 @@ ${memories.join("\n\n")}
     }
     this.seenPatterns.clear();
     this.removeAllListeners();
+    this.cleanupContextFile();
   }
 };
 async function createContextBridge(config) {
@@ -8958,11 +9064,609 @@ async function createContextBridge(config) {
   return bridge;
 }
 
+// packages/runtime/src/sesame-sync.ts
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync9, existsSync as existsSync21, mkdirSync as mkdirSync16 } from "fs";
+import { resolve as resolve20, dirname as dirname8 } from "path";
+
+// packages/runtime/src/sesame-api.ts
+var SesameAPI = class {
+  baseUrl;
+  apiKey;
+  rateLimitRemaining = 120;
+  rateLimitResetAt = 0;
+  constructor(config) {
+    this.baseUrl = config.api_url.endsWith("/api/v1") ? config.api_url : `${config.api_url}/api/v1`;
+    this.apiKey = config.api_key;
+  }
+  // ── Internal helpers ──
+  async request(method, path, body) {
+    if (this.rateLimitRemaining <= 5 && Date.now() < this.rateLimitResetAt) {
+      const waitMs = this.rateLimitResetAt - Date.now();
+      console.warn(`[sesame-api] Rate limit low (${this.rateLimitRemaining}), waiting ${waitMs}ms`);
+      await new Promise((r) => setTimeout(r, Math.min(waitMs, 5e3)));
+    }
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const options = { method, headers };
+    if (body && method !== "GET") {
+      options.body = JSON.stringify(body);
+    }
+    try {
+      const response = await fetch(url, options);
+      const remaining = response.headers.get("x-ratelimit-remaining");
+      const reset = response.headers.get("x-ratelimit-reset");
+      if (remaining) this.rateLimitRemaining = parseInt(remaining, 10);
+      if (reset) this.rateLimitResetAt = parseInt(reset, 10) * 1e3;
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let parsed;
+        try {
+          parsed = JSON.parse(errorBody);
+        } catch {
+          parsed = { error: errorBody };
+        }
+        const err = new Error(`Sesame API ${method} ${path}: ${response.status} ${parsed.error || errorBody}`);
+        err.status = response.status;
+        err.details = parsed;
+        throw err;
+      }
+      const data = await response.json();
+      return data.data ?? data;
+    } catch (err) {
+      if (err.status) throw err;
+      console.error(`[sesame-api] Network error on ${method} ${path}:`, err.message);
+      throw err;
+    }
+  }
+  // ── Wake ──
+  async wake(agentId) {
+    return this.request("GET", `/agents/${agentId}/wake`);
+  }
+  // ── Agent State ──
+  async getState(agentId, namespace = "default") {
+    try {
+      return await this.request("GET", `/agents/${agentId}/state?namespace=${namespace}`);
+    } catch (err) {
+      if (err.status === 404) return null;
+      throw err;
+    }
+  }
+  async setState(agentId, state, namespace = "default", ttlSeconds = 86400) {
+    return this.request("PUT", `/agents/${agentId}/state`, {
+      namespace,
+      state,
+      ttlSeconds
+    });
+  }
+  // ── Agent Memory ──
+  async getMemory(agentId, category, limit = 50) {
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (category) params.set("category", category);
+    return this.request("GET", `/agents/${agentId}/memory?${params}`);
+  }
+  async setMemory(agentId, category, key, content, metadata) {
+    return this.request("PUT", `/agents/${agentId}/memory`, {
+      category,
+      key,
+      content,
+      metadata
+    });
+  }
+  async deleteMemory(agentId, memoryId) {
+    await this.request("DELETE", `/agents/${agentId}/memory/${memoryId}`);
+  }
+  // ── Agent Focus ──
+  async setFocus(agentId, taskId) {
+    await this.request("PUT", `/agents/${agentId}/focus`, { taskId });
+  }
+  async clearFocus(agentId) {
+    await this.request("DELETE", `/agents/${agentId}/focus`);
+  }
+  // ── Tasks ──
+  async createTask(task) {
+    return this.request("POST", "/tasks", task);
+  }
+  async getTask(taskId) {
+    return this.request("GET", `/tasks/${taskId}`);
+  }
+  async updateTask(taskId, updates) {
+    return this.request("PATCH", `/tasks/${taskId}`, updates);
+  }
+  async getMyTasks(status) {
+    const params = status ? `?status=${status}` : "";
+    return this.request("GET", `/tasks/mine${params}`);
+  }
+  async getNextTask() {
+    try {
+      return await this.request("GET", "/tasks/next");
+    } catch (err) {
+      if (err.status === 404) return null;
+      throw err;
+    }
+  }
+  async logActivity(taskId, type, message, metadata) {
+    return this.request("POST", `/tasks/${taskId}/activity`, {
+      type,
+      message,
+      metadata
+    });
+  }
+  async getTaskContext(taskId) {
+    try {
+      return await this.request("GET", `/tasks/${taskId}/context`);
+    } catch (err) {
+      if (err.status === 404) return null;
+      throw err;
+    }
+  }
+  async updateTaskContext(taskId, context) {
+    return this.request("PATCH", `/tasks/${taskId}/context`, context);
+  }
+  async appendTaskContext(taskId, field, values) {
+    const current = await this.getTaskContext(taskId);
+    const existing = current?.[field] ?? [];
+    const merged = [...existing, ...values.filter((v) => !existing.includes(v))];
+    return this.request("PATCH", `/tasks/${taskId}/context`, {
+      [field]: merged
+    });
+  }
+  async searchTasks(query, scope = "all") {
+    return this.request("GET", `/tasks/search?q=${encodeURIComponent(query)}&scope=${scope}`);
+  }
+  async handoffTask(taskId, toHandle, summary, instructions, reason, state) {
+    return this.request("POST", `/tasks/${taskId}/handoff`, {
+      toHandle,
+      reason: reason || "Handoff",
+      summary,
+      instructions,
+      state
+    });
+  }
+  // ── Projects ──
+  async createProject(project) {
+    return this.request("POST", "/projects", project);
+  }
+  async getProject(projectId) {
+    return this.request("GET", `/projects/${projectId}`);
+  }
+  async getProjectContext(projectId) {
+    try {
+      return await this.request("GET", `/projects/${projectId}/context`);
+    } catch (err) {
+      if (err.status === 404) return null;
+      throw err;
+    }
+  }
+  async updateProjectContext(projectId, context) {
+    return this.request("PUT", `/projects/${projectId}/context`, context);
+  }
+  // ── Schedule ──
+  async syncSchedule(events) {
+    return this.request("PUT", "/schedule/sync", { events });
+  }
+  async recordOccurrence(eventId, scheduledAt, status, result) {
+    return this.request("POST", `/schedule/${eventId}/occurrences`, {
+      scheduledAt,
+      status,
+      result
+    });
+  }
+  // ── Utility ──
+  getRateLimitRemaining() {
+    return this.rateLimitRemaining;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+};
+
+// packages/runtime/src/sesame-sync.ts
+function defaultSyncState() {
+  return {
+    lastStatePush: null,
+    lastL3Sync: null,
+    syncedL3Keys: [],
+    lastMemoryMdHash: null,
+    lastWake: null
+  };
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash.toString(36);
+}
+var SesameSync = class {
+  api;
+  agentId;
+  workspaceDir;
+  dataDir;
+  syncState;
+  syncStatePath;
+  syncInterval = null;
+  constructor(config, agentId, workspaceDir, dataDir) {
+    this.api = new SesameAPI(config);
+    this.agentId = agentId;
+    this.workspaceDir = workspaceDir;
+    this.dataDir = dataDir;
+    this.syncStatePath = resolve20(dataDir, "sesame-sync-state.json");
+    this.syncState = this.loadSyncState();
+  }
+  // ── State Persistence ──
+  loadSyncState() {
+    try {
+      if (existsSync21(this.syncStatePath)) {
+        return JSON.parse(readFileSync16(this.syncStatePath, "utf-8"));
+      }
+    } catch (err) {
+      console.warn("[sesame-sync] Failed to load sync state:", err.message);
+    }
+    return defaultSyncState();
+  }
+  saveSyncState() {
+    try {
+      const dir = dirname8(this.syncStatePath);
+      if (!existsSync21(dir)) mkdirSync16(dir, { recursive: true });
+      writeFileSync9(this.syncStatePath, JSON.stringify(this.syncState, null, 2));
+    } catch (err) {
+      console.warn("[sesame-sync] Failed to save sync state:", err.message);
+    }
+  }
+  // ── Push: MEMORY.md -> Agent State ──
+  /**
+   * Read MEMORY.md from workspace and push to Sesame agent state.
+   * Only pushes if content has changed since last push.
+   */
+  async pushState() {
+    const memoryMdPath = resolve20(this.workspaceDir, "MEMORY.md");
+    if (!existsSync21(memoryMdPath)) {
+      console.log("[sesame-sync] No MEMORY.md found, skipping state push");
+      return false;
+    }
+    const content = readFileSync16(memoryMdPath, "utf-8");
+    const hash = simpleHash(content);
+    if (hash === this.syncState.lastMemoryMdHash) {
+      return false;
+    }
+    try {
+      await this.api.setState(this.agentId, {
+        memoryMd: content,
+        memoryMdHash: hash,
+        lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "hivemind-sync"
+      }, "memory", 172800);
+      this.syncState.lastMemoryMdHash = hash;
+      this.syncState.lastStatePush = (/* @__PURE__ */ new Date()).toISOString();
+      this.saveSyncState();
+      console.log("[sesame-sync] Pushed MEMORY.md to agent state");
+      return true;
+    } catch (err) {
+      console.error("[sesame-sync] Failed to push state:", err.message);
+      return false;
+    }
+  }
+  // ── Push: Working Context -> Agent State ──
+  /**
+   * Push current working context (focus, active work, etc.) to agent state.
+   * This is the "default" namespace for quick session recovery.
+   */
+  async pushWorkingContext(context) {
+    try {
+      await this.api.setState(this.agentId, {
+        ...context,
+        lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "hivemind-sync"
+      }, "default", 86400);
+      console.log("[sesame-sync] Pushed working context to agent state");
+      return true;
+    } catch (err) {
+      console.error("[sesame-sync] Failed to push working context:", err.message);
+      return false;
+    }
+  }
+  // ── L3 Classification ──
+  /**
+   * Classify an L3 entry into a Sesame memory category based on content keywords.
+   * Categories: people, preferences, projects, context-recovery, lessons (default)
+   */
+  classifyL3Entry(content) {
+    const lower = content.toLowerCase();
+    const peoplePatterns = [
+      /\b(ryan|bailey|caitlin|human|user|agent)\b/,
+      /\bwork(ing|ed|s)?\s+(with|together|alongside)\b/,
+      /\b(collaborat|communicat|partner|teammate)/,
+      /\b(prefers?|expects?|wants?)\s+(me|us|the agent)\b/
+    ];
+    if (peoplePatterns.some((p) => p.test(lower))) return "people";
+    const prefPatterns = [
+      /\b(i prefer|always use|never use|best practice|my workflow)\b/,
+      /\b(default to|opt for|choose|convention)\b/,
+      /\b(style|format|approach|pattern)\s+(is|should be|works best)\b/
+    ];
+    if (prefPatterns.some((p) => p.test(lower))) return "preferences";
+    const projectPatterns = [
+      /\b(hivemind|sesame|openclaw)\b/,
+      /\b(repo(sitory)?|codebase|project|package)\b/,
+      /\bgithub\.com\b/,
+      /\b(src\/|packages\/|\.ts|\.js|\.py)\b/
+    ];
+    if (projectPatterns.some((p) => p.test(lower))) return "projects";
+    const recoveryPatterns = [
+      /\b(recover|restart|compaction|cold start|wake)\b/,
+      /\b(rebuild|restore|flush|checkpoint)\b/,
+      /\b(memory\.md|agent state|sync state)\b/
+    ];
+    if (recoveryPatterns.some((p) => p.test(lower))) return "context-recovery";
+    return "lessons";
+  }
+  // ── Push: L3 Knowledge -> Agent Memory ──
+  /**
+   * Sync L3 promoted knowledge to Sesame agent memory.
+   * Classifies entries into categories: people, preferences, projects, context-recovery, lessons.
+   * Only pushes entries that haven't been synced yet.
+   *
+   * @param memoryDaemonUrl - URL of the local memory daemon
+   */
+  async syncL3ToMemory(memoryDaemonUrl) {
+    let l3Entries;
+    try {
+      const response = await fetch(`${memoryDaemonUrl}/promotion/l3?context=global`);
+      if (!response.ok) {
+        console.warn("[sesame-sync] Failed to fetch L3 knowledge:", response.status);
+        return 0;
+      }
+      const data = await response.json();
+      l3Entries = data.entries || data || [];
+    } catch (err) {
+      console.error("[sesame-sync] Failed to fetch L3 knowledge:", err.message);
+      return 0;
+    }
+    if (!Array.isArray(l3Entries) || l3Entries.length === 0) return 0;
+    let synced = 0;
+    const syncedKeys = new Set(this.syncState.syncedL3Keys);
+    for (const entry of l3Entries) {
+      const key = entry.key || `l3-${simpleHash(entry.content)}`;
+      if (syncedKeys.has(key)) continue;
+      try {
+        const category = this.classifyL3Entry(entry.content);
+        await this.api.setMemory(
+          this.agentId,
+          category,
+          key,
+          entry.content,
+          {
+            source: "hivemind-l3-promotion",
+            l3Score: entry.score,
+            l3Context: entry.context || "global",
+            l3Category: category,
+            syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        );
+        syncedKeys.add(key);
+        synced++;
+      } catch (err) {
+        console.warn(`[sesame-sync] Failed to sync L3 entry "${key}":`, err.message);
+      }
+    }
+    if (synced > 0) {
+      this.syncState.syncedL3Keys = Array.from(syncedKeys);
+      this.syncState.lastL3Sync = (/* @__PURE__ */ new Date()).toISOString();
+      this.saveSyncState();
+      console.log(`[sesame-sync] Synced ${synced} L3 entries to Sesame agent memory`);
+    }
+    return synced;
+  }
+  // ── Pull: Wake -> Rebuild Context ──
+  /**
+   * Call the wake endpoint and return structured data for context rebuilding.
+   * This is the primary recovery mechanism after restart/compaction.
+   */
+  async pullOnWake() {
+    try {
+      const wake = await this.api.wake(this.agentId);
+      this.syncState.lastWake = (/* @__PURE__ */ new Date()).toISOString();
+      this.saveSyncState();
+      console.log("[sesame-sync] Wake data retrieved successfully");
+      return wake;
+    } catch (err) {
+      console.error("[sesame-sync] Wake failed:", err.message);
+      return null;
+    }
+  }
+  // ── Pull: Recent Channel Messages ──
+  /**
+   * Pull recent messages from unread channels after wake.
+   * Wake gives tasks/state but not conversational context — this fills that gap.
+   *
+   * @param wakeResponse - The response from pullOnWake()
+   * @param limit - Messages per channel (default: 30)
+   * @returns Map of channelId -> messages
+   */
+  async pullRecentMessages(wakeResponse, limit = 30) {
+    const result = /* @__PURE__ */ new Map();
+    const unreadChannels = wakeResponse.unreads || [];
+    if (unreadChannels.length === 0) {
+      console.log("[sesame-sync] No unread channels to pull messages from");
+      return result;
+    }
+    for (const channel of unreadChannels) {
+      const channelId = channel.channelId || channel.id;
+      if (!channelId) continue;
+      try {
+        const response = await fetch(
+          `${this.api.getBaseUrl()}/channels/${channelId}/messages?limit=${limit}&direction=before`,
+          {
+            headers: {
+              Authorization: `Bearer ${this.api.getApiKey()}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        if (!response.ok) {
+          console.warn(`[sesame-sync] Failed to fetch messages for channel ${channelId}: ${response.status}`);
+          continue;
+        }
+        const data = await response.json();
+        const messages = (data.messages || data.data || []).map((msg) => ({
+          content: msg.content || msg.plaintext || "",
+          sender: msg.senderHandle || msg.sender || "unknown",
+          timestamp: msg.createdAt || msg.timestamp || ""
+        }));
+        if (messages.length > 0) {
+          result.set(channelId, messages);
+        }
+      } catch (err) {
+        console.warn(`[sesame-sync] Failed to pull messages for ${channelId}:`, err.message);
+      }
+    }
+    console.log(`[sesame-sync] Pulled messages from ${result.size} channels`);
+    return result;
+  }
+  // ── Pull: Agent State -> MEMORY.md Recovery ──
+  /**
+   * Pull agent state and restore MEMORY.md if local copy is missing or empty.
+   */
+  async pullStateToMemoryMd() {
+    const memoryMdPath = resolve20(this.workspaceDir, "MEMORY.md");
+    if (existsSync21(memoryMdPath)) {
+      const content = readFileSync16(memoryMdPath, "utf-8").trim();
+      if (content.length > 0) {
+        return false;
+      }
+    }
+    try {
+      const state = await this.api.getState(this.agentId, "memory");
+      if (!state || !state.state.memoryMd) {
+        console.log("[sesame-sync] No MEMORY.md found in agent state");
+        return false;
+      }
+      writeFileSync9(memoryMdPath, state.state.memoryMd);
+      console.log("[sesame-sync] Restored MEMORY.md from agent state");
+      return true;
+    } catch (err) {
+      console.error("[sesame-sync] Failed to pull state:", err.message);
+      return false;
+    }
+  }
+  // ── Pre-Compaction Flush ──
+  /**
+   * Safety flush before compaction risk.
+   * Pushes MEMORY.md to agent state and updates focused task context.
+   */
+  async flushBeforeCompaction(focusedTaskId, contextSummary) {
+    console.log("[sesame-sync] Pre-compaction flush starting...");
+    await this.pushState();
+    if (contextSummary) {
+      await this.pushWorkingContext({
+        preCompactionFlush: true,
+        contextSummary,
+        focusedTaskId,
+        flushedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    if (focusedTaskId && contextSummary) {
+      try {
+        await this.api.updateTaskContext(focusedTaskId, {
+          notes: `[Pre-compaction flush ${(/* @__PURE__ */ new Date()).toISOString()}] ${contextSummary}`
+        });
+        console.log("[sesame-sync] Updated focused task context");
+      } catch (err) {
+        console.warn("[sesame-sync] Failed to update task context:", err.message);
+      }
+    }
+    console.log("[sesame-sync] Pre-compaction flush complete");
+  }
+  // ── Task Helpers ──
+  /**
+   * Log progress on a Sesame task.
+   */
+  async logTaskProgress(taskId, message) {
+    try {
+      await this.api.logActivity(taskId, "progress", message);
+    } catch (err) {
+      console.warn("[sesame-sync] Failed to log task progress:", err.message);
+    }
+  }
+  /**
+   * Log a decision on a Sesame task.
+   */
+  async logTaskDecision(taskId, message) {
+    try {
+      await this.api.logActivity(taskId, "decision", message);
+    } catch (err) {
+      console.warn("[sesame-sync] Failed to log task decision:", err.message);
+    }
+  }
+  /**
+   * Update a task's context block.
+   */
+  async updateTaskContext(taskId, context) {
+    try {
+      await this.api.updateTaskContext(taskId, context);
+    } catch (err) {
+      console.warn("[sesame-sync] Failed to update task context:", err.message);
+    }
+  }
+  // ── Periodic Sync ──
+  /**
+   * Start periodic background sync.
+   * Pushes state every intervalMs (default: 5 minutes).
+   * Syncs L3 every l3IntervalMs (default: 30 minutes).
+   */
+  startPeriodicSync(memoryDaemonUrl, intervalMs = 5 * 60 * 1e3, l3IntervalMs = 30 * 60 * 1e3) {
+    if (this.syncInterval) return;
+    let l3Counter = 0;
+    const l3Every = Math.max(1, Math.floor(l3IntervalMs / intervalMs));
+    this.syncInterval = setInterval(async () => {
+      try {
+        await this.pushState();
+        l3Counter++;
+        if (l3Counter >= l3Every) {
+          l3Counter = 0;
+          await this.syncL3ToMemory(memoryDaemonUrl);
+        }
+      } catch (err) {
+        console.error("[sesame-sync] Periodic sync error:", err.message);
+      }
+    }, intervalMs);
+    console.log(`[sesame-sync] Periodic sync started (state: ${intervalMs / 1e3}s, L3: ${l3IntervalMs / 1e3}s)`);
+  }
+  /**
+   * Stop periodic sync.
+   */
+  stopPeriodicSync() {
+    if (this.syncInterval) {
+      clearInterval(this.syncInterval);
+      this.syncInterval = null;
+      console.log("[sesame-sync] Periodic sync stopped");
+    }
+  }
+  // ── Accessors ──
+  getApi() {
+    return this.api;
+  }
+  getSyncState() {
+    return { ...this.syncState };
+  }
+  getAgentId() {
+    return this.agentId;
+  }
+};
+
 // packages/runtime/src/pipeline.ts
 var PACKAGE_VERSION = "unknown";
 try {
-  const __dirname2 = dirname8(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync16(resolve20(__dirname2, "../package.json"), "utf-8"));
+  const __dirname2 = dirname9(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync17(resolve21(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -9004,12 +9708,12 @@ function startHealthServer(port) {
   return server;
 }
 function writePidFile(path) {
-  writeFileSync9(path, String(process.pid));
+  writeFileSync10(path, String(process.pid));
   console.log(`[hivemind] PID file written: ${path}`);
 }
 function cleanupPidFile(path) {
   try {
-    unlinkSync3(path);
+    unlinkSync4(path);
   } catch {
   }
 }
@@ -9045,12 +9749,12 @@ async function startPipeline(configPath) {
       console.log("[hivemind] Global context already exists in memory daemon");
     }
   }
-  const requestLogger = new RequestLogger(resolve20(dirname8(configPath), "data", "dashboard.db"));
+  const requestLogger = new RequestLogger(resolve21(dirname9(configPath), "data", "dashboard.db"));
   const agent = new Agent(config);
   startDashboardServer(requestLogger, config.memory, () => agent.getConversationHistories());
   agent.setRequestLogger(requestLogger);
-  const hivemindHome = process.env.HIVEMIND_HOME || resolve20(process.env.HOME || "/root", "hivemind");
-  const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve21(process.env.HOME || "/root", "hivemind");
+  const workspaceDir = resolve21(hivemindHome, config.agent.workspace || "workspace");
   let contextBridge;
   if (memoryConnected) {
     try {
@@ -9084,7 +9788,7 @@ async function startPipeline(configPath) {
   agent.setToolRegistry(toolRegistry);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
   if (config.auto_debug?.enabled) {
-    const dataDir2 = resolve20(hivemindHome, "data");
+    const dataDir2 = resolve21(hivemindHome, "data");
     const autoDebugConfig = config.auto_debug;
     const logWatcher = new LogWatcher(
       {
@@ -9126,7 +9830,7 @@ async function startPipeline(configPath) {
     process.on("exit", () => processManager.stop());
     console.log("[hivemind] Auto-debug processors started");
   }
-  const dataDir = resolve20(hivemindHome, "data");
+  const dataDir = resolve21(hivemindHome, "data");
   if (config.sesame.api_key) {
     await startSesameLoop(config, agent, toolRegistry, dataDir);
   } else {
@@ -9137,6 +9841,7 @@ async function startPipeline(configPath) {
 async function startSesameLoop(config, agent, toolRegistry, dataDir) {
   const sesame = new SesameClient2(config.sesame);
   registerMessagingTools(toolRegistry, sesame);
+  let sesameSync = null;
   let eventsWatcher = null;
   if (dataDir) {
     eventsWatcher = new EventsWatcher(dataDir, async (channelId, text, filename, eventType) => {
@@ -9159,11 +9864,20 @@ async function startSesameLoop(config, agent, toolRegistry, dataDir) {
     eventsWatcher.start();
   }
   let shuttingDown = false;
-  const shutdown = (signal) => {
+  const shutdown = async (signal) => {
     if (shuttingDown) return;
     shuttingDown = true;
     console.log(`
 [hivemind] Received ${signal}, shutting down...`);
+    if (sesameSync) {
+      try {
+        await sesameSync.flushBeforeCompaction(void 0, `Shutdown via ${signal}`);
+        sesameSync.stopPeriodicSync();
+        console.log("[hivemind] Sesame state flushed before shutdown");
+      } catch (err) {
+        console.warn("[hivemind] Sesame flush failed:", err.message);
+      }
+    }
     try {
       sesame.updatePresence("offline", { emoji: "\u2B58" });
       sesame.disconnect();
@@ -9253,6 +9967,21 @@ async function startSesameLoop(config, agent, toolRegistry, dataDir) {
   await sesame.connect();
   sesameConnected = true;
   console.log("[hivemind] Listening for Sesame messages");
+  const agentId = sesame.getAgentId();
+  if (agentId && dataDir) {
+    const hivemindHome = process.env.HIVEMIND_HOME || resolve21(process.env.HOME || "/root", "hivemind");
+    const workspaceDir = resolve21(hivemindHome, config.agent.workspace || "workspace");
+    sesameSync = new SesameSync(config.sesame, agentId, workspaceDir, dataDir);
+    try {
+      await sesameSync.pushState();
+      console.log("[hivemind] Initial Sesame state sync complete");
+    } catch (err) {
+      console.warn("[hivemind] Initial Sesame state sync failed:", err.message);
+    }
+    sesameSync.startPeriodicSync(config.memory.daemon_url, 5 * 60 * 1e3, 30 * 60 * 1e3);
+    process.on("exit", () => sesameSync?.stopPeriodicSync());
+    console.log("[hivemind] Sesame sync module initialized");
+  }
   await new Promise(() => {
   });
 }
@@ -9300,8 +10029,8 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve21) => {
-    rl.on("close", resolve21);
+  return new Promise((resolve22) => {
+    rl.on("close", resolve22);
   });
 }
 async function runSpawnTask(config, configPath) {
@@ -9312,7 +10041,7 @@ async function runSpawnTask(config, configPath) {
   const spawnDir = process.env.SPAWN_DIR;
   console.log(`[spawn] Sub-agent starting (id: ${spawnId}, context: ${context})`);
   const agent = new Agent(config, context);
-  const hivemindHome = process.env.HIVEMIND_HOME || resolve20(process.env.HOME || "/root", "hivemind");
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve21(process.env.HOME || "/root", "hivemind");
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
@@ -9325,7 +10054,7 @@ async function runSpawnTask(config, configPath) {
     const result = response.content;
     console.log(`[spawn] Task completed (context: ${response.context})`);
     if (spawnDir) {
-      writeFileSync9(resolve20(spawnDir, "result.txt"), result);
+      writeFileSync10(resolve21(spawnDir, "result.txt"), result);
     }
     if (channelId && config.sesame.api_key) {
       try {
@@ -9342,7 +10071,7 @@ async function runSpawnTask(config, configPath) {
     const errorMsg = `[SPAWN ERROR] ${err.message}`;
     console.error(`[spawn] ${errorMsg}`);
     if (spawnDir) {
-      writeFileSync9(resolve20(spawnDir, "result.txt"), errorMsg);
+      writeFileSync10(resolve21(spawnDir, "result.txt"), errorMsg);
     }
     process.exitCode = 1;
   }
@@ -9373,20 +10102,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve21, reject) => {
+    return new Promise((resolve22, reject) => {
       this.server = createServer4((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve21());
+      this.server.listen(this.port, () => resolve22());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve21) => {
+    return new Promise((resolve22) => {
       if (!this.server) {
-        resolve21();
+        resolve22();
         return;
       }
-      this.server.close(() => resolve21());
+      this.server.close(() => resolve22());
     });
   }
   getPort() {
@@ -9509,10 +10238,10 @@ var WorkerServer = class {
   }
 };
 function readBody2(req) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve21(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve22(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -9854,4 +10583,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-PGLO6WA5.js.map
+//# sourceMappingURL=chunk-CEJEBZTB.js.map