@mclawnet/agent 0.6.10 → 0.6.12

package/dist/{chunk-AZDR76NN.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";
@@ -169,12 +173,12 @@ async function handleListHistorySessions(workDir) {
   sessions.sort((a, b) => (b.lastModified ?? 0) - (a.lastModified ?? 0));
   return { workDir, sessions };
 }
-async function handleLoadSessionHistory(workDir, claudeSessionId) {
+async function handleLoadSessionHistory(workDir, claudeSessionId, opts) {
   const projectsDir = getClaudeProjectsDir();
   const projectFolder = pathToProjectFolder(workDir);
   const filePath = join(projectsDir, projectFolder, `${claudeSessionId}.jsonl`);
   if (!existsSync(filePath)) {
-    return { messages: [] };
+    return { messages: [], oldestSeq: 0, hasMore: false };
   }
   const messages = [];
   try {
@@ -236,11 +240,19 @@ async function handleLoadSessionHistory(workDir, claudeSessionId) {
     }
   } catch {
   }
-  return { messages: messages.slice(-50) };
+  const limit = Math.max(1, Math.min(opts?.limit ?? 50, 200));
+  const upper = opts?.before === void 0 || opts.before <= 0 || opts.before > messages.length ? messages.length : opts.before;
+  const lower = Math.max(0, upper - limit);
+  const slice = messages.slice(lower, upper);
+  return {
+    messages: slice,
+    oldestSeq: lower,
+    hasMore: lower > 0
+  };
 }
 
 // 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;
@@ -425,12 +437,15 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "load_session_history") {
-      log.info({ workDir: msg.workDir, claudeSessionId: msg.claudeSessionId }, "load_session_history");
-      handleLoadSessionHistory(msg.workDir, msg.claudeSessionId).then((result) => {
+      log.info(
+        { workDir: msg.workDir, claudeSessionId: msg.claudeSessionId, before: msg.before, limit: msg.limit },
+        "load_session_history"
+      );
+      handleLoadSessionHistory(msg.workDir, msg.claudeSessionId, { before: msg.before, limit: msg.limit }).then((result) => {
         this.send({ type: "session_history_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
         log.error({ err, workDir: msg.workDir }, "load_session_history failed");
-        this.send({ type: "session_history_result", requestId: msg.requestId, messages: [] });
+        this.send({ type: "session_history_result", requestId: msg.requestId, messages: [], oldestSeq: 0, hasMore: false });
       });
       return true;
     }
@@ -596,13 +611,12 @@ var HubConnection = class {
     }
     if (msg.type === "claude.execute") {
       const { sessionId, content, workDir, claudeSessionId, useBrainCore } = msg;
-      if (this.sessionManager.hasSession(sessionId)) {
-        log.info({ sessionId }, "claude.execute: reusing existing session");
-        this.sessionManager.sendInput(sessionId, content);
-      } else {
-        log.info({ sessionId, workDir, roleId: "role-__assistant__" }, "claude.execute: creating new session with memory injection");
-        this.sessionManager.createSession({ sessionId, workDir, resumeId: claudeSessionId, useBrainCore, roleId: "role-__assistant__" }).then(() => {
-          this.sessionManager.sendInput(sessionId, content);
+      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) => {
           this.send({
             type: "session.error",
@@ -610,6 +624,45 @@ var HubConnection = class {
             error: err instanceof Error ? err.message : String(err)
           });
         });
+      };
+      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");
+        this.send({
+          type: "session.died",
+          sessionId,
+          reason: "unhealthy_before_input"
+        });
+        sm.abortSession(sessionId).catch((err) => {
+          log.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during unhealthy fallback, proceeding to respawn");
+        }).then(() => spawnAndSend(claudeSessionId, "unhealthy_fallback_resume"));
+      } else if (claudeSessionId) {
+        spawnAndSend(claudeSessionId, "fresh_resume");
+      } else {
+        spawnAndSend(void 0, "brand_new");
+      }
+      return true;
+    }
+    if (msg.type === "session.force_restart") {
+      const { sessionId, reason } = msg;
+      log.warn({ sessionId, reason }, "session.force_restart received");
+      const sm = this.sessionManager;
+      const reply = {
+        type: "session.died",
+        sessionId,
+        reason: reason ?? "force_restart"
+      };
+      if (sm.hasSession(sessionId)) {
+        sm.abortSession(sessionId).catch((err) => {
+          log.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during force_restart");
+        }).finally(() => {
+          this.send(reply);
+        });
+      } else {
+        this.send(reply);
       }
       return true;
     }
@@ -642,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;
     }
@@ -731,24 +787,321 @@ 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 {
   sessions = /* @__PURE__ */ new Map();
   conversationBuffer = /* @__PURE__ */ new Map();
+  // Sessions whose abort is in flight. Treated as not-present by hasSession /
+  // isHealthy so a racing claude.execute (e.g., right after force_restart) is
+  // correctly routed to the "spawn new + --resume" branch instead of trying
+  // to write to a process we are about to kill.
+  aborting = /* @__PURE__ */ new Set();
   adapter;
   onOutput;
   onTurnComplete;
   onSessionError;
+  onSessionStarted;
   onBeforeClose;
   constructor(options) {
     this.adapter = options.adapter;
     this.onOutput = options.onOutput;
     this.onTurnComplete = options.onTurnComplete;
     this.onSessionError = options.onSessionError;
+    this.onSessionStarted = options.onSessionStarted;
     this.onBeforeClose = options.onBeforeClose;
   }
   async createSession(options) {
@@ -767,11 +1120,27 @@ 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);
       this.sessions.set(options.sessionId, process2);
@@ -793,6 +1162,29 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
       this.adapter.onError?.(process2, (error) => {
         this.onSessionError(options.sessionId, error.message);
       });
+      if (this.onSessionStarted) {
+        this.adapter.onSessionStarted?.(process2, (info) => {
+          if (this.aborting.has(options.sessionId)) {
+            log3.debug(
+              { sessionId: options.sessionId },
+              "suppressing late session_started \u2014 session is aborting"
+            );
+            return;
+          }
+          if (this.sessions.get(options.sessionId) !== process2) {
+            return;
+          }
+          this.onSessionStarted(options.sessionId, info);
+        });
+      }
+      this.adapter.onExit?.(process2, (code) => {
+        if (this.sessions.get(options.sessionId) === process2) {
+          this.sessions.delete(options.sessionId);
+          this.conversationBuffer.delete(options.sessionId);
+          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"})`);
+        }
+      });
       return process2.id;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -806,14 +1198,23 @@ ${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) {
     const process2 = this.sessions.get(sessionId);
     if (!process2) return;
+    this.aborting.add(sessionId);
     this.conversationBuffer.delete(sessionId);
     this.sessions.delete(sessionId);
-    await this.adapter.stop(process2);
+    try {
+      await this.adapter.stop(process2);
+    } finally {
+      this.aborting.delete(sessionId);
+    }
   }
   async closeSession(sessionId) {
     const process2 = this.sessions.get(sessionId);
@@ -844,7 +1245,18 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
     await Promise.all(promises);
   }
   hasSession(sessionId) {
-    return this.sessions.has(sessionId);
+    return this.sessions.has(sessionId) && !this.aborting.has(sessionId);
+  }
+  /**
+   * Stricter than hasSession(): also requires the underlying process to still
+   * be alive (not exited, stdin still writable). Callers in the reuse path
+   * must use this to avoid sending input into a dead pipe — if it returns
+   * false they should fall back to `--resume` against db's claudeSessionId.
+   */
+  isHealthy(sessionId) {
+    if (this.aborting.has(sessionId)) return false;
+    const process2 = this.sessions.get(sessionId);
+    return !!process2 && process2.isAlive();
   }
   get activeSessionCount() {
     return this.sessions.size;
@@ -857,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";
@@ -1372,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);
@@ -1403,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) => {
@@ -1424,13 +1769,21 @@ async function startAgent(options) {
         contextUsage: info.contextUsage
       });
     },
+    onSessionStarted: (sessionId, info) => {
+      hub.send({
+        type: "claude.session_started",
+        sessionId,
+        claudeSessionId: info.claudeSessionId
+      });
+    },
     onSessionError: (sessionId, error) => {
       hub.send({
         type: "session.error",
         sessionId,
         error
       });
-    }
+    },
+    onBeforeClose
   });
   swarmCoordinator = new SwarmCoordinator(sessionManager, hub);
   hub.setSessionManager(sessionManager);
@@ -1441,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);
@@ -1456,4 +1816,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-AZDR76NN.js.map
+//# sourceMappingURL=chunk-MSDIRBXF.js.map