@mclawnet/agent 0.5.9 → 0.6.2

package/dist/{chunk-KHPEQTWF.js → chunk-GLO5OZAY.js}

@@ -1,90 +1,6 @@
-// src/config.ts
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir, hostname } from "os";
-import { createLogger } from "@mclawnet/logger";
-var log = createLogger({ module: "config" });
-var CONFIG_DIR = join(homedir(), ".clawnet");
-var SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
-var DEFAULT_HUB_URL = process.env.CLAWNET_DEFAULT_HUB_URL || "ws://localhost:3000/ws/agent";
-var DEFAULTS = {
-  hubUrl: DEFAULT_HUB_URL,
-  token: "",
-  name: hostname(),
-  backendType: "claude-code"
-};
-function normalizeHubUrl(url) {
-  url = url.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
-  if (!/^wss?:\/\//.test(url)) url = "wss://" + url;
-  if (url.endsWith("/ws/agent")) return url;
-  return url.replace(/\/+$/, "") + "/ws/agent";
-}
-function applyEmbeddingConfig(embedding) {
-  const mapping = [
-    ["provider", "CLAWNET_EMBEDDING_PROVIDER"],
-    ["openaiBaseUrl", "CLAWNET_OPENAI_BASE_URL"],
-    ["openaiApiKey", "CLAWNET_OPENAI_API_KEY"],
-    ["openaiModel", "CLAWNET_OPENAI_EMBEDDING_MODEL"],
-    ["ollamaUrl", "CLAWNET_OLLAMA_URL"],
-    ["ollamaModel", "CLAWNET_OLLAMA_MODEL"]
-  ];
-  for (const [configKey, envKey] of mapping) {
-    const value = embedding[configKey];
-    if (value !== void 0 && process.env[envKey] === void 0) {
-      process.env[envKey] = value;
-    }
-  }
-}
-function loadConfig(cliOpts = {}) {
-  let fileConfig = {};
-  log.info({ path: SETTINGS_FILE }, "loading config");
-  if (existsSync(SETTINGS_FILE)) {
-    try {
-      fileConfig = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
-      log.info(
-        { hubUrl: fileConfig.hubUrl, hasToken: !!fileConfig.token, name: fileConfig.name },
-        "settings.json loaded"
-      );
-    } catch (e) {
-      log.warn({ err: e }, "failed to parse settings.json");
-    }
-  } else {
-    log.warn("settings.json not found");
-  }
-  if (fileConfig.embedding) {
-    applyEmbeddingConfig(fileConfig.embedding);
-  }
-  const hubUrl = cliOpts.hubUrl ?? process.env.CLAWNET_HUB_URL ?? fileConfig.hubUrl ?? DEFAULTS.hubUrl;
-  const resolved = {
-    hubUrl: normalizeHubUrl(hubUrl),
-    token: cliOpts.token ?? process.env.CLAWNET_TOKEN ?? fileConfig.token ?? DEFAULTS.token,
-    name: cliOpts.name ?? process.env.CLAWNET_NAME ?? fileConfig.name ?? DEFAULTS.name,
-    backendType: cliOpts.backendType ?? process.env.CLAWNET_BACKEND_TYPE ?? fileConfig.backendType ?? DEFAULTS.backendType,
-    embedding: fileConfig.embedding
-  };
-  log.info(
-    {
-      hubUrl: resolved.hubUrl,
-      hubUrlSource: cliOpts.hubUrl ? "cli" : process.env.CLAWNET_HUB_URL ? "env" : fileConfig.hubUrl ? "file" : "default",
-      tokenSource: cliOpts.token ? "cli" : process.env.CLAWNET_TOKEN ? "env" : fileConfig.token ? "file" : "default",
-      hasToken: !!resolved.token
-    },
-    "config resolved"
-  );
-  return resolved;
-}
-function saveConfig(config) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  let existing = {};
-  if (existsSync(SETTINGS_FILE)) {
-    try {
-      existing = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
-    } catch {
-    }
-  }
-  const merged = { ...existing, ...config };
-  writeFileSync(SETTINGS_FILE, JSON.stringify(merged, null, 2) + "\n");
-}
+import {
+  loadConfig
+} from "./chunk-CBZIH6FY.js";
 
 // src/hub-connection.ts
 import { hostname as osHostname } from "os";
@@ -95,16 +11,16 @@ import {
   MAX_RECONNECT_MS,
   WS_CLOSE_INVALID_TOKEN
 } from "@mclawnet/shared";
-import { listRecoverableSwarms, recoverSwarm, listRoles, loadRole, listRecoverableSwarmIds, deleteSwarmSnapshot } from "@mclawnet/swarm";
+import { listRecoverableSwarms, recoverSwarm, listRoles, loadRole, listRecoverableSwarmIds, deleteSwarmSnapshot, listTemplates, loadTemplate } from "@mclawnet/swarm";
 
 // src/fs-handler.ts
 import { readdir } from "fs/promises";
-import { existsSync as existsSync2, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { existsSync, readdirSync, statSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "__pycache__", ".next", ".nuxt", ".cache"]);
 async function handleListDir(path) {
-  const target = path || homedir2();
+  const target = path || homedir();
   const dirents = await readdir(target, { withFileTypes: true });
   const entries = dirents.filter((d) => !(d.isDirectory() && SKIP_DIRS.has(d.name))).map((d) => ({
     name: d.name,
@@ -116,14 +32,14 @@ async function handleListDir(path) {
   return { path: target, entries };
 }
 function getClaudeProjectsDir() {
-  return join2(homedir2(), ".claude", "projects");
+  return join(homedir(), ".claude", "projects");
 }
 function pathToProjectFolder(workDir) {
   return workDir.replace(/:/g, "-").replace(/[/\\]/g, "-");
 }
 function extractWorkDirFromSessionFile(filePath) {
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (const line of lines.slice(0, 5)) {
       try {
@@ -141,7 +57,7 @@ function getWorkDirFromProjectFolder(folderPath, folderName) {
     const files = readdirSync(folderPath);
     for (const file of files) {
       if (file.endsWith(".jsonl")) {
-        const workDir = extractWorkDirFromSessionFile(join2(folderPath, file));
+        const workDir = extractWorkDirFromSessionFile(join(folderPath, file));
         if (workDir) return workDir;
       }
     }
@@ -158,10 +74,10 @@ function getWorkDirFromProjectFolder(folderPath, folderName) {
 async function handleListFolders() {
   const projectsDir = getClaudeProjectsDir();
   const folders = [];
-  if (!existsSync2(projectsDir)) return { folders };
+  if (!existsSync(projectsDir)) return { folders };
   const entries = readdirSync(projectsDir);
   for (const entry of entries) {
-    const entryPath = join2(projectsDir, entry);
+    const entryPath = join(projectsDir, entry);
     let entryStat;
     try {
       entryStat = statSync(entryPath);
@@ -179,7 +95,7 @@ async function handleListFolders() {
         if (file.endsWith(".jsonl")) {
           sessionCount++;
           try {
-            const fileStats = statSync(join2(entryPath, file));
+            const fileStats = statSync(join(entryPath, file));
             if (fileStats.mtime.getTime() > lastModified) {
               lastModified = fileStats.mtime.getTime();
             }
@@ -197,8 +113,8 @@ async function handleListFolders() {
 async function handleListHistorySessions(workDir) {
   const projectsDir = getClaudeProjectsDir();
   const projectFolder = pathToProjectFolder(workDir);
-  const projectPath = join2(projectsDir, projectFolder);
-  if (!existsSync2(projectPath)) {
+  const projectPath = join(projectsDir, projectFolder);
+  if (!existsSync(projectPath)) {
     return { workDir, sessions: [] };
   }
   const sessions = [];
@@ -206,7 +122,7 @@ async function handleListHistorySessions(workDir) {
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
     const sessionId = file.replace(".jsonl", "");
-    const filePath = join2(projectPath, file);
+    const filePath = join(projectPath, file);
     let fileStats;
     try {
       fileStats = statSync(filePath);
@@ -218,7 +134,7 @@ async function handleListHistorySessions(workDir) {
     let customTitle = "";
     let jsonlSummary = "";
     try {
-      const content = readFileSync2(filePath, "utf-8");
+      const content = readFileSync(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim());
       for (const line of lines) {
         try {
@@ -256,13 +172,13 @@ async function handleListHistorySessions(workDir) {
 async function handleLoadSessionHistory(workDir, claudeSessionId) {
   const projectsDir = getClaudeProjectsDir();
   const projectFolder = pathToProjectFolder(workDir);
-  const filePath = join2(projectsDir, projectFolder, `${claudeSessionId}.jsonl`);
-  if (!existsSync2(filePath)) {
+  const filePath = join(projectsDir, projectFolder, `${claudeSessionId}.jsonl`);
+  if (!existsSync(filePath)) {
     return { messages: [] };
   }
   const messages = [];
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (const line of lines) {
       try {
@@ -324,8 +240,8 @@ async function handleLoadSessionHistory(workDir, claudeSessionId) {
 }
 
 // src/hub-connection.ts
-import { createLogger as createLogger2 } from "@mclawnet/logger";
-var log2 = createLogger2({ module: "agent" });
+import { createLogger } from "@mclawnet/logger";
+var log = createLogger({ module: "agent" });
 var HubConnection = class {
   ws = null;
   heartbeatTimer = null;
@@ -407,7 +323,7 @@ var HubConnection = class {
         return;
       }
       if (this.authState === "pending" && data.type === "auth_required") {
-        log2.info("hub requires auth, sending credentials");
+        log.info("hub requires auth, sending credentials");
         this.authState = "authenticating";
         this.sendRaw({
           type: "auth",
@@ -419,7 +335,7 @@ var HubConnection = class {
         return;
       }
       if (this.authState === "authenticating" && data.type === "registered") {
-        log2.info({ agentId: data.agentId }, "registered with hub");
+        log.info({ agentId: data.agentId }, "registered with hub");
         this.authState = "authenticated";
         this.agentId = data.agentId ?? null;
         this.startHeartbeat();
@@ -433,18 +349,18 @@ var HubConnection = class {
       }
     });
     this.ws.on("close", (code, reason) => {
-      log2.warn({ code, reason: reason.toString() }, "disconnected from hub");
+      log.warn({ code, reason: reason.toString() }, "disconnected from hub");
       this.stopHeartbeat();
       this.authState = "pending";
       this.onDisconnect?.(code, reason.toString());
       if (code === WS_CLOSE_INVALID_TOKEN) {
-        log2.error("auth failed \u2014 not reconnecting, check your token");
+        log.error("auth failed \u2014 not reconnecting, check your token");
         return;
       }
       this.scheduleReconnect();
     });
     this.ws.on("error", (err) => {
-      log2.error({ err }, "ws connection error");
+      log.error({ err }, "ws connection error");
       this.onError?.(err);
     });
   }
@@ -462,11 +378,11 @@ var HubConnection = class {
   // ── Session message handling ─────────────────────────────────────
   handleSessionMessage(msg) {
     if (msg.type === "fs.list_dir") {
-      log2.info({ path: msg.path }, "fs.list_dir");
+      log.info({ path: msg.path }, "fs.list_dir");
       handleListDir(msg.path).then((result) => {
         this.send({ type: "fs.list_dir_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err, path: msg.path }, "fs.list_dir failed");
+        log.error({ err, path: msg.path }, "fs.list_dir failed");
         this.send({
           type: "fs.list_dir_result",
           requestId: msg.requestId,
@@ -477,21 +393,21 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "list_folders") {
-      log2.info("list_folders");
+      log.info("list_folders");
       handleListFolders().then((result) => {
         this.send({ type: "folders_list_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err }, "list_folders failed");
+        log.error({ err }, "list_folders failed");
         this.send({ type: "folders_list_result", requestId: msg.requestId, folders: [] });
       });
       return true;
     }
     if (msg.type === "list_history_sessions") {
-      log2.info({ workDir: msg.workDir }, "list_history_sessions");
+      log.info({ workDir: msg.workDir }, "list_history_sessions");
       handleListHistorySessions(msg.workDir).then((result) => {
         this.send({ type: "history_sessions_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err, workDir: msg.workDir }, "list_history_sessions failed");
+        log.error({ err, workDir: msg.workDir }, "list_history_sessions failed");
         this.send({
           type: "history_sessions_result",
           requestId: msg.requestId,
@@ -502,26 +418,28 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "load_session_history") {
-      log2.info({ workDir: msg.workDir, claudeSessionId: msg.claudeSessionId }, "load_session_history");
+      log.info({ workDir: msg.workDir, claudeSessionId: msg.claudeSessionId }, "load_session_history");
       handleLoadSessionHistory(msg.workDir, msg.claudeSessionId).then((result) => {
         this.send({ type: "session_history_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err, workDir: msg.workDir }, "load_session_history failed");
+        log.error({ err, workDir: msg.workDir }, "load_session_history failed");
         this.send({ type: "session_history_result", requestId: msg.requestId, messages: [] });
       });
       return true;
     }
     if (msg.type === "list_roles") {
-      log2.info("list_roles");
+      log.info("list_roles");
       const roleNames = listRoles();
       const roles = roleNames.map((name) => {
         try {
           const def = loadRole(name);
           return {
             name: def.name,
-            displayName: def.shortName || def.name,
+            displayName: def.displayName || def.description || def.name,
             description: def.description || "",
             capabilities: def.capabilities || [],
+            type: def.type,
+            color: def.color,
             promptBody: def.promptBody || ""
           };
         } catch {
@@ -535,12 +453,41 @@ var HubConnection = class {
       });
       return true;
     }
+    if (msg.type === "list_templates") {
+      log.info("list_templates");
+      try {
+        const names = listTemplates();
+        const templates = names.map((name) => {
+          const tpl = loadTemplate(name);
+          return {
+            name: tpl.name,
+            displayName: tpl.displayName,
+            description: tpl.description,
+            icon: tpl.icon,
+            roles: tpl.roles
+          };
+        });
+        this.send({
+          type: "templates_list_result",
+          sessionId: msg.sessionId,
+          templates
+        });
+      } catch (err) {
+        log.error({ err }, "list_templates failed");
+        this.send({
+          type: "templates_list_result",
+          sessionId: msg.sessionId,
+          templates: []
+        });
+      }
+      return true;
+    }
     if (msg.type === "generic.request") {
       const handler = this.namespaceHandlers.get(msg.namespace);
       if (handler) {
-        log2.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request received");
+        log.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request received");
         handler(msg).then((result) => {
-          log2.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request handled OK");
+          log.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request handled OK");
           this.send({
             type: "generic.response",
             namespace: msg.namespace,
@@ -549,7 +496,7 @@ var HubConnection = class {
             requestId: msg.requestId
           });
         }).catch((err) => {
-          log2.error({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId, err }, "generic.request handler error");
+          log.error({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId, err }, "generic.request handler error");
           this.send({
             type: "generic.response",
             namespace: msg.namespace,
@@ -561,7 +508,7 @@ var HubConnection = class {
         });
         return true;
       }
-      log2.warn({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request unknown namespace");
+      log.warn({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request unknown namespace");
       this.send({
         type: "generic.response",
         namespace: msg.namespace,
@@ -575,7 +522,7 @@ var HubConnection = class {
     if (msg.type === "swarm.execute" && this.swarmCoordinator) {
       const { sessionId, content, workDir, targetInstance, crewConfig } = msg;
       if (this.swarmCoordinator.hasSwarm(sessionId)) {
-        log2.info({ sessionId, targetInstance }, "swarm.execute: forwarding to existing swarm");
+        log.info({ sessionId, targetInstance }, "swarm.execute: forwarding to existing swarm");
         this.swarmCoordinator.handleUserMessage(sessionId, content, targetInstance).catch((err) => {
           this.send({
             type: "session.error",
@@ -584,16 +531,17 @@ var HubConnection = class {
           });
         });
       } else if (this.finishedSwarms.has(sessionId)) {
-        log2.info({ sessionId }, "swarm.execute ignored: swarm already finished");
+        log.info({ sessionId }, "swarm.execute ignored: swarm already finished");
         this.send({
           type: "session.error",
           sessionId,
           error: "\u8702\u7FA4\u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u64CD\u4F5C\u3002\u8BF7\u521B\u5EFA\u65B0\u7684\u8702\u7FA4\u4EFB\u52A1\u3002"
         });
-      } else if (crewConfig?.roles) {
-        log2.info({ sessionId, rolesCount: crewConfig.roles.length }, "swarm.execute: creating new swarm");
+      } else if (crewConfig?.templateName || crewConfig?.roles) {
+        const templateName = crewConfig.templateName;
         const roles = crewConfig.roles;
-        this.swarmCoordinator.create(sessionId, { workDir, roles, task: content }).catch((err) => {
+        log.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: creating new swarm");
+        this.swarmCoordinator.create(sessionId, { workDir, templateName, roles, task: content }).catch((err) => {
           this.send({
             type: "session.error",
             sessionId,
@@ -601,7 +549,7 @@ var HubConnection = class {
           });
         });
       } else {
-        log2.info({ sessionId }, "swarm.execute ignored: swarm not found, no config");
+        log.info({ sessionId }, "swarm.execute ignored: swarm not found, no config");
         this.send({
           type: "session.error",
           sessionId,
@@ -613,7 +561,7 @@ var HubConnection = class {
     if (!this.sessionManager) return false;
     if (msg.type === "abort_execution") {
       const { sessionId } = msg;
-      log2.info({ sessionId }, "abort_execution");
+      log.info({ sessionId }, "abort_execution");
       if (this.sessionManager?.hasSession(sessionId)) {
         this.sessionManager.abortSession(sessionId).then(() => {
           this.send({ type: "execution_aborted", sessionId });
@@ -628,10 +576,10 @@ var HubConnection = class {
     if (msg.type === "claude.execute") {
       const { sessionId, content, workDir, claudeSessionId, useBrainCore } = msg;
       if (this.sessionManager.hasSession(sessionId)) {
-        log2.info({ sessionId }, "claude.execute: reusing existing session");
+        log.info({ sessionId }, "claude.execute: reusing existing session");
         this.sessionManager.sendInput(sessionId, content);
       } else {
-        log2.info({ sessionId, workDir, roleId: "role-__assistant__" }, "claude.execute: creating new session with memory injection");
+        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);
         }).catch((err) => {
@@ -645,7 +593,7 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "session.create") {
-      log2.info({ sessionId: msg.sessionId, roleId: "role-__assistant__" }, "session.create with memory injection");
+      log.info({ sessionId: msg.sessionId, roleId: "role-__assistant__" }, "session.create with memory injection");
       this.sessionManager.createSession({
         sessionId: msg.sessionId,
         workDir: msg.workDir,
@@ -667,13 +615,13 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "session.close") {
-      log2.info({ sessionId: msg.sessionId }, "session.close");
+      log.info({ sessionId: msg.sessionId }, "session.close");
       this.sessionManager.closeSession(msg.sessionId).catch(() => {
       });
       return true;
     }
     if (msg.type === "claude.input") {
-      log2.info({ sessionId: msg.sessionId }, "claude.input");
+      log.info({ sessionId: msg.sessionId }, "claude.input");
       this.sessionManager.sendInput(msg.sessionId, msg.content);
       return true;
     }
@@ -689,17 +637,17 @@ var HubConnection = class {
       for (const id of allIds) {
         if (!recoverableIds.has(id)) {
           deleteSwarmSnapshot(id);
-          log2.info({ swarmId: id }, "cleaned up non-recoverable swarm snapshot");
+          log.info({ swarmId: id }, "cleaned up non-recoverable swarm snapshot");
         }
       }
       for (const snap of snapshots) {
-        log2.info({ swarmId: snap.id }, "recovering swarm");
+        log.info({ swarmId: snap.id }, "recovering swarm");
         recoverSwarm(this.swarmCoordinator, snap).catch((err) => {
-          log2.error({ err, swarmId: snap.id }, "failed to recover swarm");
+          log.error({ err, swarmId: snap.id }, "failed to recover swarm");
         });
       }
     } catch (err) {
-      log2.error({ err }, "swarm recovery failed");
+      log.error({ err }, "swarm recovery failed");
     }
   }
   sendRaw(data) {
@@ -721,7 +669,7 @@ var HubConnection = class {
   }
   scheduleReconnect() {
     if (this.destroyed) return;
-    log2.warn({ delayMs: this.reconnectDelay }, "reconnecting to hub...");
+    log.warn({ delayMs: this.reconnectDelay }, "reconnecting to hub...");
     this.reconnectTimer = setTimeout(() => {
       this.connect();
     }, this.reconnectDelay);
@@ -746,17 +694,14 @@ var HubConnection = class {
 };
 
 // src/session-manager.ts
-import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
-import { tmpdir } from "os";
-import { join as join3, dirname } from "path";
-import { createRequire } from "module";
-import { createLogger as createLogger3 } from "@mclawnet/logger";
+import { createLogger as createLogger2 } from "@mclawnet/logger";
 import { buildMemorySection } from "@mclawnet/memory";
-var log3 = createLogger3({ module: "agent/session-manager" });
+var log2 = createLogger2({ 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();
-  mcpConfigPaths = /* @__PURE__ */ new Map();
   adapter;
   onOutput;
   onTurnComplete;
@@ -773,23 +718,21 @@ var SessionManager = class {
     if (this.sessions.has(options.sessionId)) {
       throw new Error(`Session ${options.sessionId} already exists`);
     }
+    if (this.sessions.size >= MAX_PROCESSES) {
+      throw new Error(`Process limit reached (${MAX_PROCESSES}). Cannot create new session.`);
+    }
     if (options.roleId) {
       try {
         const memorySection = buildMemorySection(options.roleId);
-        options.systemPrompt = options.systemPrompt ? `${memorySection}
+        const roleHint = `
 
-${options.systemPrompt}` : memorySection;
-        log3.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory prompt injected");
+[Memory Context] Your roleId is "${options.roleId}". Always use this roleId when calling memory_search, memory_store, memory_stats, or memory_reflect.`;
+        options.systemPrompt = options.systemPrompt ? `${memorySection}${roleHint}
+
+${options.systemPrompt}` : `${memorySection}${roleHint}`;
+        log2.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory prompt + roleId hint injected");
       } catch (err) {
-        log3.warn({ err, roleId: options.roleId }, "failed to build memory section, proceeding without");
-      }
-      if (!options.mcpConfigPath) {
-        try {
-          options.mcpConfigPath = this.createMemoryMcpConfig(options.sessionId, options.roleId);
-          log3.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory MCP config created");
-        } catch (err) {
-          log3.warn({ err, roleId: options.roleId }, "failed to create memory MCP config, proceeding without");
-        }
+        log2.warn({ err, roleId: options.roleId }, "failed to build memory section, proceeding without");
       }
     }
     try {
@@ -832,7 +775,6 @@ ${options.systemPrompt}` : memorySection;
     const process2 = this.sessions.get(sessionId);
     if (!process2) return;
     this.conversationBuffer.delete(sessionId);
-    this.cleanupMcpConfig(sessionId);
     this.sessions.delete(sessionId);
     await this.adapter.stop(process2);
   }
@@ -845,7 +787,6 @@ ${options.systemPrompt}` : memorySection;
       });
     }
     this.conversationBuffer.delete(sessionId);
-    this.cleanupMcpConfig(sessionId);
     this.sessions.delete(sessionId);
     await this.adapter.stop(process2);
   }
@@ -858,7 +799,6 @@ ${options.systemPrompt}` : memorySection;
           });
         }
         this.conversationBuffer.delete(sessionId);
-        this.cleanupMcpConfig(sessionId);
         this.sessions.delete(sessionId);
         await this.adapter.stop(process2).catch(() => {
         });
@@ -872,56 +812,107 @@ ${options.systemPrompt}` : memorySection;
   get activeSessionCount() {
     return this.sessions.size;
   }
-  // ── Private helpers ─────────────────────────────────────────────────
-  /** Generate a temporary MCP config file for the memory server. */
-  createMemoryMcpConfig(sessionId, roleId) {
+};
+
+// src/start.ts
+import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
+
+// src/skill-loader.ts
+import { existsSync as existsSync2, mkdirSync, copyFileSync, readdirSync as readdirSync2, 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();
+}
+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");
+    }
+  }
+}
+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"));
-    const mcpServerPath = join3(memoryPkgDir, "dist", "mcp", "server.js");
-    const configPath = join3(tmpdir(), `clawnet-mcp-${sessionId.replace(/::/g, "-")}.json`);
-    writeFileSync2(
-      configPath,
-      JSON.stringify({
-        mcpServers: {
-          "clawnet-memory": {
-            command: "node",
-            args: [mcpServerPath, "--role-id", roleId]
-          }
-        }
-      })
-    );
-    this.mcpConfigPaths.set(sessionId, configPath);
-    log3.debug({ sessionId, roleId, configPath, mcpServerPath }, "memory MCP config file written");
-    return configPath;
+    mcpServerPath = join2(memoryPkgDir, "dist", "mcp", "server.js");
+  } catch {
+    log3.warn("could not resolve @mclawnet/memory package path, skipping mcp.json generation");
+    return;
   }
-  /** Remove temporary MCP config file for a session. */
-  cleanupMcpConfig(sessionId) {
-    const configPath = this.mcpConfigPaths.get(sessionId);
-    if (configPath) {
-      try {
-        unlinkSync(configPath);
-      } catch {
+  const config = {
+    mcpServers: {
+      "clawnet-memory": {
+        command: "node",
+        args: [mcpServerPath]
       }
-      this.mcpConfigPaths.delete(sessionId);
-      log3.debug({ sessionId, configPath }, "memory MCP config file cleaned up");
     }
+  };
+  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/start.ts
-import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
+}
 
 // src/brain-bridge.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync3 } from "fs";
+import { join as join3 } from "path";
 import { createLogger as createLogger4 } from "@mclawnet/logger";
 var log4 = createLogger4({ module: "brain-bridge" });
 var BrainBridge = class {
   constructor(hub, options) {
     this.hub = hub;
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    this.brainHome = options?.brainHomePath || process.env.BRAIN_HOME || join4(home, "BrainData");
-    this.brainCorePath = options?.brainCorePath || join4(home, ".brain", "BrainCore");
+    this.brainHome = options?.brainHomePath || process.env.BRAIN_HOME || join3(home, "BrainData");
+    this.brainCorePath = options?.brainCorePath || join3(home, ".brain", "BrainCore");
     this.hub.registerNamespace("brain", (msg) => this.handleRequest(msg));
     log4.info(
       { brainHome: this.brainHome, brainCorePath: this.brainCorePath },
@@ -952,7 +943,7 @@ var BrainBridge = class {
       return "not_installed";
     }
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    const installJson = join4(home, ".brain", "install.json");
+    const installJson = join3(home, ".brain", "install.json");
     if (!existsSync3(installJson)) {
       return "needs_config";
     }
@@ -964,18 +955,18 @@ var BrainBridge = class {
   /** Read the most recent daily briefing report */
   async getBriefing(date) {
     const targetDate = date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const reportsDir = join4(this.brainHome, "reports", "daily");
+    const reportsDir = join3(this.brainHome, "reports", "daily");
     if (!existsSync3(reportsDir)) {
       log4.info({ reportsDir }, "get_briefing: reports dir not found");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
-    const files = readdirSync2(reportsDir).filter((f) => f.includes(targetDate) && f.endsWith(".md")).sort().reverse();
+    const files = readdirSync3(reportsDir).filter((f) => f.includes(targetDate) && f.endsWith(".md")).sort().reverse();
     if (files.length === 0) {
       log4.info({ targetDate }, "get_briefing: no report for date");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
     log4.info({ targetDate, file: files[0] }, "get_briefing: reading report");
-    const content = readFileSync3(join4(reportsDir, files[0]), "utf-8");
+    const content = readFileSync2(join3(reportsDir, files[0]), "utf-8");
     const tldrMatch = content.match(/## TL;DR\n([\s\S]*?)(?=\n---|\n## )/);
     const tldr = tldrMatch ? tldrMatch[1].trim() : content.slice(0, 200);
     const actions = this.parseActions(content);
@@ -1174,12 +1165,12 @@ var BrainBridge = class {
     if (!recapPath) {
       return { error: "No recap path provided" };
     }
-    const fullPath = join4(this.brainHome, recapPath);
+    const fullPath = join3(this.brainHome, recapPath);
     if (!existsSync3(fullPath)) {
       log4.warn({ fullPath }, "meeting recap file not found");
       return { error: "Recap file not found" };
     }
-    const content = readFileSync3(fullPath, "utf-8");
+    const content = readFileSync2(fullPath, "utf-8");
     return { recap: this.parseRecapMarkdown(content) };
   }
   /** Parse meeting recap markdown into structured sections */
@@ -1212,7 +1203,7 @@ var BrainBridge = class {
 };
 
 // src/fs-bridge.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { extname, isAbsolute } from "path";
 import { createLogger as createLogger5 } from "@mclawnet/logger";
 var log5 = createLogger5({ module: "fs-bridge" });
@@ -1280,12 +1271,12 @@ var FsBridge = class {
     const mimeType = getMimeType(filePath);
     const totalSize = stat2.size;
     if (isTextMime(mimeType)) {
-      const raw = readFileSync4(filePath, "utf-8");
+      const raw = readFileSync3(filePath, "utf-8");
       const truncated2 = raw.length > MAX_TEXT_SIZE;
       const content = truncated2 ? raw.slice(0, MAX_TEXT_SIZE) : raw;
       return { content, encoding: "utf-8", size: content.length, totalSize, mimeType, truncated: truncated2 };
     }
-    const buf = readFileSync4(filePath);
+    const buf = readFileSync3(filePath);
     const truncated = buf.length > MAX_TEXT_SIZE;
     const slice = truncated ? buf.subarray(0, MAX_TEXT_SIZE) : buf;
     return { content: slice.toString("base64"), encoding: "base64", size: slice.length, totalSize, mimeType, truncated };
@@ -1304,6 +1295,7 @@ async function startAgent(options) {
   log6.info({ backend: options.adapter.type }, "starting agent");
   log6.info({ hubUrl: config.hubUrl }, "connecting to hub");
   await initRoles();
+  await initSkills();
   const hub = new HubConnection({
     hubUrl: config.hubUrl,
     token: config.token,
@@ -1367,10 +1359,8 @@ async function startAgent(options) {
 export {
   HubConnection,
   SessionManager,
-  loadConfig,
-  saveConfig,
   BrainBridge,
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-KHPEQTWF.js.map
+//# sourceMappingURL=chunk-GLO5OZAY.js.map