@mclawnet/agent 0.6.1 → 0.6.2

package/dist/{chunk-KITKMSBE.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";
@@ -99,12 +15,12 @@ import { listRecoverableSwarms, recoverSwarm, listRoles, loadRole, listRecoverab
 
 // 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,17 +418,17 @@ 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 {
@@ -538,7 +454,7 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "list_templates") {
-      log2.info("list_templates");
+      log.info("list_templates");
       try {
         const names = listTemplates();
         const templates = names.map((name) => {
@@ -557,7 +473,7 @@ var HubConnection = class {
           templates
         });
       } catch (err) {
-        log2.error({ err }, "list_templates failed");
+        log.error({ err }, "list_templates failed");
         this.send({
           type: "templates_list_result",
           sessionId: msg.sessionId,
@@ -569,9 +485,9 @@ var HubConnection = class {
     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,
@@ -580,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,
@@ -592,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,
@@ -606,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",
@@ -615,7 +531,7 @@ 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,
@@ -624,7 +540,7 @@ var HubConnection = class {
       } else if (crewConfig?.templateName || crewConfig?.roles) {
         const templateName = crewConfig.templateName;
         const roles = crewConfig.roles;
-        log2.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: creating new swarm");
+        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",
@@ -633,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,
@@ -645,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 });
@@ -660,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) => {
@@ -677,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,
@@ -699,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;
     }
@@ -721,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) {
@@ -753,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);
@@ -778,9 +694,9 @@ var HubConnection = class {
 };
 
 // src/session-manager.ts
-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 {
@@ -814,9 +730,9 @@ var SessionManager = class {
         options.systemPrompt = options.systemPrompt ? `${memorySection}${roleHint}
 
 ${options.systemPrompt}` : `${memorySection}${roleHint}`;
-        log3.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory prompt + roleId hint injected");
+        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");
+        log2.warn({ err, roleId: options.roleId }, "failed to build memory section, proceeding without");
       }
     }
     try {
@@ -902,71 +818,71 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
 import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
 
 // src/skill-loader.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, copyFileSync, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3, dirname } from "path";
-import { homedir as homedir3 } from "os";
+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 createLogger4 } from "@mclawnet/logger";
-var log4 = createLogger4({ module: "agent/skill-loader" });
-var CLAWNET_DIR = join3(homedir3(), ".clawnet");
-var SKILLS_DIR = join3(CLAWNET_DIR, ".claude", "skills");
-var MCP_CONFIG_PATH = join3(CLAWNET_DIR, "mcp.json");
+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 (!existsSync3(SKILLS_DIR)) {
-    mkdirSync2(SKILLS_DIR, { recursive: true });
-    log4.info({ dir: SKILLS_DIR }, "created skills directory");
+  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 = join3(dirname(thisFile), "..", "skills");
-  if (!existsSync3(srcDir)) {
-    log4.debug({ srcDir }, "no built-in skills directory found, skipping");
+  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 {
-    log4.warn({ srcDir }, "failed to read built-in skills directory");
+    log3.warn({ srcDir }, "failed to read built-in skills directory");
     return;
   }
   for (const skillName of entries) {
-    const srcSkillMd = join3(srcDir, skillName, "SKILL.md");
-    const destDir = join3(SKILLS_DIR, skillName);
-    const destSkillMd = join3(destDir, "SKILL.md");
-    if (!existsSync3(srcSkillMd)) continue;
-    if (existsSync3(destSkillMd)) {
-      log4.debug({ skill: skillName }, "skill already exists, skipping");
+    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 {
-      mkdirSync2(destDir, { recursive: true });
+      mkdirSync(destDir, { recursive: true });
       copyFileSync(srcSkillMd, destSkillMd);
-      log4.info({ skill: skillName }, "copied built-in skill");
+      log3.info({ skill: skillName }, "copied built-in skill");
     } catch (err) {
-      log4.warn({ skill: skillName, err }, "failed to copy built-in skill");
+      log3.warn({ skill: skillName, err }, "failed to copy built-in skill");
     }
   }
 }
 function ensureMcpConfig() {
-  if (existsSync3(MCP_CONFIG_PATH)) {
-    log4.debug("mcp.json already exists, skipping");
+  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 = join3(memoryPkgDir, "dist", "mcp", "server.js");
+    mcpServerPath = join2(memoryPkgDir, "dist", "mcp", "server.js");
   } catch {
-    log4.warn("could not resolve @mclawnet/memory package path, skipping mcp.json generation");
+    log3.warn("could not resolve @mclawnet/memory package path, skipping mcp.json generation");
     return;
   }
   const config = {
@@ -978,27 +894,27 @@ function ensureMcpConfig() {
     }
   };
   try {
-    mkdirSync2(CLAWNET_DIR, { recursive: true });
-    writeFileSync2(MCP_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
-    log4.info({ path: MCP_CONFIG_PATH }, "generated default mcp.json");
+    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) {
-    log4.warn({ err }, "failed to generate mcp.json");
+    log3.warn({ err }, "failed to generate mcp.json");
   }
 }
 
 // src/brain-bridge.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join4 } from "path";
-import { createLogger as createLogger5 } from "@mclawnet/logger";
-var log5 = createLogger5({ module: "brain-bridge" });
+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));
-    log5.info(
+    log4.info(
       { brainHome: this.brainHome, brainCorePath: this.brainCorePath },
       "BrainBridge initialized"
     );
@@ -1006,11 +922,11 @@ var BrainBridge = class {
   brainHome;
   brainCorePath;
   async handleRequest(msg) {
-    log5.info({ action: msg.action, requestId: msg.requestId }, "brain request");
+    log4.info({ action: msg.action, requestId: msg.requestId }, "brain request");
     switch (msg.action) {
       case "setup_status": {
         const status = this.checkSetup();
-        log5.info({ status }, "setup_status result");
+        log4.info({ status }, "setup_status result");
         return { status };
       }
       case "get_briefing":
@@ -1018,20 +934,20 @@ var BrainBridge = class {
       case "get_meeting_recap":
         return await this.getMeetingRecap(msg.params.recapPath);
       default:
-        log5.warn({ action: msg.action }, "unknown brain action");
+        log4.warn({ action: msg.action }, "unknown brain action");
         throw new Error(`Unknown brain action: ${msg.action}`);
     }
   }
   checkSetup() {
-    if (!existsSync4(this.brainCorePath)) {
+    if (!existsSync3(this.brainCorePath)) {
       return "not_installed";
     }
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    const installJson = join4(home, ".brain", "install.json");
-    if (!existsSync4(installJson)) {
+    const installJson = join3(home, ".brain", "install.json");
+    if (!existsSync3(installJson)) {
       return "needs_config";
     }
-    if (!existsSync4(this.brainHome)) {
+    if (!existsSync3(this.brainHome)) {
       return "needs_config";
     }
     return "ready";
@@ -1039,25 +955,25 @@ 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");
-    if (!existsSync4(reportsDir)) {
-      log5.info({ reportsDir }, "get_briefing: reports dir not found");
+    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 = readdirSync3(reportsDir).filter((f) => f.includes(targetDate) && f.endsWith(".md")).sort().reverse();
     if (files.length === 0) {
-      log5.info({ targetDate }, "get_briefing: no report for date");
+      log4.info({ targetDate }, "get_briefing: no report for date");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
-    log5.info({ targetDate, file: files[0] }, "get_briefing: reading report");
-    const content = readFileSync3(join4(reportsDir, files[0]), "utf-8");
+    log4.info({ targetDate, file: files[0] }, "get_briefing: reading report");
+    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);
     const projects = this.parseProjects(content);
     const meetings = this.parseMeetings(content);
     const feed = this.parseFeed(content);
-    log5.info(
+    log4.info(
       { actions: actions.length, projects: projects.length, meetings: meetings.length, feed: feed.length },
       "get_briefing: parsed"
     );
@@ -1249,12 +1165,12 @@ var BrainBridge = class {
     if (!recapPath) {
       return { error: "No recap path provided" };
     }
-    const fullPath = join4(this.brainHome, recapPath);
-    if (!existsSync4(fullPath)) {
-      log5.warn({ fullPath }, "meeting recap file not found");
+    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 */
@@ -1287,10 +1203,10 @@ var BrainBridge = class {
 };
 
 // src/fs-bridge.ts
-import { existsSync as existsSync5, 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 createLogger6 } from "@mclawnet/logger";
-var log6 = createLogger6({ module: "fs-bridge" });
+import { createLogger as createLogger5 } from "@mclawnet/logger";
+var log5 = createLogger5({ module: "fs-bridge" });
 var MAX_TEXT_SIZE = 5 * 1024 * 1024;
 var MIME_MAP = {
   ".ts": "text/typescript",
@@ -1328,10 +1244,10 @@ var FsBridge = class {
   constructor(hub) {
     this.hub = hub;
     this.hub.registerNamespace("fs", (msg) => this.handleRequest(msg));
-    log6.info("FsBridge initialized");
+    log5.info("FsBridge initialized");
   }
   async handleRequest(msg) {
-    log6.info({ action: msg.action, requestId: msg.requestId }, "fs request");
+    log5.info({ action: msg.action, requestId: msg.requestId }, "fs request");
     switch (msg.action) {
       case "read":
         return this.readFile(msg.params);
@@ -1345,7 +1261,7 @@ var FsBridge = class {
     if (!isAbsolute(filePath)) {
       throw new Error(`Access denied: only absolute paths allowed`);
     }
-    if (!existsSync5(filePath)) {
+    if (!existsSync4(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
     const stat2 = statSync2(filePath);
@@ -1355,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 };
@@ -1368,16 +1284,16 @@ var FsBridge = class {
 };
 
 // src/start.ts
-import { createLogger as createLogger7 } from "@mclawnet/logger";
-var log7 = createLogger7({ module: "agent" });
+import { createLogger as createLogger6 } from "@mclawnet/logger";
+var log6 = createLogger6({ module: "agent" });
 async function startAgent(options) {
   const config = loadConfig(options.config);
   if (!config.token) {
-    log7.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
+    log6.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
     process.exit(1);
   }
-  log7.info({ backend: options.adapter.type }, "starting agent");
-  log7.info({ hubUrl: config.hubUrl }, "connecting to hub");
+  log6.info({ backend: options.adapter.type }, "starting agent");
+  log6.info({ hubUrl: config.hubUrl }, "connecting to hub");
   await initRoles();
   await initSkills();
   const hub = new HubConnection({
@@ -1385,13 +1301,13 @@ async function startAgent(options) {
     token: config.token,
     hostname: config.name,
     onConnect: (agentId) => {
-      log7.info({ agentId }, "connected to hub");
+      log6.info({ agentId }, "connected to hub");
     },
     onDisconnect: (code, reason) => {
-      log7.info({ code, reason }, "disconnected from hub");
+      log6.info({ code, reason }, "disconnected from hub");
     },
     onError: (err) => {
-      log7.error({ err }, "hub connection error");
+      log6.error({ err }, "hub connection error");
     }
   });
   let swarmCoordinator;
@@ -1429,7 +1345,7 @@ async function startAgent(options) {
   const brainBridge = new BrainBridge(hub);
   const fsBridge = new FsBridge(hub);
   const shutdown = async () => {
-    log7.info("shutting down");
+    log6.info("shutting down");
     await sessionManager.closeAll();
     hub.destroy();
     process.exit(0);
@@ -1443,10 +1359,8 @@ async function startAgent(options) {
 export {
   HubConnection,
   SessionManager,
-  loadConfig,
-  saveConfig,
   BrainBridge,
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-KITKMSBE.js.map
+//# sourceMappingURL=chunk-GLO5OZAY.js.map