@mclawnet/agent 0.6.11 → 0.6.12

package/dist/__tests__/skill-sync.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=skill-sync.test.d.ts.map

package/dist/__tests__/skill-sync.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-sync.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/skill-sync.test.ts"],"names":[],"mappings":""}

package/dist/{chunk-HQMVKDYY.js → chunk-MSDIRBXF.js}

@@ -2,6 +2,10 @@ import {
   loadConfig
 } from "./chunk-CBZIH6FY.js";
 
+// src/start.ts
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+
 // src/hub-connection.ts
 import { hostname as osHostname } from "os";
 import WebSocket from "ws";
@@ -248,7 +252,7 @@ async function handleLoadSessionHistory(workDir, claudeSessionId, opts) {
 }
 
 // src/hub-connection.ts
-import { createLogger } from "@mclawnet/logger";
+import { createLogger, previewFields } from "@mclawnet/logger";
 var log = createLogger({ module: "agent" });
 var HubConnection = class {
   ws = null;
@@ -610,6 +614,7 @@ var HubConnection = class {
       const sm = this.sessionManager;
       const spawnAndSend = (resumeId, label) => {
         log.info({ sessionId, claudeSessionId: resumeId, workDir, label }, "claude.execute: spawning");
+        log.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
         sm.createSession({ sessionId, workDir, resumeId, useBrainCore, roleId: "role-__assistant__" }).then(() => {
           sm.sendInput(sessionId, content);
         }).catch((err) => {
@@ -622,6 +627,7 @@ var HubConnection = class {
       };
       if (sm.isHealthy(sessionId)) {
         log.info({ sessionId }, "claude.execute: reusing healthy session");
+        log.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
         sm.sendInput(sessionId, content);
       } else if (sm.hasSession(sessionId) && claudeSessionId) {
         log.warn({ sessionId, claudeSessionId }, "claude.execute: session unhealthy, recreating with --resume");
@@ -689,7 +695,10 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "claude.input") {
-      log.info({ sessionId: msg.sessionId }, "claude.input");
+      log.debug(
+        { sessionId: msg.sessionId, ...previewFields(msg.content) },
+        "claude.input"
+      );
       this.sessionManager.sendInput(msg.sessionId, msg.content);
       return true;
     }
@@ -778,9 +787,299 @@ var HubConnection = class {
 };
 
 // src/session-manager.ts
-import { createLogger as createLogger2 } from "@mclawnet/logger";
+import { createLogger as createLogger3, previewFields as previewFields2 } from "@mclawnet/logger";
 import { buildMemorySection } from "@mclawnet/memory";
-var log2 = createLogger2({ module: "agent/session-manager" });
+
+// src/skill-loader.ts
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { createHash } from "crypto";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { createLogger as createLogger2 } from "@mclawnet/logger";
+import { ManifestManager, mergeSkillSections } from "@mclawnet/skill-manager";
+var log2 = createLogger2({ module: "agent/skill-loader" });
+var CLAWNET_DIR = join2(homedir2(), ".clawnet");
+var SKILLS_DIR = join2(CLAWNET_DIR, ".claude", "skills");
+var MCP_CONFIG_PATH = join2(CLAWNET_DIR, "mcp.json");
+async function initSkills() {
+  ensureSkillsDir();
+  syncBuiltinSkills(CLAWNET_DIR, defaultBuiltinSourceDir());
+  ensureMcpConfig();
+  scanSkills();
+}
+function defaultBuiltinSourceDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  return join2(dirname(thisFile), "..", "skills");
+}
+function sha256(s) {
+  return createHash("sha256").update(s).digest("hex");
+}
+function readBuiltinVersion(content) {
+  const match = content.match(/^version:\s*(.+)$/m);
+  return match ? match[1].trim().replace(/^["']|["']$/g, "") : "1.0.0";
+}
+function syncBuiltinSkills(rootDir, srcDir) {
+  const skillsDir = join2(rootDir, ".claude", "skills");
+  if (!existsSync2(skillsDir)) mkdirSync(skillsDir, { recursive: true });
+  if (!existsSync2(srcDir)) {
+    log2.debug({ srcDir }, "no built-in skills directory found, skipping");
+    return;
+  }
+  const manifest = new ManifestManager(rootDir);
+  let entries;
+  try {
+    entries = readdirSync2(srcDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    log2.warn({ srcDir }, "failed to read built-in skills directory");
+    return;
+  }
+  for (const skillName of entries) {
+    const srcSkillMd = join2(srcDir, skillName, "SKILL.md");
+    if (!existsSync2(srcSkillMd)) continue;
+    const destDir = join2(skillsDir, skillName);
+    const destSkillMd = join2(destDir, "SKILL.md");
+    const baseSnapshotPath = join2(destDir, ".base.md");
+    let officialContent;
+    try {
+      officialContent = readFileSync2(srcSkillMd, "utf-8");
+    } catch (err) {
+      log2.warn({ skill: skillName, err }, "failed to read built-in skill");
+      continue;
+    }
+    const officialHash = sha256(officialContent);
+    const officialVersion = readBuiltinVersion(officialContent);
+    if (!existsSync2(destSkillMd)) {
+      try {
+        mkdirSync(destDir, { recursive: true });
+        writeFileSync(destSkillMd, officialContent);
+        writeFileSync(baseSnapshotPath, officialContent);
+        manifest.register(skillName, officialHash, officialVersion);
+        log2.info({ skill: skillName, version: officialVersion }, "installed built-in skill");
+      } catch (err) {
+        log2.warn({ skill: skillName, err }, "failed to install built-in skill");
+      }
+      continue;
+    }
+    const userContent = readFileSync2(destSkillMd, "utf-8");
+    const userHash = sha256(userContent);
+    manifest.refresh(skillName, userHash);
+    if (!existsSync2(baseSnapshotPath)) {
+      const entry = manifest.load().skills[skillName];
+      if (entry && !entry.userModified) {
+        try {
+          writeFileSync(baseSnapshotPath, userContent);
+        } catch (err) {
+          log2.debug({ skill: skillName, err }, "failed to write lazy .base.md");
+        }
+      }
+    }
+    const action = manifest.determineSyncAction(skillName, officialHash, officialVersion);
+    switch (action) {
+      case "skip":
+        log2.debug({ skill: skillName }, "skill already up to date");
+        break;
+      case "direct-overwrite":
+        try {
+          writeFileSync(destSkillMd, officialContent);
+          writeFileSync(baseSnapshotPath, officialContent);
+          manifest.markSynced(skillName, officialHash, officialHash, officialVersion);
+          log2.info({ skill: skillName, version: officialVersion }, "upgraded built-in skill");
+        } catch (err) {
+          log2.warn({ skill: skillName, err }, "failed to overwrite skill");
+        }
+        break;
+      case "keep-user":
+        log2.debug({ skill: skillName }, "keeping user-modified skill");
+        break;
+      case "needs-merge": {
+        if (!existsSync2(baseSnapshotPath)) {
+          try {
+            writeFileSync(
+              destSkillMd + ".conflict",
+              renderConflictFile(skillName, officialContent, [
+                {
+                  section: "(entire file)",
+                  official: officialContent,
+                  user: userContent
+                }
+              ])
+            );
+            log2.warn(
+              { skill: skillName },
+              "missing .base.md snapshot \u2014 skipping auto-merge, wrote .conflict advisory"
+            );
+          } catch (err) {
+            log2.warn({ skill: skillName, err }, "failed to write .conflict advisory");
+          }
+          break;
+        }
+        const baseContent = readFileSync2(baseSnapshotPath, "utf-8");
+        const merged = mergeSkillSections(baseContent, officialContent, userContent);
+        if (merged.success && merged.content) {
+          try {
+            writeFileSync(destSkillMd, merged.content);
+            writeFileSync(baseSnapshotPath, officialContent);
+            const newCurrentHash = sha256(merged.content);
+            manifest.markSynced(skillName, officialHash, newCurrentHash, officialVersion);
+            log2.info({ skill: skillName }, "auto-merged skill upgrade");
+          } catch (err) {
+            log2.warn({ skill: skillName, err }, "failed to write merged skill");
+          }
+        } else {
+          try {
+            writeFileSync(
+              destSkillMd + ".conflict",
+              renderConflictFile(skillName, officialContent, merged.conflicts ?? [])
+            );
+            log2.warn(
+              { skill: skillName, conflicts: merged.conflicts?.length },
+              "skill merge conflict \u2014 user version kept, .conflict file written"
+            );
+          } catch (err) {
+            log2.warn({ skill: skillName, err }, "failed to write .conflict file");
+          }
+        }
+        break;
+      }
+    }
+  }
+}
+function renderConflictFile(skillName, officialContent, conflicts) {
+  const lines = [
+    `# Skill upgrade conflict: ${skillName}`,
+    ``,
+    `The official skill was updated, and your local copy was also modified.`,
+    `Please review each section below and reconcile manually.`,
+    ``,
+    `## Conflicted sections`,
+    ``
+  ];
+  for (const c of conflicts) {
+    lines.push(`### ${c.section}`);
+    lines.push("");
+    lines.push("**Official:**");
+    lines.push("```");
+    lines.push(c.official);
+    lines.push("```");
+    lines.push("");
+    lines.push("**Your version:**");
+    lines.push("```");
+    lines.push(c.user);
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Full official content");
+  lines.push("```");
+  lines.push(officialContent);
+  lines.push("```");
+  return lines.join("\n");
+}
+function ensureSkillsDir() {
+  if (!existsSync2(SKILLS_DIR)) {
+    mkdirSync(SKILLS_DIR, { recursive: true });
+    log2.info({ dir: SKILLS_DIR }, "created skills directory");
+  }
+}
+var cachedSkills = [];
+function scanSkills() {
+  if (!existsSync2(SKILLS_DIR)) return [];
+  let dirs;
+  try {
+    dirs = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    log2.warn("failed to read skills directory for scanning");
+    return [];
+  }
+  const skills = [];
+  for (const dirName of dirs) {
+    const skillMd = join2(SKILLS_DIR, dirName, "SKILL.md");
+    if (!existsSync2(skillMd)) continue;
+    try {
+      const content = readFileSync2(skillMd, "utf-8");
+      const parsed = parseFrontmatter(content);
+      if (parsed.name) {
+        skills.push({
+          name: parsed.name,
+          description: parsed.description || dirName
+        });
+      }
+    } catch (err) {
+      log2.debug({ skill: dirName, err }, "failed to parse SKILL.md frontmatter");
+    }
+  }
+  cachedSkills = skills;
+  log2.info({ count: skills.length }, "scanned skills");
+  return skills;
+}
+function getSkillList() {
+  return cachedSkills;
+}
+function getPendingNotification() {
+  const pendingPath = join2(CLAWNET_DIR, ".claude", "pending-evolutions.json");
+  if (!existsSync2(pendingPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync2(pendingPath, "utf-8"));
+    const pending = Array.isArray(raw?.pending) ? raw.pending : [];
+    if (pending.length === 0) return null;
+    const lines = pending.map(
+      (p) => `- [${p.signal ?? "?"}] ${p.skillName ?? "?"}: ${p.problem ?? ""} (confidence: ${p.confidence ?? "?"})`
+    );
+    const text = `\u6709 ${pending.length} \u6761 Skill \u8FDB\u5316\u63D0\u6848\u5F85\u5BA1\u6838\uFF1A
+${lines.join("\n")}
+\u4F7F\u7528 skill_pending_list \u67E5\u770B\u8BE6\u60C5\uFF0Cskill_pending_approve / skill_pending_reject \u5904\u7406\u3002`;
+    return { count: pending.length, text };
+  } catch (err) {
+    log2.debug({ err }, "failed to read pending-evolutions.json");
+    return null;
+  }
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return { name: "", description: "" };
+  const yaml = match[1];
+  const nameMatch = yaml.match(/^name:\s*(.+)$/m);
+  const descMatch = yaml.match(/^description:\s*(.+)$/m);
+  const strip = (s) => s.trim().replace(/^["']|["']$/g, "");
+  return {
+    name: strip(nameMatch?.[1] ?? ""),
+    description: strip(descMatch?.[1] ?? "")
+  };
+}
+function ensureMcpConfig() {
+  if (existsSync2(MCP_CONFIG_PATH)) {
+    log2.debug("mcp.json already exists, skipping");
+    return;
+  }
+  let mcpServerPath;
+  try {
+    const req = createRequire(import.meta.url);
+    const mcpPkgDir = dirname(req.resolve("@mclawnet/mcp-server/package.json"));
+    mcpServerPath = join2(mcpPkgDir, "dist", "server.js");
+  } catch {
+    log2.warn("could not resolve @mclawnet/mcp-server package path, skipping mcp.json generation");
+    return;
+  }
+  const config = {
+    mcpServers: {
+      "clawnet-mcp": {
+        command: "node",
+        args: [mcpServerPath]
+      }
+    }
+  };
+  try {
+    mkdirSync(CLAWNET_DIR, { recursive: true });
+    writeFileSync(MCP_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+    log2.info({ path: MCP_CONFIG_PATH }, "generated default mcp.json");
+  } catch (err) {
+    log2.warn({ err }, "failed to generate mcp.json");
+  }
+}
+
+// src/session-manager.ts
+var log3 = createLogger3({ module: "agent/session-manager" });
 var DEFAULT_MAX_PROCESSES = 10;
 var MAX_PROCESSES = Number(process.env.CLAWNET_MAX_PROCESSES) || DEFAULT_MAX_PROCESSES;
 var SessionManager = class {
@@ -821,10 +1120,26 @@ var SessionManager = class {
         options.systemPrompt = options.systemPrompt ? `${memorySection}${roleHint}
 
 ${options.systemPrompt}` : `${memorySection}${roleHint}`;
-        log2.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory prompt + roleId hint injected");
+        log3.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory prompt + roleId hint injected");
       } catch (err) {
-        log2.warn({ err, roleId: options.roleId }, "failed to build memory section, proceeding without");
+        log3.warn({ err, roleId: options.roleId }, "failed to build memory section, proceeding without");
+      }
+    }
+    try {
+      const notice = getPendingNotification();
+      if (notice) {
+        const noticeBlock = `
+
+[Skill \u8FDB\u5316\u63D0\u6848]
+${notice.text}`;
+        options.systemPrompt = options.systemPrompt ? `${options.systemPrompt}${noticeBlock}` : noticeBlock.trimStart();
+        log3.debug(
+          { sessionId: options.sessionId, pending: notice.count },
+          "pending skill evolution notice injected"
+        );
       }
+    } catch (err) {
+      log3.debug({ err }, "failed to inject pending notification");
     }
     try {
       const process2 = await this.adapter.spawn(options);
@@ -850,7 +1165,7 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
       if (this.onSessionStarted) {
         this.adapter.onSessionStarted?.(process2, (info) => {
           if (this.aborting.has(options.sessionId)) {
-            log2.debug(
+            log3.debug(
               { sessionId: options.sessionId },
               "suppressing late session_started \u2014 session is aborting"
             );
@@ -866,7 +1181,7 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
         if (this.sessions.get(options.sessionId) === process2) {
           this.sessions.delete(options.sessionId);
           this.conversationBuffer.delete(options.sessionId);
-          log2.warn({ sessionId: options.sessionId, exitCode: code }, "backend process exited unexpectedly, evicted from session map");
+          log3.warn({ sessionId: options.sessionId, exitCode: code }, "backend process exited unexpectedly, evicted from session map");
           this.onSessionError(options.sessionId, `backend process exited (code=${code ?? "null"})`);
         }
       });
@@ -883,6 +1198,10 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
       this.onSessionError(sessionId, `No active session: ${sessionId}`);
       return;
     }
+    log3.debug(
+      { sessionId, ...previewFields2(input) },
+      "sendInput \u2192 backend stdin"
+    );
     this.adapter.send(process2, input);
   }
   async abortSession(sessionId) {
@@ -950,138 +1269,6 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
 // src/start.ts
 import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
 
-// src/skill-loader.ts
-import { existsSync as existsSync2, mkdirSync, copyFileSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join2, dirname } from "path";
-import { homedir as homedir2 } from "os";
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-import { createLogger as createLogger3 } from "@mclawnet/logger";
-var log3 = createLogger3({ module: "agent/skill-loader" });
-var CLAWNET_DIR = join2(homedir2(), ".clawnet");
-var SKILLS_DIR = join2(CLAWNET_DIR, ".claude", "skills");
-var MCP_CONFIG_PATH = join2(CLAWNET_DIR, "mcp.json");
-async function initSkills() {
-  ensureSkillsDir();
-  copyBuiltinSkills();
-  ensureMcpConfig();
-  scanSkills();
-}
-function ensureSkillsDir() {
-  if (!existsSync2(SKILLS_DIR)) {
-    mkdirSync(SKILLS_DIR, { recursive: true });
-    log3.info({ dir: SKILLS_DIR }, "created skills directory");
-  }
-}
-function copyBuiltinSkills() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const srcDir = join2(dirname(thisFile), "..", "skills");
-  if (!existsSync2(srcDir)) {
-    log3.debug({ srcDir }, "no built-in skills directory found, skipping");
-    return;
-  }
-  let entries;
-  try {
-    entries = readdirSync2(srcDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    log3.warn({ srcDir }, "failed to read built-in skills directory");
-    return;
-  }
-  for (const skillName of entries) {
-    const srcSkillMd = join2(srcDir, skillName, "SKILL.md");
-    const destDir = join2(SKILLS_DIR, skillName);
-    const destSkillMd = join2(destDir, "SKILL.md");
-    if (!existsSync2(srcSkillMd)) continue;
-    if (existsSync2(destSkillMd)) {
-      log3.debug({ skill: skillName }, "skill already exists, skipping");
-      continue;
-    }
-    try {
-      mkdirSync(destDir, { recursive: true });
-      copyFileSync(srcSkillMd, destSkillMd);
-      log3.info({ skill: skillName }, "copied built-in skill");
-    } catch (err) {
-      log3.warn({ skill: skillName, err }, "failed to copy built-in skill");
-    }
-  }
-}
-var cachedSkills = [];
-function scanSkills() {
-  if (!existsSync2(SKILLS_DIR)) return [];
-  let dirs;
-  try {
-    dirs = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    log3.warn("failed to read skills directory for scanning");
-    return [];
-  }
-  const skills = [];
-  for (const dirName of dirs) {
-    const skillMd = join2(SKILLS_DIR, dirName, "SKILL.md");
-    if (!existsSync2(skillMd)) continue;
-    try {
-      const content = readFileSync2(skillMd, "utf-8");
-      const parsed = parseFrontmatter(content);
-      if (parsed.name) {
-        skills.push({
-          name: parsed.name,
-          description: parsed.description || dirName
-        });
-      }
-    } catch (err) {
-      log3.debug({ skill: dirName, err }, "failed to parse SKILL.md frontmatter");
-    }
-  }
-  cachedSkills = skills;
-  log3.info({ count: skills.length }, "scanned skills");
-  return skills;
-}
-function getSkillList() {
-  return cachedSkills;
-}
-function parseFrontmatter(content) {
-  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
-  if (!match) return { name: "", description: "" };
-  const yaml = match[1];
-  const nameMatch = yaml.match(/^name:\s*(.+)$/m);
-  const descMatch = yaml.match(/^description:\s*(.+)$/m);
-  const strip = (s) => s.trim().replace(/^["']|["']$/g, "");
-  return {
-    name: strip(nameMatch?.[1] ?? ""),
-    description: strip(descMatch?.[1] ?? "")
-  };
-}
-function ensureMcpConfig() {
-  if (existsSync2(MCP_CONFIG_PATH)) {
-    log3.debug("mcp.json already exists, skipping");
-    return;
-  }
-  let mcpServerPath;
-  try {
-    const req = createRequire(import.meta.url);
-    const memoryPkgDir = dirname(req.resolve("@mclawnet/memory/package.json"));
-    mcpServerPath = join2(memoryPkgDir, "dist", "mcp", "server.js");
-  } catch {
-    log3.warn("could not resolve @mclawnet/memory package path, skipping mcp.json generation");
-    return;
-  }
-  const config = {
-    mcpServers: {
-      "clawnet-memory": {
-        command: "node",
-        args: [mcpServerPath]
-      }
-    }
-  };
-  try {
-    mkdirSync(CLAWNET_DIR, { recursive: true });
-    writeFileSync(MCP_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
-    log3.info({ path: MCP_CONFIG_PATH }, "generated default mcp.json");
-  } catch (err) {
-    log3.warn({ err }, "failed to generate mcp.json");
-  }
-}
-
 // src/brain-bridge.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "fs";
 import { join as join3 } from "path";
@@ -1465,6 +1652,19 @@ var FsBridge = class {
 
 // src/start.ts
 import { createLogger as createLogger6 } from "@mclawnet/logger";
+import {
+  initDatabase,
+  MemoryStore,
+  EmbeddingService,
+  createEmbeddingProviders,
+  distillConversation
+} from "@mclawnet/memory";
+import {
+  SkillStore,
+  EvolutionPipeline,
+  AccumulationScanner,
+  triggerFromAccumulation
+} from "@mclawnet/skill-manager";
 var log6 = createLogger6({ module: "agent" });
 async function startAgent(options) {
   const config = loadConfig(options.config);
@@ -1496,6 +1696,58 @@ async function startAgent(options) {
     }
   });
   let swarmCoordinator;
+  const clawnetDir = process.env.CLAWNET_DIR ?? join4(homedir3(), ".clawnet");
+  const dbPath = process.env.CLAWNET_MEMORY_DB ?? join4(clawnetDir, "memory.db");
+  let memoryStore = null;
+  let embeddingService = null;
+  let evolutionPipeline = null;
+  let skillStore = null;
+  let memoryDb = null;
+  try {
+    memoryDb = initDatabase(dbPath);
+    memoryStore = new MemoryStore(memoryDb);
+    embeddingService = new EmbeddingService(memoryDb, createEmbeddingProviders());
+    skillStore = new SkillStore(clawnetDir);
+    evolutionPipeline = new EvolutionPipeline(clawnetDir);
+  } catch (err) {
+    log6.warn({ err }, "failed to init memory/skill infra; distillation disabled");
+  }
+  const onBeforeClose = async (sessionId, messages) => {
+    if (messages.length === 0) return;
+    if (!memoryStore || !embeddingService) return;
+    try {
+      await distillConversation(
+        messages,
+        "role-__assistant__",
+        memoryStore,
+        embeddingService
+      );
+    } catch (err) {
+      log6.warn({ err, sessionId }, "distillation failed (non-fatal)");
+    }
+    try {
+      if (!skillStore || !evolutionPipeline) return;
+      const skills = skillStore.scan();
+      if (skills.length === 0) return;
+      const recent = memoryStore.getMemoriesByRole("role-__assistant__", "working");
+      const refs = recent.map((m) => ({
+        id: m.id,
+        type: m.type,
+        content: m.content,
+        domain: m.domain
+      }));
+      const scanner = new AccumulationScanner();
+      const signals = scanner.scan(
+        refs,
+        skills.map((s) => s.name)
+      );
+      if (signals.length > 0) {
+        await triggerFromAccumulation(signals, evolutionPipeline);
+      }
+    } catch (err) {
+      log6.warn({ err, sessionId }, "accumulation scan failed (non-fatal)");
+    }
+  };
   const sessionManager = new SessionManager({
     adapter: options.adapter,
     onOutput: (sessionId, data) => {
@@ -1530,7 +1782,8 @@ async function startAgent(options) {
         sessionId,
         error
       });
-    }
+    },
+    onBeforeClose
   });
   swarmCoordinator = new SwarmCoordinator(sessionManager, hub);
   hub.setSessionManager(sessionManager);
@@ -1541,6 +1794,13 @@ async function startAgent(options) {
     log6.info("shutting down");
     await sessionManager.closeAll();
     hub.destroy();
+    if (memoryDb) {
+      try {
+        memoryDb.close();
+      } catch (err) {
+        log6.warn({ err }, "failed to close memory db");
+      }
+    }
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
@@ -1556,4 +1816,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-HQMVKDYY.js.map
+//# sourceMappingURL=chunk-MSDIRBXF.js.map