@mclawnet/agent 0.6.24 → 0.6.26

package/dist/__tests__/projects-handler.test.d.ts

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

package/dist/__tests__/projects-handler.test.d.ts.map

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

package/dist/{chunk-WJWCYGLQ.js → chunk-K6CQFAGN.js}

@@ -3,8 +3,8 @@ import {
 } from "./chunk-PJ5M6Q36.js";
 
 // src/start.ts
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 
 // src/hub-connection.ts
 import { hostname as osHostname } from "os";
@@ -246,10 +246,177 @@ async function handleLoadSessionHistory(workDir, claudeSessionId, opts) {
   };
 }
 
+// src/projects-handler.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { TaskStore, projectRoot } from "@mclawnet/task";
+import {
+  listAllProjectSummaries,
+  loadProjectSummary,
+  loadSwarmSummaries,
+  resolveWorkDir,
+  loadSwarmSnapshot,
+  InboxStore,
+  listProjectFiles,
+  readProjectFile,
+  writeProjectFile,
+  ProjectFilesError
+} from "@mclawnet/swarm";
+function getHome() {
+  return process.env.CLAWNET_HOME ?? homedir2();
+}
+async function handleProjectsList() {
+  return { projects: listAllProjectSummaries(getHome()) };
+}
+async function handleProjectsGet(encodedCwd) {
+  const home = getHome();
+  const summary = loadProjectSummary(home, encodedCwd);
+  if (!summary) return { project: null };
+  const swarms = loadSwarmSummaries(home, summary.workDir);
+  return { project: { ...summary, swarms } };
+}
+async function handleProjectsTasks(encodedCwd, filters = {}) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { tasks: [] };
+  const store = new TaskStore({ workDir, home });
+  let tasks = store.list();
+  if (filters.status) tasks = tasks.filter((t) => t.status === filters.status);
+  if (filters.swarmId) tasks = tasks.filter((t) => t.swarmId === filters.swarmId);
+  if (filters.owner) tasks = tasks.filter((t) => t.owner === filters.owner);
+  return { tasks };
+}
+async function handleProjectsTask(encodedCwd, taskId) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { task: null };
+  const task = new TaskStore({ workDir, home }).tryGet(taskId);
+  return { task: task ?? null };
+}
+async function handleProjectsSwarms(encodedCwd) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { swarms: [] };
+  return { swarms: loadSwarmSummaries(home, workDir) };
+}
+async function handleProjectsSwarm(encodedCwd, swarmId) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { snapshot: null, tasks: [] };
+  const snapshot = loadSwarmSnapshot(workDir, swarmId);
+  if (!snapshot) return { snapshot: null, tasks: [] };
+  const tasks = new TaskStore({ workDir, home }).listBySwarm(swarmId);
+  return { snapshot, tasks };
+}
+async function handleProjectsInboxes(encodedCwd, swarmId) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, inboxes: [] };
+  const dir = join2(projectRoot(workDir, home), "swarms", swarmId, "inboxes");
+  if (!existsSync2(dir)) return { projectFound: true, inboxes: [] };
+  const store = new InboxStore(workDir, swarmId, home);
+  let entries;
+  try {
+    entries = readdirSync2(dir).filter((f) => f.endsWith(".json"));
+  } catch (err) {
+    return {
+      projectFound: true,
+      inboxes: [],
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const inboxes = await Promise.all(
+    entries.map(async (file) => {
+      const instanceId = file.slice(0, -".json".length);
+      const all = await store.readAll(instanceId);
+      return {
+        instanceId,
+        messageCount: all.length,
+        unreadCount: all.filter((m) => !m.delivered).length
+      };
+    })
+  );
+  return { projectFound: true, inboxes };
+}
+async function handleProjectsInbox(encodedCwd, swarmId, instanceId) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, messages: null, error: null };
+  try {
+    const messages = await new InboxStore(workDir, swarmId, home).readAll(instanceId);
+    return { projectFound: true, messages, error: null };
+  } catch (err) {
+    return {
+      projectFound: true,
+      messages: null,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function handleProjectsSwarmSessionId(encodedCwd, swarmId) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, swarmFound: false, hubSessionId: null };
+  const snap = loadSwarmSnapshot(workDir, swarmId);
+  if (!snap) return { projectFound: true, swarmFound: false, hubSessionId: null };
+  return { projectFound: true, swarmFound: true, hubSessionId: snap.hubSessionId ?? null };
+}
+async function handleProjectsFilesList(encodedCwd) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, files: [] };
+  return { projectFound: true, files: listProjectFiles(workDir) };
+}
+async function handleProjectsFileRead(encodedCwd, relPath) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, file: null, error: null };
+  try {
+    const file = readProjectFile(workDir, relPath);
+    return { projectFound: true, file, error: null };
+  } catch (err) {
+    if (err instanceof ProjectFilesError) {
+      return {
+        projectFound: true,
+        file: null,
+        error: { status: err.status, message: err.message, details: err.details }
+      };
+    }
+    return {
+      projectFound: true,
+      file: null,
+      error: { status: 500, message: err instanceof Error ? err.message : String(err) }
+    };
+  }
+}
+async function handleProjectsFileWrite(encodedCwd, relPath, content, ifMatchEtag) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, file: null, error: null };
+  try {
+    const file = writeProjectFile(workDir, relPath, content, { ifMatchEtag });
+    return { projectFound: true, file, error: null };
+  } catch (err) {
+    if (err instanceof ProjectFilesError) {
+      return {
+        projectFound: true,
+        file: null,
+        error: { status: err.status, message: err.message, details: err.details }
+      };
+    }
+    return {
+      projectFound: true,
+      file: null,
+      error: { status: 500, message: err instanceof Error ? err.message : String(err) }
+    };
+  }
+}
+
 // src/swarm-control-dispatch.ts
 import { randomUUID } from "crypto";
 import { createLogger } from "@mclawnet/logger";
-import { InboxStore } from "@mclawnet/swarm";
+import { InboxStore as InboxStore2 } from "@mclawnet/swarm";
 var log = createLogger({ module: "agent/swarm-control" });
 async function handleSwarmControl(coord, msg, opts) {
   if (!msg || msg.type !== "swarm_spawn" && msg.type !== "swarm_resume") {
@@ -280,7 +447,7 @@ async function handleSwarmControl(coord, msg, opts) {
     const queen = coord.findQueenInstance?.(swarmId);
     if (swarm && swarm.workDir && queen) {
       try {
-        const store = new InboxStore(swarm.workDir, swarmId, opts.home);
+        const store = new InboxStore2(swarm.workDir, swarmId, opts.home);
         await store.append(queen.instanceId, {
           id: randomUUID(),
           from: "user",
@@ -509,6 +676,132 @@ var HubConnection = class {
       });
       return true;
     }
+    if (msg.type === "projects.list") {
+      log2.info("projects.list");
+      handleProjectsList().then((r) => this.send({ type: "projects.list_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err }, "projects.list failed");
+        this.send({ type: "projects.list_result", requestId: msg.requestId, projects: [] });
+      });
+      return true;
+    }
+    if (msg.type === "projects.get") {
+      log2.info({ encodedCwd: msg.encodedCwd }, "projects.get");
+      handleProjectsGet(msg.encodedCwd).then((r) => this.send({ type: "projects.get_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd }, "projects.get failed");
+        this.send({ type: "projects.get_result", requestId: msg.requestId, project: null });
+      });
+      return true;
+    }
+    if (msg.type === "projects.tasks") {
+      log2.info({ encodedCwd: msg.encodedCwd, status: msg.status, swarmId: msg.swarmId, owner: msg.owner }, "projects.tasks");
+      handleProjectsTasks(msg.encodedCwd, { status: msg.status, swarmId: msg.swarmId, owner: msg.owner }).then((r) => this.send({ type: "projects.tasks_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, status: msg.status, swarmId: msg.swarmId, owner: msg.owner }, "projects.tasks failed");
+        this.send({ type: "projects.tasks_result", requestId: msg.requestId, tasks: [] });
+      });
+      return true;
+    }
+    if (msg.type === "projects.task") {
+      log2.info({ encodedCwd: msg.encodedCwd, taskId: msg.taskId }, "projects.task");
+      handleProjectsTask(msg.encodedCwd, msg.taskId).then((r) => this.send({ type: "projects.task_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, taskId: msg.taskId }, "projects.task failed");
+        this.send({ type: "projects.task_result", requestId: msg.requestId, task: null });
+      });
+      return true;
+    }
+    if (msg.type === "projects.swarms") {
+      log2.info({ encodedCwd: msg.encodedCwd }, "projects.swarms");
+      handleProjectsSwarms(msg.encodedCwd).then((r) => this.send({ type: "projects.swarms_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd }, "projects.swarms failed");
+        this.send({ type: "projects.swarms_result", requestId: msg.requestId, swarms: [] });
+      });
+      return true;
+    }
+    if (msg.type === "projects.swarm") {
+      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm");
+      handleProjectsSwarm(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.swarm_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm failed");
+        this.send({ type: "projects.swarm_result", requestId: msg.requestId, snapshot: null, tasks: [] });
+      });
+      return true;
+    }
+    if (msg.type === "projects.inboxes") {
+      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.inboxes");
+      handleProjectsInboxes(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.inboxes_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.inboxes failed");
+        this.send({
+          type: "projects.inboxes_result",
+          requestId: msg.requestId,
+          projectFound: true,
+          inboxes: [],
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.inbox") {
+      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, instanceId: msg.instanceId }, "projects.inbox");
+      handleProjectsInbox(msg.encodedCwd, msg.swarmId, msg.instanceId).then((r) => this.send({ type: "projects.inbox_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, instanceId: msg.instanceId }, "projects.inbox failed");
+        this.send({
+          type: "projects.inbox_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          messages: null,
+          error: "agent error"
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.swarm_session_id") {
+      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm_session_id");
+      handleProjectsSwarmSessionId(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.swarm_session_id_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm_session_id failed");
+        this.send({
+          type: "projects.swarm_session_id_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          swarmFound: false,
+          hubSessionId: null
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.files_list") {
+      log2.info({ encodedCwd: msg.encodedCwd }, "projects.files_list");
+      handleProjectsFilesList(msg.encodedCwd).then((r) => this.send({ type: "projects.files_list_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd }, "projects.files_list failed");
+        this.send({ type: "projects.files_list_result", requestId: msg.requestId, projectFound: false, files: [] });
+      });
+      return true;
+    }
+    if (msg.type === "projects.file_read") {
+      log2.info({ encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_read");
+      handleProjectsFileRead(msg.encodedCwd, msg.relPath).then((r) => this.send({ type: "projects.file_read_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_read failed");
+        this.send({
+          type: "projects.file_read_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          file: null,
+          error: { status: 500, message: "agent error" }
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.file_write") {
+      log2.info({ encodedCwd: msg.encodedCwd, relPath: msg.relPath, hasIfMatch: !!msg.ifMatchEtag }, "projects.file_write");
+      handleProjectsFileWrite(msg.encodedCwd, msg.relPath, msg.content, msg.ifMatchEtag).then((r) => this.send({ type: "projects.file_write_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log2.error({ err, encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_write failed");
+        this.send({
+          type: "projects.file_write_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          file: null,
+          error: { status: 500, message: "agent error" }
+        });
+      });
+      return true;
+    }
     if (msg.type === "list_roles") {
       log2.info("list_roles");
       const roleNames = listRoles();
@@ -1286,18 +1579,18 @@ import { buildMemorySection } from "@mclawnet/memory";
 import { MAX_TOKENS_LADDER, clampLadderIndex } from "@mclawnet/shared";
 
 // src/skill-loader.ts
-import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { createHash } from "crypto";
-import { join as join2, dirname } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join3, dirname } from "path";
+import { homedir as homedir3 } from "os";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { createLogger as createLogger4 } from "@mclawnet/logger";
 import { ManifestManager, mergeSkillSections } from "@mclawnet/skill-manager";
 var log4 = createLogger4({ 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");
+var CLAWNET_DIR = join3(homedir3(), ".clawnet");
+var SKILLS_DIR = join3(CLAWNET_DIR, ".claude", "skills");
+var MCP_CONFIG_PATH = join3(CLAWNET_DIR, "mcp.json");
 async function initSkills() {
   ensureSkillsDir();
   syncBuiltinSkills(CLAWNET_DIR, defaultBuiltinSourceDir());
@@ -1306,7 +1599,7 @@ async function initSkills() {
 }
 function defaultBuiltinSourceDir() {
   const thisFile = fileURLToPath(import.meta.url);
-  return join2(dirname(thisFile), "..", "skills");
+  return join3(dirname(thisFile), "..", "skills");
 }
 function sha256(s) {
   return createHash("sha256").update(s).digest("hex");
@@ -1316,26 +1609,26 @@ function readBuiltinVersion(content) {
   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)) {
+  const skillsDir = join3(rootDir, ".claude", "skills");
+  if (!existsSync3(skillsDir)) mkdirSync(skillsDir, { recursive: true });
+  if (!existsSync3(srcDir)) {
     log4.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);
+    entries = readdirSync3(srcDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
     log4.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");
+    const srcSkillMd = join3(srcDir, skillName, "SKILL.md");
+    if (!existsSync3(srcSkillMd)) continue;
+    const destDir = join3(skillsDir, skillName);
+    const destSkillMd = join3(destDir, "SKILL.md");
+    const baseSnapshotPath = join3(destDir, ".base.md");
     let officialContent;
     try {
       officialContent = readFileSync2(srcSkillMd, "utf-8");
@@ -1345,7 +1638,7 @@ function syncBuiltinSkills(rootDir, srcDir) {
     }
     const officialHash = sha256(officialContent);
     const officialVersion = readBuiltinVersion(officialContent);
-    if (!existsSync2(destSkillMd)) {
+    if (!existsSync3(destSkillMd)) {
       try {
         mkdirSync(destDir, { recursive: true });
         writeFileSync(destSkillMd, officialContent);
@@ -1360,7 +1653,7 @@ function syncBuiltinSkills(rootDir, srcDir) {
     const userContent = readFileSync2(destSkillMd, "utf-8");
     const userHash = sha256(userContent);
     manifest.refresh(skillName, userHash);
-    if (!existsSync2(baseSnapshotPath)) {
+    if (!existsSync3(baseSnapshotPath)) {
       const entry = manifest.load().skills[skillName];
       if (entry && !entry.userModified) {
         try {
@@ -1389,7 +1682,7 @@ function syncBuiltinSkills(rootDir, srcDir) {
         log4.debug({ skill: skillName }, "keeping user-modified skill");
         break;
       case "needs-merge": {
-        if (!existsSync2(baseSnapshotPath)) {
+        if (!existsSync3(baseSnapshotPath)) {
           try {
             writeFileSync(
               destSkillMd + ".conflict",
@@ -1472,25 +1765,25 @@ function renderConflictFile(skillName, officialContent, conflicts) {
   return lines.join("\n");
 }
 function ensureSkillsDir() {
-  if (!existsSync2(SKILLS_DIR)) {
+  if (!existsSync3(SKILLS_DIR)) {
     mkdirSync(SKILLS_DIR, { recursive: true });
     log4.info({ dir: SKILLS_DIR }, "created skills directory");
   }
 }
 var cachedSkills = [];
 function scanSkills() {
-  if (!existsSync2(SKILLS_DIR)) return [];
+  if (!existsSync3(SKILLS_DIR)) return [];
   let dirs;
   try {
-    dirs = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    dirs = readdirSync3(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
     log4.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;
+    const skillMd = join3(SKILLS_DIR, dirName, "SKILL.md");
+    if (!existsSync3(skillMd)) continue;
     try {
       const content = readFileSync2(skillMd, "utf-8");
       const parsed = parseFrontmatter(content);
@@ -1512,8 +1805,8 @@ function getSkillList() {
   return cachedSkills;
 }
 function getPendingNotification() {
-  const pendingPath = join2(CLAWNET_DIR, ".claude", "pending-evolutions.json");
-  if (!existsSync2(pendingPath)) return null;
+  const pendingPath = join3(CLAWNET_DIR, ".claude", "pending-evolutions.json");
+  if (!existsSync3(pendingPath)) return null;
   try {
     const raw = JSON.parse(readFileSync2(pendingPath, "utf-8"));
     const pending = Array.isArray(raw?.pending) ? raw.pending : [];
@@ -1547,7 +1840,7 @@ function ensureMcpConfig() {
   try {
     const req = createRequire(import.meta.url);
     const mcpPkgDir = dirname(req.resolve("@mclawnet/mcp-server/package.json"));
-    mcpServerPath = join2(mcpPkgDir, "dist", "server.js");
+    mcpServerPath = join3(mcpPkgDir, "dist", "server.js");
   } catch {
     log4.warn("could not resolve @mclawnet/mcp-server package path, skipping mcp.json generation");
     return;
@@ -1555,7 +1848,7 @@ function ensureMcpConfig() {
   const desired = { command: "node", args: [mcpServerPath] };
   let config = {};
   let fileExists = false;
-  if (existsSync2(MCP_CONFIG_PATH)) {
+  if (existsSync3(MCP_CONFIG_PATH)) {
     fileExists = true;
     try {
       config = JSON.parse(readFileSync2(MCP_CONFIG_PATH, "utf-8"));
@@ -2181,19 +2474,19 @@ ${notice.text}`;
 
 // src/start.ts
 import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
-import { TaskStore } from "@mclawnet/task";
+import { TaskStore as TaskStore2 } from "@mclawnet/task";
 
 // src/brain-bridge.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync4 } from "fs";
+import { join as join4 } from "path";
 import { createLogger as createLogger6 } from "@mclawnet/logger";
 var log6 = createLogger6({ 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 || join3(home, "BrainData");
-    this.brainCorePath = options?.brainCorePath || join3(home, ".brain", "BrainCore");
+    this.brainHome = options?.brainHomePath || process.env.BRAIN_HOME || join4(home, "BrainData");
+    this.brainCorePath = options?.brainCorePath || join4(home, ".brain", "BrainCore");
     this.hub.registerNamespace("brain", (msg) => this.handleRequest(msg));
     log6.info(
       { brainHome: this.brainHome, brainCorePath: this.brainCorePath },
@@ -2220,15 +2513,15 @@ var BrainBridge = class {
     }
   }
   checkSetup() {
-    if (!existsSync3(this.brainCorePath)) {
+    if (!existsSync4(this.brainCorePath)) {
       return "not_installed";
     }
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    const installJson = join3(home, ".brain", "install.json");
-    if (!existsSync3(installJson)) {
+    const installJson = join4(home, ".brain", "install.json");
+    if (!existsSync4(installJson)) {
       return "needs_config";
     }
-    if (!existsSync3(this.brainHome)) {
+    if (!existsSync4(this.brainHome)) {
       return "needs_config";
     }
     return "ready";
@@ -2236,18 +2529,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 = join3(this.brainHome, "reports", "daily");
-    if (!existsSync3(reportsDir)) {
+    const reportsDir = join4(this.brainHome, "reports", "daily");
+    if (!existsSync4(reportsDir)) {
       log6.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();
+    const files = readdirSync4(reportsDir).filter((f) => f.includes(targetDate) && f.endsWith(".md")).sort().reverse();
     if (files.length === 0) {
       log6.info({ targetDate }, "get_briefing: no report for date");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
     log6.info({ targetDate, file: files[0] }, "get_briefing: reading report");
-    const content = readFileSync3(join3(reportsDir, files[0]), "utf-8");
+    const content = readFileSync3(join4(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);
@@ -2446,8 +2739,8 @@ var BrainBridge = class {
     if (!recapPath) {
       return { error: "No recap path provided" };
     }
-    const fullPath = join3(this.brainHome, recapPath);
-    if (!existsSync3(fullPath)) {
+    const fullPath = join4(this.brainHome, recapPath);
+    if (!existsSync4(fullPath)) {
       log6.warn({ fullPath }, "meeting recap file not found");
       return { error: "Recap file not found" };
     }
@@ -2484,7 +2777,7 @@ var BrainBridge = class {
 };
 
 // src/fs-bridge.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { extname, isAbsolute } from "path";
 import { createLogger as createLogger7 } from "@mclawnet/logger";
 var log7 = createLogger7({ module: "fs-bridge" });
@@ -2542,7 +2835,7 @@ var FsBridge = class {
     if (!isAbsolute(filePath)) {
       throw new Error(`Access denied: only absolute paths allowed`);
     }
-    if (!existsSync4(filePath)) {
+    if (!existsSync5(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
     const stat2 = statSync2(filePath);
@@ -2608,6 +2901,7 @@ import {
   AccumulationScanner,
   triggerFromAccumulation
 } from "@mclawnet/skill-manager";
+import { PROJECTS_RPC_CAPABILITY } from "@mclawnet/shared";
 var log9 = createLogger9({ module: "agent" });
 async function startAgent(options) {
   const config = loadConfig(options.config);
@@ -2623,6 +2917,7 @@ async function startAgent(options) {
     hubUrl: config.hubUrl,
     token: config.token,
     hostname: config.name,
+    capabilities: [PROJECTS_RPC_CAPABILITY],
     onConnect: (agentId) => {
       log9.info({ agentId }, "connected to hub");
       const skills = getSkillList();
@@ -2655,8 +2950,8 @@ 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");
+  const clawnetDir = process.env.CLAWNET_DIR ?? join5(homedir4(), ".clawnet");
+  const dbPath = process.env.CLAWNET_MEMORY_DB ?? join5(clawnetDir, "memory.db");
   let memoryStore = null;
   let embeddingService = null;
   let evolutionPipeline = null;
@@ -2752,18 +3047,18 @@ async function startAgent(options) {
     // PR-C: enable logical-state checkpoint. Lives next to memory.db under
     // CLAWNET_DIR so backup/wipe affects both consistently. Per-call writes
     // are debounced to 5s by SessionManager itself.
-    checkpointPath: join4(clawnetDir, "agent-sessions.json")
+    checkpointPath: join5(clawnetDir, "agent-sessions.json")
   });
   swarmCoordinator = new SwarmCoordinator(sessionManager, hub, (workDir) => {
     try {
       const env = process.env.CLAWNET_DIR;
-      const home = env ? env.replace(/\/\.clawnet\/?$/, "") : homedir3();
-      return new TaskStore({ workDir, home });
+      const home = env ? env.replace(/\/\.clawnet\/?$/, "") : homedir4();
+      return new TaskStore2({ workDir, home });
     } catch (err) {
       log9.warn({ err, workDir }, "TaskStore factory failed");
       return void 0;
     }
-  }, process.env.CLAWNET_HOME ?? homedir3());
+  }, process.env.CLAWNET_HOME ?? homedir4());
   hub.setSessionManager(sessionManager);
   hub.setSwarmCoordinator(swarmCoordinator);
   const scheduleRuntime = new ScheduleRuntime({ hub, sessionManager, swarmCoordinator });
@@ -2799,4 +3094,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-WJWCYGLQ.js.map
+//# sourceMappingURL=chunk-K6CQFAGN.js.map