@mclawnet/agent 0.6.20 → 0.6.22

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

@@ -56,7 +56,7 @@ function extractWorkDirFromSessionFile(filePath) {
   }
   return null;
 }
-function getWorkDirFromProjectFolder(folderPath, folderName) {
+function getWorkDirFromProjectFolder(folderPath) {
   try {
     const files = readdirSync(folderPath);
     for (const file of files) {
@@ -67,13 +67,7 @@ function getWorkDirFromProjectFolder(folderPath, folderName) {
     }
   } catch {
   }
-  if (/^[A-Za-z]--/.test(folderName)) {
-    return folderName.replace(/^([A-Za-z])--/, "$1:/").replace(/-/g, "/");
-  }
-  if (folderName.startsWith("-")) {
-    return "/" + folderName.substring(1).replace(/-/g, "/");
-  }
-  return folderName.replace(/-/g, "/");
+  return null;
 }
 async function handleListFolders() {
   const projectsDir = getClaudeProjectsDir();
@@ -90,7 +84,8 @@ async function handleListFolders() {
     }
     if (!entryStat.isDirectory()) continue;
     if (entry.includes("--crew-roles-")) continue;
-    const originalPath = getWorkDirFromProjectFolder(entryPath, entry);
+    const originalPath = getWorkDirFromProjectFolder(entryPath);
+    if (originalPath === null) continue;
     let sessionCount = 0;
     let lastModified = entryStat.mtime.getTime();
     try {
@@ -251,9 +246,64 @@ async function handleLoadSessionHistory(workDir, claudeSessionId, opts) {
   };
 }
 
+// src/swarm-control-dispatch.ts
+import { randomUUID } from "crypto";
+import { createLogger } from "@mclawnet/logger";
+import { InboxStore } 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") {
+    return { ok: false, error: "unknown control type" };
+  }
+  if (msg.type === "swarm_resume") {
+    try {
+      await coord.recover(msg.swarmId);
+      log.info({ swarmId: msg.swarmId }, "swarm_resume: recovered");
+      return { ok: true, swarmId: msg.swarmId };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      log.error({ err, swarmId: msg.swarmId }, "swarm_resume failed");
+      return { ok: false, error };
+    }
+  }
+  const workDir = msg.workDir ?? opts.defaultWorkDir;
+  const swarmId = msg.swarmId ?? randomUUID();
+  try {
+    await coord.create(swarmId, { workDir, templateName: msg.teamName });
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    log.error({ err, teamName: msg.teamName }, "swarm_spawn: create failed");
+    return { ok: false, error };
+  }
+  if (msg.msg && msg.msg.length > 0) {
+    const swarm = coord.getSwarm?.(swarmId);
+    const queen = coord.findQueenInstance?.(swarmId);
+    if (swarm && swarm.workDir && queen) {
+      try {
+        const store = new InboxStore(swarm.workDir, swarmId, opts.home);
+        await store.append(queen.instanceId, {
+          id: randomUUID(),
+          from: "user",
+          type: "user",
+          data: msg.msg,
+          timestamp: Date.now(),
+          delivered: false
+        });
+        await coord.inboxRelay.deliver(swarmId, queen.instanceId);
+      } catch (err) {
+        log.warn({ err, swarmId }, "swarm_spawn: inbox seed failed (non-fatal)");
+      }
+    } else {
+      log.warn({ swarmId, hasSwarm: !!swarm, hasQueen: !!queen }, "swarm_spawn: queen instance not found, skipping inbox seed");
+    }
+  }
+  log.info({ swarmId, teamName: msg.teamName }, "swarm_spawn: created");
+  return { ok: true, swarmId };
+}
+
 // src/hub-connection.ts
-import { createLogger, previewFields } from "@mclawnet/logger";
-var log = createLogger({ module: "agent" });
+import { createLogger as createLogger2, previewFields } from "@mclawnet/logger";
+var log2 = createLogger2({ module: "agent" });
 var HubConnection = class {
   ws = null;
   heartbeatTimer = null;
@@ -276,6 +326,8 @@ var HubConnection = class {
   sessionManager = null;
   /** Swarm coordinator — set after construction via setSwarmCoordinator() */
   swarmCoordinator = null;
+  /** Schedule runtime — set after construction via setScheduleRuntime() */
+  scheduleRuntime = null;
   /** Namespace-based generic message handlers */
   namespaceHandlers = /* @__PURE__ */ new Map();
   onMessage;
@@ -302,6 +354,9 @@ var HubConnection = class {
   setSwarmCoordinator(coordinator) {
     this.swarmCoordinator = coordinator;
   }
+  setScheduleRuntime(runtime) {
+    this.scheduleRuntime = runtime;
+  }
   registerNamespace(namespace, handler) {
     this.namespaceHandlers.set(namespace, handler);
   }
@@ -341,7 +396,7 @@ var HubConnection = class {
         return;
       }
       if (this.authState === "pending" && data.type === "auth_required") {
-        log.info("hub requires auth, sending credentials");
+        log2.info("hub requires auth, sending credentials");
         this.authState = "authenticating";
         this.sendRaw({
           type: "auth",
@@ -353,7 +408,7 @@ var HubConnection = class {
         return;
       }
       if (this.authState === "authenticating" && data.type === "registered") {
-        log.info({ agentId: data.agentId }, "registered with hub");
+        log2.info({ agentId: data.agentId }, "registered with hub");
         this.authState = "authenticated";
         this.agentId = data.agentId ?? null;
         this.startHeartbeat();
@@ -368,18 +423,18 @@ var HubConnection = class {
       }
     });
     this.ws.on("close", (code, reason) => {
-      log.warn({ code, reason: reason.toString() }, "disconnected from hub");
+      log2.warn({ code, reason: reason.toString() }, "disconnected from hub");
       this.stopHeartbeat();
       this.authState = "pending";
       this.onDisconnect?.(code, reason.toString());
       if (code === WS_CLOSE_INVALID_TOKEN) {
-        log.error("auth failed \u2014 not reconnecting, check your token");
+        log2.error("auth failed \u2014 not reconnecting, check your token");
         return;
       }
       this.scheduleReconnect();
     });
     this.ws.on("error", (err) => {
-      log.error({ err }, "ws connection error");
+      log2.error({ err }, "ws connection error");
       this.onError?.(err);
     });
   }
@@ -396,12 +451,17 @@ var HubConnection = class {
   }
   // ── Session message handling ─────────────────────────────────────
   handleSessionMessage(msg) {
+    const msgType = msg.type;
+    if (typeof msgType === "string" && msgType.startsWith("schedule:") && this.scheduleRuntime) {
+      this.scheduleRuntime.handleHubMessage(msg);
+      return true;
+    }
     if (msg.type === "fs.list_dir") {
-      log.info({ path: msg.path }, "fs.list_dir");
+      log2.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) => {
-        log.error({ err, path: msg.path }, "fs.list_dir failed");
+        log2.error({ err, path: msg.path }, "fs.list_dir failed");
         this.send({
           type: "fs.list_dir_result",
           requestId: msg.requestId,
@@ -412,21 +472,21 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "list_folders") {
-      log.info("list_folders");
+      log2.info("list_folders");
       handleListFolders().then((result) => {
         this.send({ type: "folders_list_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log.error({ err }, "list_folders failed");
+        log2.error({ err }, "list_folders failed");
         this.send({ type: "folders_list_result", requestId: msg.requestId, folders: [] });
       });
       return true;
     }
     if (msg.type === "list_history_sessions") {
-      log.info({ workDir: msg.workDir }, "list_history_sessions");
+      log2.info({ workDir: msg.workDir }, "list_history_sessions");
       handleListHistorySessions(msg.workDir).then((result) => {
         this.send({ type: "history_sessions_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log.error({ err, workDir: msg.workDir }, "list_history_sessions failed");
+        log2.error({ err, workDir: msg.workDir }, "list_history_sessions failed");
         this.send({
           type: "history_sessions_result",
           requestId: msg.requestId,
@@ -437,20 +497,20 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "load_session_history") {
-      log.info(
+      log2.info(
         { workDir: msg.workDir, claudeSessionId: msg.claudeSessionId, before: msg.before, limit: msg.limit },
         "load_session_history"
       );
       handleLoadSessionHistory(msg.workDir, msg.claudeSessionId, { before: msg.before, limit: msg.limit }).then((result) => {
         this.send({ type: "session_history_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log.error({ err, workDir: msg.workDir }, "load_session_history failed");
+        log2.error({ err, workDir: msg.workDir }, "load_session_history failed");
         this.send({ type: "session_history_result", requestId: msg.requestId, messages: [], oldestSeq: 0, hasMore: false });
       });
       return true;
     }
     if (msg.type === "list_roles") {
-      log.info("list_roles");
+      log2.info("list_roles");
       const roleNames = listRoles();
       const roles = roleNames.map((name) => {
         try {
@@ -476,7 +536,7 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "list_templates") {
-      log.info("list_templates");
+      log2.info("list_templates");
       try {
         const names = listTemplates();
         const templates = names.map((name) => {
@@ -495,7 +555,7 @@ var HubConnection = class {
           templates
         });
       } catch (err) {
-        log.error({ err }, "list_templates failed");
+        log2.error({ err }, "list_templates failed");
         this.send({
           type: "templates_list_result",
           sessionId: msg.sessionId,
@@ -507,9 +567,9 @@ var HubConnection = class {
     if (msg.type === "generic.request") {
       const handler = this.namespaceHandlers.get(msg.namespace);
       if (handler) {
-        log.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request received");
+        log2.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request received");
         handler(msg).then((result) => {
-          log.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request handled OK");
+          log2.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request handled OK");
           this.send({
             type: "generic.response",
             namespace: msg.namespace,
@@ -518,7 +578,7 @@ var HubConnection = class {
             requestId: msg.requestId
           });
         }).catch((err) => {
-          log.error({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId, err }, "generic.request handler error");
+          log2.error({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId, err }, "generic.request handler error");
           this.send({
             type: "generic.response",
             namespace: msg.namespace,
@@ -530,7 +590,7 @@ var HubConnection = class {
         });
         return true;
       }
-      log.warn({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request unknown namespace");
+      log2.warn({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request unknown namespace");
       this.send({
         type: "generic.response",
         namespace: msg.namespace,
@@ -541,10 +601,22 @@ var HubConnection = class {
       });
       return true;
     }
+    if ((msg.type === "swarm_spawn" || msg.type === "swarm_resume") && this.swarmCoordinator) {
+      const coord = this.swarmCoordinator;
+      handleSwarmControl(coord, msg, {
+        defaultWorkDir: process.cwd(),
+        home: process.env.CLAWNET_HOME
+      }).then((result) => {
+        log2.info({ type: msg.type, ok: result.ok, swarmId: result.swarmId, error: result.error }, "swarm control handled");
+      }).catch((err) => {
+        log2.error({ err, type: msg.type }, "swarm control crashed");
+      });
+      return true;
+    }
     if (msg.type === "swarm.execute" && this.swarmCoordinator) {
       const { sessionId, content, workDir, targetInstance, crewConfig } = msg;
       if (this.swarmCoordinator.hasSwarm(sessionId)) {
-        log.info({ sessionId, targetInstance }, "swarm.execute: forwarding to existing swarm");
+        log2.info({ sessionId, targetInstance }, "swarm.execute: forwarding to existing swarm");
         this.swarmCoordinator.handleUserMessage(sessionId, content, targetInstance).catch((err) => {
           this.send({
             type: "session.error",
@@ -557,7 +629,7 @@ var HubConnection = class {
           this.finishedSwarms.delete(sessionId);
           const templateName = crewConfig.templateName;
           const roles = crewConfig.roles;
-          log.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: continuing finished swarm");
+          log2.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: continuing finished swarm");
           this.swarmCoordinator.create(sessionId, { workDir, templateName, roles, task: content, isContinuation: true }).catch((err) => {
             this.send({
               type: "session.error",
@@ -566,7 +638,7 @@ var HubConnection = class {
             });
           });
         } else {
-          log.info({ sessionId }, "swarm.execute ignored: swarm finished, no config to recreate");
+          log2.info({ sessionId }, "swarm.execute ignored: swarm finished, no config to recreate");
           this.send({
             type: "session.error",
             sessionId,
@@ -576,7 +648,7 @@ var HubConnection = class {
       } else if (crewConfig?.templateName || crewConfig?.roles) {
         const templateName = crewConfig.templateName;
         const roles = crewConfig.roles;
-        log.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: creating new swarm");
+        log2.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",
@@ -585,7 +657,7 @@ var HubConnection = class {
           });
         });
       } else {
-        log.info({ sessionId }, "swarm.execute ignored: swarm not found, no config");
+        log2.info({ sessionId }, "swarm.execute ignored: swarm not found, no config");
         this.send({
           type: "session.error",
           sessionId,
@@ -597,7 +669,7 @@ var HubConnection = class {
     if (!this.sessionManager) return false;
     if (msg.type === "abort_execution") {
       const { sessionId } = msg;
-      log.info({ sessionId }, "abort_execution");
+      log2.info({ sessionId }, "abort_execution");
       if (this.sessionManager?.hasSession(sessionId)) {
         this.sessionManager.abortSession(sessionId).then(() => {
           this.send({ type: "execution_aborted", sessionId });
@@ -612,10 +684,20 @@ var HubConnection = class {
     if (msg.type === "claude.execute") {
       const { sessionId, content, workDir, claudeSessionId, useBrainCore } = msg;
       const sm = this.sessionManager;
-      const spawnAndSend = (resumeId, label) => {
-        log.info({ sessionId, claudeSessionId: resumeId, workDir, label }, "claude.execute: spawning");
-        log.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
-        sm.createSession({ sessionId, workDir, resumeId, useBrainCore, roleId: "role-__assistant__" }).then(() => {
+      const spawnAndSend = (resumeId, label, maxOutputTokens) => {
+        log2.info(
+          { sessionId, claudeSessionId: resumeId, workDir, label, maxOutputTokens },
+          "claude.execute: spawning"
+        );
+        log2.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
+        sm.createSession({
+          sessionId,
+          workDir,
+          resumeId,
+          useBrainCore,
+          roleId: "role-__assistant__",
+          maxOutputTokens
+        }).then(() => {
           sm.sendInput(sessionId, content);
         }).catch((err) => {
           this.send({
@@ -626,29 +708,30 @@ var HubConnection = class {
         });
       };
       if (sm.isHealthy(sessionId)) {
-        log.info({ sessionId }, "claude.execute: reusing healthy session");
-        log.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
+        log2.info({ sessionId }, "claude.execute: reusing healthy session");
+        log2.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
         sm.sendInput(sessionId, content);
       } else if (sm.hasSession(sessionId) && claudeSessionId) {
-        log.warn({ sessionId, claudeSessionId }, "claude.execute: session unhealthy, recreating with --resume");
+        const recommendedMax = sm.getRecommendedMaxOutputTokens(sessionId);
+        log2.warn({ sessionId, claudeSessionId }, "claude.execute: session unhealthy, recreating with --resume");
         this.send({
           type: "session.died",
           sessionId,
           reason: "unhealthy_before_input"
         });
         sm.abortSession(sessionId).catch((err) => {
-          log.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during unhealthy fallback, proceeding to respawn");
-        }).then(() => spawnAndSend(claudeSessionId, "unhealthy_fallback_resume"));
+          log2.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during unhealthy fallback, proceeding to respawn");
+        }).then(() => spawnAndSend(claudeSessionId, "unhealthy_fallback_resume", recommendedMax));
       } else if (claudeSessionId) {
-        spawnAndSend(claudeSessionId, "fresh_resume");
+        spawnAndSend(claudeSessionId, "fresh_resume", sm.getRecommendedMaxOutputTokens(sessionId));
       } else {
-        spawnAndSend(void 0, "brand_new");
+        spawnAndSend(void 0, "brand_new", void 0);
       }
       return true;
     }
     if (msg.type === "session.force_restart") {
       const { sessionId, reason } = msg;
-      log.warn({ sessionId, reason }, "session.force_restart received");
+      log2.warn({ sessionId, reason }, "session.force_restart received");
       const sm = this.sessionManager;
       const reply = {
         type: "session.died",
@@ -657,7 +740,7 @@ var HubConnection = class {
       };
       if (sm.hasSession(sessionId)) {
         sm.abortSession(sessionId).catch((err) => {
-          log.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during force_restart");
+          log2.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during force_restart");
         }).finally(() => {
           this.send(reply);
         });
@@ -667,7 +750,7 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "session.create") {
-      log.info({ sessionId: msg.sessionId, roleId: "role-__assistant__" }, "session.create with memory injection");
+      log2.info({ sessionId: msg.sessionId, roleId: "role-__assistant__" }, "session.create with memory injection");
       this.sessionManager.createSession({
         sessionId: msg.sessionId,
         workDir: msg.workDir,
@@ -689,13 +772,13 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "session.close") {
-      log.info({ sessionId: msg.sessionId }, "session.close");
+      log2.info({ sessionId: msg.sessionId }, "session.close");
       this.sessionManager.closeSession(msg.sessionId).catch(() => {
       });
       return true;
     }
     if (msg.type === "claude.input") {
-      log.debug(
+      log2.debug(
         { sessionId: msg.sessionId, ...previewFields(msg.content) },
         "claude.input"
       );
@@ -711,27 +794,27 @@ var HubConnection = class {
       const allIds = listRecoverableSwarmIds();
       const snapshots = listRecoverableSwarms();
       const recoverableIds = new Set(snapshots.map((s) => s.id));
-      for (const id of allIds) {
-        if (!recoverableIds.has(id)) {
-          deleteSwarmSnapshot(id);
-          log.info({ swarmId: id }, "cleaned up non-recoverable swarm snapshot");
+      for (const { workDir, swarmId } of allIds) {
+        if (!recoverableIds.has(swarmId)) {
+          deleteSwarmSnapshot(workDir, swarmId);
+          log2.info({ swarmId }, "cleaned up non-recoverable swarm snapshot");
         }
       }
       for (const snap of snapshots) {
-        log.info({ swarmId: snap.id }, "recovering swarm");
+        log2.info({ swarmId: snap.id }, "recovering swarm");
         recoverSwarm(this.swarmCoordinator, snap).catch((err) => {
-          log.error({ err, swarmId: snap.id }, "failed to recover swarm");
+          log2.error({ err, swarmId: snap.id }, "failed to recover swarm");
         });
       }
     } catch (err) {
-      log.error({ err }, "swarm recovery failed");
+      log2.error({ err }, "swarm recovery failed");
     }
   }
   reportLiveSessions() {
     if (!this.sessionManager) return;
     const ids = this.sessionManager.getActiveSessionIds();
     if (ids.length === 0) return;
-    log.info({ count: ids.length }, "reporting live sessions to hub after reconnect");
+    log2.info({ count: ids.length }, "reporting live sessions to hub after reconnect");
     for (const sessionId of ids) {
       this.send({
         type: "session.state",
@@ -759,7 +842,7 @@ var HubConnection = class {
   }
   scheduleReconnect() {
     if (this.destroyed) return;
-    log.warn({ delayMs: this.reconnectDelay }, "reconnecting to hub...");
+    log2.warn({ delayMs: this.reconnectDelay }, "reconnecting to hub...");
     this.reconnectTimer = setTimeout(() => {
       this.connect();
     }, this.reconnectDelay);
@@ -786,9 +869,421 @@ var HubConnection = class {
   }
 };
 
+// src/schedule-runtime.ts
+import { spawn, execSync } from "child_process";
+import {
+  JsonScheduleRepository,
+  SchedulerService,
+  createOneShotExecutor,
+  createSwarmExecutor,
+  MAX_STDOUT_BYTES,
+  MAX_STDERR_BYTES
+} from "@mclawnet/scheduler";
+import { createLogger as createLogger3 } from "@mclawnet/logger";
+var log3 = createLogger3({ module: "agent/schedule-runtime" });
+var SPAWN_STDOUT_CAP_BYTES = 1024 * 1024;
+var SPAWN_STDERR_CAP_BYTES = 256 * 1024;
+var ScheduleRuntime = class {
+  hub;
+  repo;
+  scheduler;
+  started = false;
+  // Tracks fire-and-forget handler promises so stop() can drain them before
+  // detaching listeners and stopping the scheduler. Without this, an in-flight
+  // handler could resolve after stop() returns and emit a phantom send().
+  inflight = /* @__PURE__ */ new Set();
+  // Bound handlers retained so stop() can detach them cleanly.
+  onChange;
+  onRun;
+  constructor(opts) {
+    this.hub = opts.hub;
+    this.repo = opts.repo ?? new JsonScheduleRepository();
+    const oneshotExec = opts.executors?.oneshot ?? createOneShotExecutor(makeRealOneShotSpawn());
+    const swarmExec = opts.executors?.swarm ?? createSwarmExecutor(
+      makeRealSwarmStarter({
+        sessionManager: opts.sessionManager,
+        swarmCoordinator: opts.swarmCoordinator
+      })
+    );
+    this.scheduler = opts.scheduler ?? new SchedulerService(this.repo, {
+      oneshot: oneshotExec,
+      swarm: swarmExec
+    });
+    this.onChange = (s) => {
+      this.safeSend({ type: "schedule:changed", schedule: s });
+    };
+    this.onRun = (r) => {
+      this.safeSend({ type: "schedule:run", run: r });
+    };
+  }
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    this.scheduler.events.on("change", this.onChange);
+    this.scheduler.events.on("run", this.onRun);
+    await this.scheduler.start();
+  }
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    const pending = Array.from(this.inflight);
+    if (pending.length > 0) {
+      await Promise.allSettled(pending);
+    }
+    this.scheduler.events.off("change", this.onChange);
+    this.scheduler.events.off("run", this.onRun);
+    await this.scheduler.stop();
+  }
+  /**
+   * Wraps `hub.send` with a started-flag guard so handlers that race against
+   * `stop()` can't emit phantom messages after the runtime has shut down.
+   */
+  safeSend(msg) {
+    if (!this.started) return;
+    this.hub.send(msg);
+  }
+  /**
+   * Records `p` in the in-flight set so `stop()` can wait for it, and removes
+   * it on settle. Returns the same promise so callers can `void track(...)`.
+   */
+  track(p) {
+    this.inflight.add(p);
+    return p.finally(() => {
+      this.inflight.delete(p);
+    });
+  }
+  /**
+   * Entry point for any `schedule:*` message arriving from the Hub. Always
+   * returns synchronously; per-branch async work runs on its own microtask
+   * chain and reports results back to the hub.
+   */
+  handleHubMessage(msg) {
+    if (!isMsg(msg)) return;
+    const requestId = typeof msg.requestId === "string" ? msg.requestId : void 0;
+    const m = msg;
+    switch (msg.type) {
+      case "schedule:create":
+        void this.track(this.handleCreate(m, requestId));
+        return;
+      case "schedule:update":
+        void this.track(this.handleUpdate(m, requestId));
+        return;
+      case "schedule:delete":
+        void this.track(this.handleDelete(m, requestId));
+        return;
+      case "schedule:pause":
+        void this.track(this.handlePauseResume(m, requestId, "paused"));
+        return;
+      case "schedule:resume":
+        void this.track(this.handlePauseResume(m, requestId, "active"));
+        return;
+      case "schedule:trigger":
+        void this.track(this.handleTrigger(m, requestId));
+        return;
+      case "schedule:list":
+        void this.track(this.handleList(m, requestId));
+        return;
+      case "schedule:runs":
+        void this.track(this.handleRuns(m, requestId));
+        return;
+      case "schedule:log":
+        void this.track(this.handleLog(m, requestId));
+        return;
+      default:
+        log3.warn({ type: msg.type }, "schedule-runtime: unknown message type");
+        if (requestId !== void 0) {
+          this.safeSend({
+            type: "schedule:error",
+            requestId,
+            error: {
+              code: "INTERNAL",
+              message: `unknown schedule message type: ${msg.type}`
+            }
+          });
+        }
+    }
+  }
+  // ── Per-branch handlers ─────────────────────────────────────────────
+  async handleCreate(msg, requestId) {
+    try {
+      const created = await this.repo.create(
+        msg.input
+      );
+      this.scheduler.register(created);
+      this.safeSend({
+        type: "schedule:create:result",
+        requestId,
+        schedule: created
+      });
+      this.safeSend({ type: "schedule:changed", schedule: created });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  async handleUpdate(msg, requestId) {
+    try {
+      const id = String(msg.id);
+      const updated = await this.repo.update(
+        id,
+        msg.patch
+      );
+      if (updated.status === "active") {
+        this.scheduler.register(updated);
+      } else {
+        this.scheduler.unregister(id);
+      }
+      this.safeSend({
+        type: "schedule:update:result",
+        requestId,
+        schedule: updated
+      });
+      this.safeSend({ type: "schedule:changed", schedule: updated });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  async handleDelete(msg, requestId) {
+    const id = String(msg.id);
+    try {
+      this.scheduler.unregister(id);
+      await this.repo.delete(id);
+      this.safeSend({ type: "schedule:delete:result", requestId, id });
+      this.safeSend({ type: "schedule:removed", id });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  async handlePauseResume(msg, requestId, nextStatus) {
+    const id = String(msg.id);
+    try {
+      const updated = await this.repo.update(id, { status: nextStatus });
+      if (nextStatus === "active") {
+        this.scheduler.register(updated);
+      } else {
+        this.scheduler.unregister(id);
+      }
+      const resultType = nextStatus === "paused" ? "schedule:pause:result" : "schedule:resume:result";
+      this.safeSend({ type: resultType, requestId, schedule: updated });
+      this.safeSend({ type: "schedule:changed", schedule: updated });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  async handleTrigger(msg, requestId) {
+    const id = String(msg.id);
+    try {
+      await this.scheduler.triggerNow(id);
+      const snap = await this.repo.getById(id);
+      this.safeSend({
+        type: "schedule:trigger:result",
+        requestId,
+        schedule: snap
+      });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  async handleList(msg, requestId) {
+    try {
+      const all = await this.repo.listAll();
+      const list = typeof msg.encodedCwd === "string" ? all.filter((s) => s.encodedCwd === msg.encodedCwd) : all;
+      this.safeSend({
+        type: "schedule:list:result",
+        requestId,
+        schedules: list
+      });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  async handleRuns(msg, requestId) {
+    const id = String(msg.id);
+    try {
+      const runs = await this.repo.listRuns(id);
+      this.safeSend({ type: "schedule:runs:result", requestId, runs });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  async handleLog(msg, requestId) {
+    const id = String(msg.id);
+    const runId = String(msg.runId);
+    try {
+      const { stdout, stderr } = await this.repo.readRunLogs(id, runId);
+      this.safeSend({
+        type: "schedule:log:result",
+        requestId,
+        runId,
+        stdout,
+        stderr
+      });
+    } catch (err) {
+      this.sendError(requestId, err);
+    }
+  }
+  sendError(requestId, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log3.warn({ err: message, requestId }, "schedule-runtime: branch failed");
+    this.safeSend({
+      type: "schedule:error",
+      requestId,
+      error: { code: "INTERNAL", message }
+    });
+  }
+};
+function isMsg(x) {
+  return typeof x === "object" && x !== null && typeof x.type === "string";
+}
+function resolveClaudeBin() {
+  if (process.env.CLAUDE_BIN) return process.env.CLAUDE_BIN;
+  try {
+    const which = process.platform === "win32" ? "where" : "which";
+    const out = execSync(`${which} claude`, { stdio: ["ignore", "pipe", "ignore"] }).toString().split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    if (out[0]) return out[0];
+  } catch {
+  }
+  return "claude";
+}
+var BoundedBuffer = class {
+  constructor(cap) {
+    this.cap = cap;
+    this.headCap = Math.floor(cap / 2);
+    this.tailCap = cap - this.headCap;
+  }
+  head = Buffer.alloc(0);
+  tailRing = [];
+  tailBytes = 0;
+  totalBytes = 0;
+  headCap;
+  tailCap;
+  push(chunk) {
+    if (chunk.length === 0) return;
+    const buf = Buffer.from(chunk, "utf8");
+    this.totalBytes += buf.byteLength;
+    if (this.head.byteLength < this.headCap) {
+      const need = this.headCap - this.head.byteLength;
+      if (buf.byteLength <= need) {
+        this.head = Buffer.concat([this.head, buf]);
+        return;
+      }
+      let split = need;
+      while (split > 0 && (buf[split] & 192) === 128) split -= 1;
+      this.head = Buffer.concat([this.head, buf.subarray(0, split)]);
+      this.appendToTail(buf.subarray(split));
+      return;
+    }
+    this.appendToTail(buf);
+  }
+  appendToTail(buf) {
+    if (buf.byteLength === 0) return;
+    this.tailRing.push(buf);
+    this.tailBytes += buf.byteLength;
+    while (this.tailBytes > this.tailCap && this.tailRing.length > 0) {
+      const front = this.tailRing[0];
+      const overflow = this.tailBytes - this.tailCap;
+      if (front.byteLength <= overflow) {
+        this.tailRing.shift();
+        this.tailBytes -= front.byteLength;
+      } else {
+        let start = overflow;
+        while (start < front.byteLength && (front[start] & 192) === 128) {
+          start += 1;
+        }
+        this.tailRing[0] = front.subarray(start);
+        this.tailBytes -= start;
+      }
+    }
+  }
+  toString() {
+    const tail = this.tailRing.length > 0 ? Buffer.concat(this.tailRing) : Buffer.alloc(0);
+    if (this.totalBytes <= this.cap) {
+      return Buffer.concat([this.head, tail]).toString("utf8");
+    }
+    const dropped = this.totalBytes - this.head.byteLength - tail.byteLength;
+    const marker = `
+...[truncated ${dropped} bytes]...
+`;
+    return this.head.toString("utf8") + marker + tail.toString("utf8");
+  }
+};
+function makeRealOneShotSpawn() {
+  return async (args, opts) => {
+    const bin = resolveClaudeBin();
+    const proc = spawn(bin, args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutBuf = new BoundedBuffer(SPAWN_STDOUT_CAP_BYTES);
+    const stderrBuf = new BoundedBuffer(SPAWN_STDERR_CAP_BYTES);
+    let stdoutLineResidual = "";
+    let lastAssistantText;
+    const tryExtractAssistant = (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const obj = JSON.parse(trimmed);
+        if (obj.type === "assistant" && obj.message?.content) {
+          for (const piece of obj.message.content) {
+            if (piece.type === "text" && typeof piece.text === "string") {
+              lastAssistantText = piece.text;
+            }
+          }
+        }
+      } catch {
+      }
+    };
+    proc.stdout?.setEncoding("utf8");
+    proc.stderr?.setEncoding("utf8");
+    proc.stdout?.on("data", (chunk) => {
+      stdoutBuf.push(chunk);
+      const combined = stdoutLineResidual + chunk;
+      const lines = combined.split("\n");
+      stdoutLineResidual = lines.pop() ?? "";
+      for (const line of lines) tryExtractAssistant(line);
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderrBuf.push(chunk);
+    });
+    const onAbort = () => {
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+    };
+    if (opts.signal.aborted) onAbort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+    return new Promise((resolve, reject) => {
+      proc.once("error", (err) => {
+        opts.signal.removeEventListener("abort", onAbort);
+        reject(err);
+      });
+      proc.once("close", (code) => {
+        opts.signal.removeEventListener("abort", onAbort);
+        if (stdoutLineResidual.length > 0) {
+          tryExtractAssistant(stdoutLineResidual);
+          stdoutLineResidual = "";
+        }
+        resolve({
+          exitCode: code ?? -1,
+          stdout: stdoutBuf.toString(),
+          stderr: stderrBuf.toString(),
+          lastAssistantText
+        });
+      });
+    });
+  };
+}
+function makeRealSwarmStarter(_deps) {
+  return async () => {
+    throw new Error("swarm scheduler executor not yet wired");
+  };
+}
+
 // src/session-manager.ts
-import { createLogger as createLogger3, previewFields as previewFields2 } from "@mclawnet/logger";
+import { createLogger as createLogger5, previewFields as previewFields2 } from "@mclawnet/logger";
 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";
@@ -797,9 +1292,9 @@ import { join as join2, dirname } from "path";
 import { homedir as homedir2 } from "os";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
-import { createLogger as createLogger2 } from "@mclawnet/logger";
+import { createLogger as createLogger4 } from "@mclawnet/logger";
 import { ManifestManager, mergeSkillSections } from "@mclawnet/skill-manager";
-var log2 = createLogger2({ module: "agent/skill-loader" });
+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");
@@ -824,7 +1319,7 @@ function syncBuiltinSkills(rootDir, srcDir) {
   const skillsDir = join2(rootDir, ".claude", "skills");
   if (!existsSync2(skillsDir)) mkdirSync(skillsDir, { recursive: true });
   if (!existsSync2(srcDir)) {
-    log2.debug({ srcDir }, "no built-in skills directory found, skipping");
+    log4.debug({ srcDir }, "no built-in skills directory found, skipping");
     return;
   }
   const manifest = new ManifestManager(rootDir);
@@ -832,7 +1327,7 @@ function syncBuiltinSkills(rootDir, srcDir) {
   try {
     entries = readdirSync2(srcDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
-    log2.warn({ srcDir }, "failed to read built-in skills directory");
+    log4.warn({ srcDir }, "failed to read built-in skills directory");
     return;
   }
   for (const skillName of entries) {
@@ -845,7 +1340,7 @@ function syncBuiltinSkills(rootDir, srcDir) {
     try {
       officialContent = readFileSync2(srcSkillMd, "utf-8");
     } catch (err) {
-      log2.warn({ skill: skillName, err }, "failed to read built-in skill");
+      log4.warn({ skill: skillName, err }, "failed to read built-in skill");
       continue;
     }
     const officialHash = sha256(officialContent);
@@ -856,9 +1351,9 @@ function syncBuiltinSkills(rootDir, srcDir) {
         writeFileSync(destSkillMd, officialContent);
         writeFileSync(baseSnapshotPath, officialContent);
         manifest.register(skillName, officialHash, officialVersion);
-        log2.info({ skill: skillName, version: officialVersion }, "installed built-in skill");
+        log4.info({ skill: skillName, version: officialVersion }, "installed built-in skill");
       } catch (err) {
-        log2.warn({ skill: skillName, err }, "failed to install built-in skill");
+        log4.warn({ skill: skillName, err }, "failed to install built-in skill");
       }
       continue;
     }
@@ -871,27 +1366,27 @@ function syncBuiltinSkills(rootDir, srcDir) {
         try {
           writeFileSync(baseSnapshotPath, userContent);
         } catch (err) {
-          log2.debug({ skill: skillName, err }, "failed to write lazy .base.md");
+          log4.debug({ skill: skillName, err }, "failed to write lazy .base.md");
         }
       }
     }
     const action = manifest.determineSyncAction(skillName, officialHash, officialVersion);
     switch (action) {
       case "skip":
-        log2.debug({ skill: skillName }, "skill already up to date");
+        log4.debug({ skill: skillName }, "skill already up to date");
         break;
       case "direct-overwrite":
         try {
           writeFileSync(destSkillMd, officialContent);
           writeFileSync(baseSnapshotPath, officialContent);
           manifest.markSynced(skillName, officialHash, officialHash, officialVersion);
-          log2.info({ skill: skillName, version: officialVersion }, "upgraded built-in skill");
+          log4.info({ skill: skillName, version: officialVersion }, "upgraded built-in skill");
         } catch (err) {
-          log2.warn({ skill: skillName, err }, "failed to overwrite skill");
+          log4.warn({ skill: skillName, err }, "failed to overwrite skill");
         }
         break;
       case "keep-user":
-        log2.debug({ skill: skillName }, "keeping user-modified skill");
+        log4.debug({ skill: skillName }, "keeping user-modified skill");
         break;
       case "needs-merge": {
         if (!existsSync2(baseSnapshotPath)) {
@@ -906,12 +1401,12 @@ function syncBuiltinSkills(rootDir, srcDir) {
                 }
               ])
             );
-            log2.warn(
+            log4.warn(
               { skill: skillName },
               "missing .base.md snapshot \u2014 skipping auto-merge, wrote .conflict advisory"
             );
           } catch (err) {
-            log2.warn({ skill: skillName, err }, "failed to write .conflict advisory");
+            log4.warn({ skill: skillName, err }, "failed to write .conflict advisory");
           }
           break;
         }
@@ -923,9 +1418,9 @@ function syncBuiltinSkills(rootDir, srcDir) {
             writeFileSync(baseSnapshotPath, officialContent);
             const newCurrentHash = sha256(merged.content);
             manifest.markSynced(skillName, officialHash, newCurrentHash, officialVersion);
-            log2.info({ skill: skillName }, "auto-merged skill upgrade");
+            log4.info({ skill: skillName }, "auto-merged skill upgrade");
           } catch (err) {
-            log2.warn({ skill: skillName, err }, "failed to write merged skill");
+            log4.warn({ skill: skillName, err }, "failed to write merged skill");
           }
         } else {
           try {
@@ -933,12 +1428,12 @@ function syncBuiltinSkills(rootDir, srcDir) {
               destSkillMd + ".conflict",
               renderConflictFile(skillName, officialContent, merged.conflicts ?? [])
             );
-            log2.warn(
+            log4.warn(
               { skill: skillName, conflicts: merged.conflicts?.length },
               "skill merge conflict \u2014 user version kept, .conflict file written"
             );
           } catch (err) {
-            log2.warn({ skill: skillName, err }, "failed to write .conflict file");
+            log4.warn({ skill: skillName, err }, "failed to write .conflict file");
           }
         }
         break;
@@ -979,7 +1474,7 @@ function renderConflictFile(skillName, officialContent, conflicts) {
 function ensureSkillsDir() {
   if (!existsSync2(SKILLS_DIR)) {
     mkdirSync(SKILLS_DIR, { recursive: true });
-    log2.info({ dir: SKILLS_DIR }, "created skills directory");
+    log4.info({ dir: SKILLS_DIR }, "created skills directory");
   }
 }
 var cachedSkills = [];
@@ -989,7 +1484,7 @@ function scanSkills() {
   try {
     dirs = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
-    log2.warn("failed to read skills directory for scanning");
+    log4.warn("failed to read skills directory for scanning");
     return [];
   }
   const skills = [];
@@ -1006,11 +1501,11 @@ function scanSkills() {
         });
       }
     } catch (err) {
-      log2.debug({ skill: dirName, err }, "failed to parse SKILL.md frontmatter");
+      log4.debug({ skill: dirName, err }, "failed to parse SKILL.md frontmatter");
     }
   }
   cachedSkills = skills;
-  log2.info({ count: skills.length }, "scanned skills");
+  log4.info({ count: skills.length }, "scanned skills");
   return skills;
 }
 function getSkillList() {
@@ -1031,7 +1526,7 @@ ${lines.join("\n")}
 \u4F7F\u7528 skill_pending_list \u67E5\u770B\u8BE6\u60C5\uFF0Cskill_pending_approve / skill_pending_reject \u5904\u7406\u3002`;
     return { count: pending.length, text };
   } catch (err) {
-    log2.debug({ err }, "failed to read pending-evolutions.json");
+    log4.debug({ err }, "failed to read pending-evolutions.json");
     return null;
   }
 }
@@ -1048,54 +1543,179 @@ function parseFrontmatter(content) {
   };
 }
 function ensureMcpConfig() {
-  if (existsSync2(MCP_CONFIG_PATH)) {
-    log2.debug("mcp.json already exists, skipping");
-    return;
-  }
   let mcpServerPath;
   try {
     const req = createRequire(import.meta.url);
     const mcpPkgDir = dirname(req.resolve("@mclawnet/mcp-server/package.json"));
     mcpServerPath = join2(mcpPkgDir, "dist", "server.js");
   } catch {
-    log2.warn("could not resolve @mclawnet/mcp-server package path, skipping mcp.json generation");
+    log4.warn("could not resolve @mclawnet/mcp-server package path, skipping mcp.json generation");
     return;
   }
-  const config = {
-    mcpServers: {
-      "clawnet-mcp": {
-        command: "node",
-        args: [mcpServerPath]
-      }
+  const desired = { command: "node", args: [mcpServerPath] };
+  let config = {};
+  let fileExists = false;
+  if (existsSync2(MCP_CONFIG_PATH)) {
+    fileExists = true;
+    try {
+      config = JSON.parse(readFileSync2(MCP_CONFIG_PATH, "utf-8"));
+    } catch (err) {
+      log4.warn({ err, path: MCP_CONFIG_PATH }, "mcp.json malformed \u2014 leaving alone");
+      return;
     }
-  };
+    if (!config.mcpServers || typeof config.mcpServers !== "object") {
+      config.mcpServers = {};
+    }
+  } else {
+    config = { mcpServers: {} };
+  }
+  const servers = config.mcpServers;
+  let changed = false;
+  const existing = servers["clawnet-mcp"];
+  const existingMatches = existing && existing.command === desired.command && Array.isArray(existing.args) && existing.args[0] === desired.args[0];
+  if (!existingMatches) {
+    servers["clawnet-mcp"] = desired;
+    changed = true;
+  }
+  const legacy = servers["clawnet-memory"];
+  if (legacy && legacy.command === "node" && Array.isArray(legacy.args) && typeof legacy.args[0] === "string" && /@mclawnet\/agent\/node_modules\/@mclawnet\/memory\/dist\/mcp\/server\.js$/.test(
+    legacy.args[0]
+  )) {
+    delete servers["clawnet-memory"];
+    changed = true;
+  }
+  if (!changed) {
+    log4.debug("mcp.json already up-to-date \u2014 no write");
+    return;
+  }
   try {
     mkdirSync(CLAWNET_DIR, { recursive: true });
     writeFileSync(MCP_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
-    log2.info({ path: MCP_CONFIG_PATH }, "generated default mcp.json");
+    log4.info(
+      { path: MCP_CONFIG_PATH, fresh: !fileExists },
+      fileExists ? "updated mcp.json (clawnet-mcp ensured)" : "generated default mcp.json"
+    );
+  } catch (err) {
+    log4.warn({ err }, "failed to write mcp.json");
+  }
+}
+
+// src/errors.ts
+var SessionLimitReachedError = class extends Error {
+  constructor(details) {
+    super(buildMessage(details));
+    this.details = details;
+    this.name = "SessionLimitReachedError";
+  }
+  code = "SESSION_LIMIT_REACHED";
+};
+function buildMessage(d) {
+  const kindParts = Object.entries(d.byKind).map(([k, n]) => `${k}=${n}`).join(", ");
+  const oldest = d.oldestIdleSessionId ? `Oldest idle: ${d.oldestIdleSessionId} (${d.oldestIdleKind}, idle ${Math.round(
+    (d.oldestIdleAgeMs ?? 0) / 1e3
+  )}s).` : "No idle sessions to reclaim.";
+  return `Session limit reached (${d.used}/${d.max}). ${kindParts}. ${oldest}`;
+}
+
+// src/checkpoint.ts
+import { promises as fs } from "fs";
+async function atomicWriteJson(path, data) {
+  const tmp = `${path}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify(data, null, 2));
+  await fs.rename(tmp, path);
+}
+async function readCheckpoint(path) {
+  let raw;
+  try {
+    raw = await fs.readFile(path, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  }
+  return JSON.parse(raw);
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
   } catch (err) {
-    log2.warn({ err }, "failed to generate mcp.json");
+    return err && err.code === "EPERM";
   }
 }
 
 // src/session-manager.ts
-var log3 = createLogger3({ module: "agent/session-manager" });
-var DEFAULT_MAX_PROCESSES = 10;
+var log5 = createLogger5({ module: "agent/session-manager" });
+var DEFAULT_MAX_PROCESSES = 30;
 var MAX_PROCESSES = Number(process.env.CLAWNET_MAX_PROCESSES) || DEFAULT_MAX_PROCESSES;
+var DEFAULT_CHAT_IDLE_TTL_MS = 60 * 60 * 1e3;
+var DEFAULT_IDLE_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
+var CHAT_IDLE_TTL_MS = (() => {
+  const raw = process.env.CLAWNET_CHAT_IDLE_TTL_MS;
+  if (raw === void 0) return DEFAULT_CHAT_IDLE_TTL_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : DEFAULT_CHAT_IDLE_TTL_MS;
+})();
+var IDLE_SWEEP_INTERVAL_MS = (() => {
+  const raw = process.env.CLAWNET_IDLE_SWEEP_INTERVAL_MS;
+  if (raw === void 0) return DEFAULT_IDLE_SWEEP_INTERVAL_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_IDLE_SWEEP_INTERVAL_MS;
+})();
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
   conversationBuffer = /* @__PURE__ */ new Map();
+  // PR-A: parallel metadata map (kind, timestamps). See SessionMeta jsdoc.
+  sessionMeta = /* @__PURE__ */ new Map();
+  // PR-A: sessions currently inside a sendInput→turn_complete window. Idle
+  // sweeper must skip these even if lastActivityAt looks ancient — a
+  // long-running deep-research turn would otherwise be killed mid-flight.
+  activelyExecuting = /* @__PURE__ */ new Set();
   // Sessions whose abort is in flight. Treated as not-present by hasSession /
   // isHealthy so a racing claude.execute (e.g., right after force_restart) is
   // correctly routed to the "spawn new + --resume" branch instead of trying
   // to write to a process we are about to kill.
   aborting = /* @__PURE__ */ new Set();
+  idleSweepTimer = null;
+  // PR-A: effective sweeper config. Initialized from env at construct time
+  // and overridable per-instance via startIdleSweeper(overrides) — the
+  // override path is mostly for tests (drive sweeps with sub-second TTLs)
+  // and for ops scripts that want a one-off short cycle.
+  idleTtlMs = CHAT_IDLE_TTL_MS;
+  idleSweepIntervalMs = IDLE_SWEEP_INTERVAL_MS;
+  // PR-C: checkpoint state. `checkpointPath` is null when checkpoint is
+  // disabled (no path supplied → tests, or env override later). Debouncer
+  // coalesces structural events into ≤ 1 disk write per 5s; agentStartedAt
+  // is recorded once at construction so a restart can correlate logs.
+  checkpointPath;
+  checkpointDebounceMs;
+  checkpointDebouncer = null;
+  agentStartedAt = Date.now();
+  // PR-C fixup: one-shot guard. start.ts wires recoverFromCheckpoint() into
+  // hub `onConnect`, which fires on every reconnect. After the first call the
+  // checkpoint file holds *current-run* entries owned by us — re-classifying
+  // them would falsely flag every live session as "orphan" and spam logs. The
+  // flag is intentionally process-lifetime: a new agent process gets a fresh
+  // SessionManager and re-runs recovery exactly once.
+  hasRecovered = false;
+  /**
+   * Carry-over ladder indices from the previous run's checkpoint. Populated by
+   * `recoverFromCheckpoint`, drained one-shot by `createSession`. Without this
+   * a SIGTERM right after escalating to 16k would silently revert the next
+   * spawn back to 32k and re-hit the 168k wall on its first turn.
+   */
+  recoveredLadderIndex = /* @__PURE__ */ new Map();
   adapter;
   onOutput;
   onTurnComplete;
   onSessionError;
   onSessionStarted;
   onBeforeClose;
+  // PR-A: classifies a sessionId as 'chat' or 'swarm-role'. Injected by
+  // start.ts via SwarmCoordinator.isSwarmSession to keep SessionManager
+  // independent of the swarm package. Defaults to 'chat' if absent — safe
+  // because the worst-case (mis-classify a swarm-role as chat) is bounded by
+  // activelyExecuting protection during turn execution.
+  classify;
   constructor(options) {
     this.adapter = options.adapter;
     this.onOutput = options.onOutput;
@@ -1103,13 +1723,16 @@ var SessionManager = class {
     this.onSessionError = options.onSessionError;
     this.onSessionStarted = options.onSessionStarted;
     this.onBeforeClose = options.onBeforeClose;
+    this.classify = options.classify ?? (() => "chat");
+    this.checkpointPath = options.checkpointPath ?? null;
+    this.checkpointDebounceMs = options.checkpointDebounceMs ?? 5e3;
   }
   async createSession(options) {
     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.`);
+      throw new SessionLimitReachedError(this.snapshotPoolForError());
     }
     if (options.roleId) {
       try {
@@ -1120,9 +1743,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");
+        log5.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");
+        log5.warn({ err, roleId: options.roleId }, "failed to build memory section, proceeding without");
       }
     }
     try {
@@ -1133,17 +1756,34 @@ ${options.systemPrompt}` : `${memorySection}${roleHint}`;
 [Skill \u8FDB\u5316\u63D0\u6848]
 ${notice.text}`;
         options.systemPrompt = options.systemPrompt ? `${options.systemPrompt}${noticeBlock}` : noticeBlock.trimStart();
-        log3.debug(
+        log5.debug(
           { sessionId: options.sessionId, pending: notice.count },
           "pending skill evolution notice injected"
         );
       }
     } catch (err) {
-      log3.debug({ err }, "failed to inject pending notification");
+      log5.debug({ err }, "failed to inject pending notification");
     }
     try {
       const process2 = await this.adapter.spawn(options);
       this.sessions.set(options.sessionId, process2);
+      const now = Date.now();
+      const kind = this.classify(options.sessionId);
+      const agentInstanceId = kind === "swarm-role" ? options.sessionId.split("::")[1] : void 0;
+      this.sessionMeta.set(options.sessionId, {
+        kind,
+        workDir: options.workDir ?? process2.workDir,
+        agentInstanceId,
+        startedAt: now,
+        lastActivityAt: now,
+        turnsCompleted: 0,
+        // Restore ladder index if this sessionId was carried over from the
+        // previous run's checkpoint. drain-on-read so a future re-creation of
+        // a different session with the same id starts fresh.
+        currentLadderIndex: this.recoveredLadderIndex.get(options.sessionId)
+      });
+      this.recoveredLadderIndex.delete(options.sessionId);
+      this.scheduleCheckpoint();
       this.adapter.onOutput(process2, (data) => {
         const msg = data;
         if (msg?.type === "assistant" && msg?.message?.content) {
@@ -1157,15 +1797,54 @@ ${notice.text}`;
         this.onOutput(options.sessionId, data);
       });
       this.adapter.onTurnComplete?.(process2, (info) => {
+        const meta = this.sessionMeta.get(options.sessionId);
+        if (meta) {
+          meta.lastActivityAt = Date.now();
+          meta.turnsCompleted += 1;
+        }
+        this.activelyExecuting.delete(options.sessionId);
         this.onTurnComplete(options.sessionId, info);
       });
       this.adapter.onError?.(process2, (error) => {
+        this.activelyExecuting.delete(options.sessionId);
         this.onSessionError(options.sessionId, error.message);
       });
+      this.adapter.onTokenBudgetWarning?.(process2, (info) => {
+        const meta = this.sessionMeta.get(options.sessionId);
+        if (!meta) return;
+        const currentIndex = clampLadderIndex(meta.currentLadderIndex);
+        const atFloor = currentIndex >= MAX_TOKENS_LADDER.length - 1;
+        if (atFloor) {
+          log5.warn(
+            {
+              sessionId: options.sessionId,
+              used: info.used,
+              hardLimit: info.hardLimit,
+              maxOutputTokens: info.maxOutputTokens
+            },
+            "token_budget_warning at ladder floor (8k) \u2014 cannot escalate further"
+          );
+          return;
+        }
+        const nextIndex = currentIndex + 1;
+        meta.currentLadderIndex = nextIndex;
+        log5.warn(
+          {
+            sessionId: options.sessionId,
+            used: info.used,
+            hardLimit: info.hardLimit,
+            previousMaxOutputTokens: info.maxOutputTokens,
+            nextMaxOutputTokens: MAX_TOKENS_LADDER[nextIndex],
+            ladderIndex: nextIndex
+          },
+          "token_budget_warning: escalating max_output_tokens for next spawn"
+        );
+        this.scheduleCheckpoint();
+      });
       if (this.onSessionStarted) {
         this.adapter.onSessionStarted?.(process2, (info) => {
           if (this.aborting.has(options.sessionId)) {
-            log3.debug(
+            log5.debug(
               { sessionId: options.sessionId },
               "suppressing late session_started \u2014 session is aborting"
             );
@@ -1174,14 +1853,20 @@ ${notice.text}`;
           if (this.sessions.get(options.sessionId) !== process2) {
             return;
           }
+          const meta = this.sessionMeta.get(options.sessionId);
+          if (meta) meta.claudeSessionId = info.claudeSessionId;
+          this.scheduleCheckpoint();
           this.onSessionStarted(options.sessionId, info);
         });
       }
       this.adapter.onExit?.(process2, (code) => {
         if (this.sessions.get(options.sessionId) === process2) {
           this.sessions.delete(options.sessionId);
+          this.sessionMeta.delete(options.sessionId);
+          this.activelyExecuting.delete(options.sessionId);
           this.conversationBuffer.delete(options.sessionId);
-          log3.warn({ sessionId: options.sessionId, exitCode: code }, "backend process exited unexpectedly, evicted from session map");
+          this.scheduleCheckpoint();
+          log5.warn({ sessionId: options.sessionId, exitCode: code }, "backend process exited unexpectedly, evicted from session map");
           this.onSessionError(options.sessionId, `backend process exited (code=${code ?? "null"})`);
         }
       });
@@ -1198,7 +1883,10 @@ ${notice.text}`;
       this.onSessionError(sessionId, `No active session: ${sessionId}`);
       return;
     }
-    log3.debug(
+    this.activelyExecuting.add(sessionId);
+    const meta = this.sessionMeta.get(sessionId);
+    if (meta) meta.lastActivityAt = Date.now();
+    log5.debug(
       { sessionId, ...previewFields2(input) },
       "sendInput \u2192 backend stdin"
     );
@@ -1210,6 +1898,9 @@ ${notice.text}`;
     this.aborting.add(sessionId);
     this.conversationBuffer.delete(sessionId);
     this.sessions.delete(sessionId);
+    this.sessionMeta.delete(sessionId);
+    this.activelyExecuting.delete(sessionId);
+    this.scheduleCheckpoint();
     try {
       await this.adapter.stop(process2);
     } finally {
@@ -1226,9 +1917,13 @@ ${notice.text}`;
     }
     this.conversationBuffer.delete(sessionId);
     this.sessions.delete(sessionId);
+    this.sessionMeta.delete(sessionId);
+    this.activelyExecuting.delete(sessionId);
+    this.scheduleCheckpoint();
     await this.adapter.stop(process2);
   }
   async closeAll() {
+    this.stopIdleSweeper();
     const promises = Array.from(this.sessions.entries()).map(
       async ([sessionId, process2]) => {
         const messages = this.conversationBuffer.get(sessionId);
@@ -1238,11 +1933,22 @@ ${notice.text}`;
         }
         this.conversationBuffer.delete(sessionId);
         this.sessions.delete(sessionId);
+        this.sessionMeta.delete(sessionId);
+        this.activelyExecuting.delete(sessionId);
         await this.adapter.stop(process2).catch(() => {
         });
       }
     );
     await Promise.all(promises);
+    if (this.checkpointPath) {
+      if (this.checkpointDebouncer) {
+        clearTimeout(this.checkpointDebouncer);
+        this.checkpointDebouncer = null;
+      }
+      await this.flushCheckpoint().catch(
+        (err) => log5.warn({ err }, "checkpoint: final flushCheckpoint failed")
+      );
+    }
   }
   hasSession(sessionId) {
     return this.sessions.has(sessionId) && !this.aborting.has(sessionId);
@@ -1264,16 +1970,224 @@ ${notice.text}`;
   getActiveSessionIds() {
     return Array.from(this.sessions.keys());
   }
+  /**
+   * Recommended `CLAUDE_CODE_MAX_OUTPUT_TOKENS` for the *next* spawn of this
+   * session. Returns `undefined` for unknown sessions OR sessions still at
+   * ladder index 0 — callers omit the env override in that case so the CLI
+   * picks its own default. Returning `undefined` (instead of `32_000`) keeps
+   * env composition free of redundant overrides for the common path.
+   *
+   * Used by hub-connection.spawnAndSend on every reuse / fresh-resume
+   * branch — without that wiring the ladder change in meta would be inert.
+   */
+  getRecommendedMaxOutputTokens(sessionId) {
+    const meta = this.sessionMeta.get(sessionId);
+    if (!meta) return void 0;
+    const idx = clampLadderIndex(meta.currentLadderIndex);
+    if (idx <= 0) return void 0;
+    return MAX_TOKENS_LADDER[idx];
+  }
+  // ─── PR-A: idle TTL sweeper ─────────────────────────────────────────
+  /**
+   * Start the periodic idle sweeper. Idempotent: a second call is a no-op.
+   * Disabled (no-op) when effective TTL is `<= 0` — set via env
+   * `CLAWNET_CHAT_IDLE_TTL_MS=0` or via the `ttlMs` override.
+   *
+   * The timer is `unref()`-ed so it never blocks process exit.
+   *
+   * @param overrides - test/ops hook to override env-derived defaults.
+   */
+  startIdleSweeper(overrides) {
+    if (overrides?.ttlMs !== void 0) this.idleTtlMs = overrides.ttlMs;
+    if (overrides?.intervalMs !== void 0)
+      this.idleSweepIntervalMs = overrides.intervalMs;
+    if (this.idleSweepTimer) return;
+    if (this.idleTtlMs <= 0) {
+      log5.info("idleSweeper disabled (ttlMs <= 0)");
+      return;
+    }
+    this.idleSweepTimer = setInterval(() => {
+      this.sweepIdleSessions().catch(
+        (err) => log5.warn({ err }, "idleSweeper: tick failed")
+      );
+    }, this.idleSweepIntervalMs);
+    this.idleSweepTimer.unref?.();
+    log5.info(
+      { ttlMs: this.idleTtlMs, intervalMs: this.idleSweepIntervalMs },
+      "idleSweeper started"
+    );
+  }
+  stopIdleSweeper() {
+    if (this.idleSweepTimer) {
+      clearInterval(this.idleSweepTimer);
+      this.idleSweepTimer = null;
+    }
+  }
+  /**
+   * One sweep tick. Exposed for tests (so they can drive sweeps deterministically
+   * without faking interval timers) and for ops scripts. Safe to call concurrently
+   * with normal traffic — the sweeper only ever calls closeSession, which itself
+   * is idempotent on missing IDs.
+   */
+  async sweepIdleSessions() {
+    const now = Date.now();
+    const ttl = this.idleTtlMs;
+    if (ttl <= 0) return;
+    const victims = [];
+    for (const [sid, meta] of this.sessionMeta) {
+      if (meta.kind !== "chat") continue;
+      if (this.activelyExecuting.has(sid)) continue;
+      if (this.aborting.has(sid)) continue;
+      if (now - meta.lastActivityAt < ttl) continue;
+      victims.push(sid);
+    }
+    for (const sid of victims) {
+      const idleMs = now - (this.sessionMeta.get(sid)?.lastActivityAt ?? now);
+      log5.info(
+        { sessionId: sid, idleMs, ttlMs: ttl },
+        "idleSweeper: closing idle chat session"
+      );
+      await this.closeSession(sid).catch(
+        (err) => log5.warn({ err, sessionId: sid }, "idleSweeper: closeSession failed, continuing")
+      );
+    }
+  }
+  // ─── PR-B: fail-fast saturation snapshot ────────────────────────────
+  /**
+   * Build the SessionPoolSnapshot attached to a SessionLimitReachedError.
+   *
+   * "Idle" here means "not currently executing a turn". A session whose
+   * lastActivityAt is hours old but is mid-turn (long-running deep-research)
+   * is intentionally NOT a candidate — pointing the user at it would be
+   * misleading. The selection mirrors `sweepIdleSessions` filters minus the
+   * TTL gate (since at saturation we report the LRU regardless of TTL).
+   */
+  snapshotPoolForError() {
+    const byKind = { chat: 0, "swarm-role": 0 };
+    let oldestIdleSessionId = null;
+    let oldestIdleTs = Infinity;
+    let oldestIdleKind = null;
+    const now = Date.now();
+    for (const [sid, meta] of this.sessionMeta) {
+      byKind[meta.kind]++;
+      if (this.activelyExecuting.has(sid)) continue;
+      if (this.aborting.has(sid)) continue;
+      if (meta.lastActivityAt < oldestIdleTs) {
+        oldestIdleTs = meta.lastActivityAt;
+        oldestIdleSessionId = sid;
+        oldestIdleKind = meta.kind;
+      }
+    }
+    return {
+      used: this.sessions.size,
+      max: MAX_PROCESSES,
+      byKind,
+      oldestIdleSessionId,
+      oldestIdleAgeMs: oldestIdleSessionId ? now - oldestIdleTs : null,
+      oldestIdleKind
+    };
+  }
+  // ─── PR-C: logical-state checkpoint ─────────────────────────────────
+  /**
+   * Schedule a debounced flush of the in-memory pool to the checkpoint file.
+   *
+   * Burst protection: if a debounce timer is already pending, this is a no-op
+   * — the flush captures the pool state at firing time, so all events in the
+   * 5s window are observable in the eventual snapshot. This collapses the
+   * "create + onSessionStarted + close" 3-event sequence into one disk write.
+   */
+  scheduleCheckpoint() {
+    if (!this.checkpointPath) return;
+    if (this.checkpointDebouncer) return;
+    this.checkpointDebouncer = setTimeout(() => {
+      this.checkpointDebouncer = null;
+      this.flushCheckpoint().catch(
+        (err) => log5.warn({ err }, "checkpoint: flush failed")
+      );
+    }, this.checkpointDebounceMs);
+    this.checkpointDebouncer.unref?.();
+  }
+  /**
+   * Flush the current pool to the checkpoint file via temp+rename. Public
+   * for tests and for the graceful-shutdown final-flush in `closeAll`.
+   *
+   * Sessions whose underlying BackendProcess has no `pid` (e.g., in-process
+   * mock backends) are skipped — without a pid the recovery probe can't
+   * distinguish dead from alive, and writing them in would just generate
+   * spurious session.died notifications on restart.
+   */
+  async flushCheckpoint() {
+    if (!this.checkpointPath) return;
+    const entries = [];
+    for (const [sid, meta] of this.sessionMeta) {
+      const proc = this.sessions.get(sid);
+      if (!proc) continue;
+      if (proc.pid === void 0) continue;
+      entries.push({
+        sessionId: sid,
+        kind: meta.kind,
+        workDir: meta.workDir,
+        claudeSessionId: meta.claudeSessionId,
+        agentInstanceId: meta.agentInstanceId,
+        startedAt: meta.startedAt,
+        lastActivityAt: meta.lastActivityAt,
+        pid: proc.pid,
+        currentLadderIndex: meta.currentLadderIndex
+      });
+    }
+    const data = {
+      version: 1,
+      agentStartedAt: this.agentStartedAt,
+      entries
+    };
+    await atomicWriteJson(this.checkpointPath, data);
+  }
+  /**
+   * Read the previous-run checkpoint, classify each entry as `dead` or
+   * `orphan` via pid probe, then reset the file to the current (empty)
+   * truth. Caller (start.ts) is expected to forward `dead` entries to hub
+   * via `session.died` so db's processState clears.
+   *
+   * Returns `{dead: [], orphan: []}` on first boot (no file). Throws on
+   * file-system error or JSON parse failure — start.ts catches and logs so a
+   * corrupt checkpoint does not block agent startup.
+   */
+  async recoverFromCheckpoint() {
+    if (!this.checkpointPath) return { dead: [], orphan: [] };
+    if (this.hasRecovered) return { dead: [], orphan: [] };
+    this.hasRecovered = true;
+    const file = await readCheckpoint(this.checkpointPath);
+    if (!file) return { dead: [], orphan: [] };
+    const dead = [];
+    const orphan = [];
+    for (const entry of file.entries) {
+      if (typeof entry.currentLadderIndex === "number") {
+        this.recoveredLadderIndex.set(entry.sessionId, entry.currentLadderIndex);
+      }
+      if (isPidAlive(entry.pid)) {
+        orphan.push(entry);
+        log5.warn(
+          { sessionId: entry.sessionId, pid: entry.pid },
+          "recover: pid still alive but not owned by current agent (orphan)"
+        );
+      } else {
+        dead.push(entry);
+      }
+    }
+    await this.flushCheckpoint();
+    return { dead, orphan };
+  }
 };
 
 // src/start.ts
 import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
+import { TaskStore } 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 { createLogger as createLogger4 } from "@mclawnet/logger";
-var log4 = createLogger4({ module: "brain-bridge" });
+import { createLogger as createLogger6 } from "@mclawnet/logger";
+var log6 = createLogger6({ module: "brain-bridge" });
 var BrainBridge = class {
   constructor(hub, options) {
     this.hub = hub;
@@ -1281,7 +2195,7 @@ var BrainBridge = class {
     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(
+    log6.info(
       { brainHome: this.brainHome, brainCorePath: this.brainCorePath },
       "BrainBridge initialized"
     );
@@ -1289,11 +2203,11 @@ var BrainBridge = class {
   brainHome;
   brainCorePath;
   async handleRequest(msg) {
-    log4.info({ action: msg.action, requestId: msg.requestId }, "brain request");
+    log6.info({ action: msg.action, requestId: msg.requestId }, "brain request");
     switch (msg.action) {
       case "setup_status": {
         const status = this.checkSetup();
-        log4.info({ status }, "setup_status result");
+        log6.info({ status }, "setup_status result");
         return { status };
       }
       case "get_briefing":
@@ -1301,7 +2215,7 @@ var BrainBridge = class {
       case "get_meeting_recap":
         return await this.getMeetingRecap(msg.params.recapPath);
       default:
-        log4.warn({ action: msg.action }, "unknown brain action");
+        log6.warn({ action: msg.action }, "unknown brain action");
         throw new Error(`Unknown brain action: ${msg.action}`);
     }
   }
@@ -1324,15 +2238,15 @@ var BrainBridge = class {
     const targetDate = date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const reportsDir = join3(this.brainHome, "reports", "daily");
     if (!existsSync3(reportsDir)) {
-      log4.info({ reportsDir }, "get_briefing: reports dir not found");
+      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();
     if (files.length === 0) {
-      log4.info({ targetDate }, "get_briefing: no report for date");
+      log6.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");
+    log6.info({ targetDate, file: files[0] }, "get_briefing: reading report");
     const content = readFileSync3(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);
@@ -1340,7 +2254,7 @@ var BrainBridge = class {
     const projects = this.parseProjects(content);
     const meetings = this.parseMeetings(content);
     const feed = this.parseFeed(content);
-    log4.info(
+    log6.info(
       { actions: actions.length, projects: projects.length, meetings: meetings.length, feed: feed.length },
       "get_briefing: parsed"
     );
@@ -1534,7 +2448,7 @@ var BrainBridge = class {
     }
     const fullPath = join3(this.brainHome, recapPath);
     if (!existsSync3(fullPath)) {
-      log4.warn({ fullPath }, "meeting recap file not found");
+      log6.warn({ fullPath }, "meeting recap file not found");
       return { error: "Recap file not found" };
     }
     const content = readFileSync3(fullPath, "utf-8");
@@ -1572,8 +2486,8 @@ var BrainBridge = class {
 // src/fs-bridge.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { extname, isAbsolute } from "path";
-import { createLogger as createLogger5 } from "@mclawnet/logger";
-var log5 = createLogger5({ module: "fs-bridge" });
+import { createLogger as createLogger7 } from "@mclawnet/logger";
+var log7 = createLogger7({ module: "fs-bridge" });
 var MAX_TEXT_SIZE = 5 * 1024 * 1024;
 var MIME_MAP = {
   ".ts": "text/typescript",
@@ -1611,10 +2525,10 @@ var FsBridge = class {
   constructor(hub) {
     this.hub = hub;
     this.hub.registerNamespace("fs", (msg) => this.handleRequest(msg));
-    log5.info("FsBridge initialized");
+    log7.info("FsBridge initialized");
   }
   async handleRequest(msg) {
-    log5.info({ action: msg.action, requestId: msg.requestId }, "fs request");
+    log7.info({ action: msg.action, requestId: msg.requestId }, "fs request");
     switch (msg.action) {
       case "read":
         return this.readFile(msg.params);
@@ -1650,8 +2564,37 @@ var FsBridge = class {
   }
 };
 
+// src/swarm-session-bridge.ts
+import { createLogger as createLogger8 } from "@mclawnet/logger";
+var log8 = createLogger8({ module: "agent:swarm-bridge" });
+function createSwarmAwareSessionStartedHandler(deps) {
+  return (sessionId, info) => {
+    deps.hub.send({
+      type: "claude.session_started",
+      sessionId,
+      claudeSessionId: info.claudeSessionId
+    });
+    if (deps.swarmCoordinator.isSwarmSession(sessionId)) {
+      try {
+        const ok = deps.swarmCoordinator.setRoleClaudeSessionIdBySession(
+          sessionId,
+          info.claudeSessionId
+        );
+        if (!ok) {
+          log8.debug(
+            { sessionId },
+            "session_started for swarm-shaped sessionId, but no matching role (already destroyed?)"
+          );
+        }
+      } catch (err) {
+        log8.warn({ err, sessionId }, "failed to bridge session_started into swarm");
+      }
+    }
+  };
+}
+
 // src/start.ts
-import { createLogger as createLogger6 } from "@mclawnet/logger";
+import { createLogger as createLogger9 } from "@mclawnet/logger";
 import {
   initDatabase,
   MemoryStore,
@@ -1665,15 +2608,15 @@ import {
   AccumulationScanner,
   triggerFromAccumulation
 } from "@mclawnet/skill-manager";
-var log6 = createLogger6({ module: "agent" });
+var log9 = createLogger9({ module: "agent" });
 async function startAgent(options) {
   const config = loadConfig(options.config);
   if (!config.token) {
-    log6.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
+    log9.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
     process.exit(1);
   }
-  log6.info({ backend: options.adapter.type }, "starting agent");
-  log6.info({ hubUrl: config.hubUrl }, "connecting to hub");
+  log9.info({ backend: options.adapter.type }, "starting agent");
+  log9.info({ hubUrl: config.hubUrl }, "connecting to hub");
   await initRoles();
   await initSkills();
   const hub = new HubConnection({
@@ -1681,18 +2624,34 @@ async function startAgent(options) {
     token: config.token,
     hostname: config.name,
     onConnect: (agentId) => {
-      log6.info({ agentId }, "connected to hub");
+      log9.info({ agentId }, "connected to hub");
       const skills = getSkillList();
       if (skills.length > 0) {
         hub.sendSkillList(skills);
-        log6.info({ count: skills.length }, "pushed skill list to hub");
+        log9.info({ count: skills.length }, "pushed skill list to hub");
       }
+      void sessionManager.recoverFromCheckpoint().then((report) => {
+        for (const entry of report.dead) {
+          hub.send({
+            type: "session.died",
+            sessionId: entry.sessionId,
+            reason: "agent_restart",
+            claudeSessionId: entry.claudeSessionId
+          });
+        }
+        log9.info(
+          { deadCount: report.dead.length, orphanCount: report.orphan.length },
+          "checkpoint recover: cleanup complete"
+        );
+      }).catch((err) => {
+        log9.warn({ err }, "checkpoint recover: failed (degrading to no-op)");
+      });
     },
     onDisconnect: (code, reason) => {
-      log6.info({ code, reason }, "disconnected from hub");
+      log9.info({ code, reason }, "disconnected from hub");
     },
     onError: (err) => {
-      log6.error({ err }, "hub connection error");
+      log9.error({ err }, "hub connection error");
     }
   });
   let swarmCoordinator;
@@ -1710,7 +2669,7 @@ async function startAgent(options) {
     skillStore = new SkillStore(clawnetDir);
     evolutionPipeline = new EvolutionPipeline(clawnetDir);
   } catch (err) {
-    log6.warn({ err }, "failed to init memory/skill infra; distillation disabled");
+    log9.warn({ err }, "failed to init memory/skill infra; distillation disabled");
   }
   const onBeforeClose = async (sessionId, messages) => {
     if (messages.length === 0) return;
@@ -1723,7 +2682,7 @@ async function startAgent(options) {
         embeddingService
       );
     } catch (err) {
-      log6.warn({ err, sessionId }, "distillation failed (non-fatal)");
+      log9.warn({ err, sessionId }, "distillation failed (non-fatal)");
     }
     try {
       if (!skillStore || !evolutionPipeline) return;
@@ -1745,7 +2704,7 @@ async function startAgent(options) {
         await triggerFromAccumulation(signals, evolutionPipeline);
       }
     } catch (err) {
-      log6.warn({ err, sessionId }, "accumulation scan failed (non-fatal)");
+      log9.warn({ err, sessionId }, "accumulation scan failed (non-fatal)");
     }
   };
   const sessionManager = new SessionManager({
@@ -1770,11 +2729,11 @@ async function startAgent(options) {
       });
     },
     onSessionStarted: (sessionId, info) => {
-      hub.send({
-        type: "claude.session_started",
-        sessionId,
-        claudeSessionId: info.claudeSessionId
+      const handler = createSwarmAwareSessionStartedHandler({
+        hub,
+        swarmCoordinator
       });
+      handler(sessionId, info);
     },
     onSessionError: (sessionId, error) => {
       hub.send({
@@ -1783,22 +2742,46 @@ async function startAgent(options) {
         error
       });
     },
-    onBeforeClose
+    onBeforeClose,
+    // PR-A: classify session kind for the idle sweeper. SessionManager stays
+    // independent of the swarm package; we hand it a closure that defers to
+    // SwarmCoordinator (created below) at call time. Lazy-read is safe because
+    // createSession can't run until the hub connection is up, by which point
+    // swarmCoordinator is already assigned.
+    classify: (sessionId) => swarmCoordinator?.isSwarmSession(sessionId) ? "swarm-role" : "chat",
+    // 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")
   });
-  swarmCoordinator = new SwarmCoordinator(sessionManager, hub);
+  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 });
+    } catch (err) {
+      log9.warn({ err, workDir }, "TaskStore factory failed");
+      return void 0;
+    }
+  }, process.env.CLAWNET_HOME ?? homedir3());
   hub.setSessionManager(sessionManager);
   hub.setSwarmCoordinator(swarmCoordinator);
+  const scheduleRuntime = new ScheduleRuntime({ hub, sessionManager, swarmCoordinator });
+  hub.setScheduleRuntime(scheduleRuntime);
+  await scheduleRuntime.start();
   const brainBridge = new BrainBridge(hub);
   const fsBridge = new FsBridge(hub);
+  sessionManager.startIdleSweeper();
   const shutdown = async () => {
-    log6.info("shutting down");
+    log9.info("shutting down");
     await sessionManager.closeAll();
+    await scheduleRuntime.stop();
     hub.destroy();
     if (memoryDb) {
       try {
         memoryDb.close();
       } catch (err) {
-        log6.warn({ err }, "failed to close memory db");
+        log9.warn({ err }, "failed to close memory db");
       }
     }
     process.exit(0);
@@ -1806,7 +2789,7 @@ async function startAgent(options) {
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   hub.connect();
-  return { hub, sessionManager, swarmCoordinator, brainBridge, fsBridge };
+  return { hub, sessionManager, swarmCoordinator, scheduleRuntime, brainBridge, fsBridge };
 }
 
 export {
@@ -1816,4 +2799,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-RIK7IXSW.js.map
+//# sourceMappingURL=chunk-WJWCYGLQ.js.map