@mclawnet/agent 0.6.33 → 0.6.35

package/dist/{chunk-QPLG5WHL.js → chunk-B733MQCA.js}

@@ -3,8 +3,8 @@ import {
 } from "./chunk-PJ5M6Q36.js";
 
 // src/start.ts
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 
 // src/hub-connection.ts
 import { hostname as osHostname } from "os";
@@ -168,10 +168,10 @@ async function handleListHistorySessions(workDir) {
   sessions.sort((a, b) => (b.lastModified ?? 0) - (a.lastModified ?? 0));
   return { workDir, sessions };
 }
-async function handleLoadSessionHistory(workDir, claudeSessionId, opts) {
+async function handleLoadSessionHistory(workDir, backendSessionId, opts) {
   const projectsDir = getClaudeProjectsDir();
   const projectFolder = pathToProjectFolder(workDir);
-  const filePath = join(projectsDir, projectFolder, `${claudeSessionId}.jsonl`);
+  const filePath = join(projectsDir, projectFolder, `${backendSessionId}.jsonl`);
   if (!existsSync(filePath)) {
     return { messages: [], oldestSeq: 0, hasMore: false };
   }
@@ -418,8 +418,9 @@ import { randomUUID } from "crypto";
 import { createLogger } from "@mclawnet/logger";
 import { InboxStore as InboxStore2 } from "@mclawnet/swarm";
 var log = createLogger({ module: "agent/swarm-control" });
+var MAX_ROLES_PER_SWARM = 20;
 async function handleSwarmControl(coord, msg, opts) {
-  if (!msg || msg.type !== "swarm_spawn" && msg.type !== "swarm_resume") {
+  if (!msg || msg.type !== "swarm_spawn" && msg.type !== "swarm_resume" && msg.type !== "swarm_add_role") {
     return { ok: false, error: "unknown control type" };
   }
   if (msg.type === "swarm_resume") {
@@ -433,10 +434,54 @@ async function handleSwarmControl(coord, msg, opts) {
       return { ok: false, error };
     }
   }
+  if (msg.type === "swarm_add_role") {
+    const swarm = coord.getSwarm?.(msg.swarmId);
+    if (!swarm) {
+      return { ok: false, error: `swarm ${msg.swarmId} not found` };
+    }
+    const effectiveStatus = swarm.status ?? "unknown";
+    if (effectiveStatus !== "running") {
+      return {
+        ok: false,
+        error: `swarm ${msg.swarmId} is ${effectiveStatus}, not running \u2014 add not allowed`
+      };
+    }
+    if (msg.roleName === "queen") {
+      return { ok: false, error: "cannot add a second queen to a running swarm" };
+    }
+    const roleCount = swarm.roles?.size ?? 0;
+    if (roleCount >= MAX_ROLES_PER_SWARM) {
+      return {
+        ok: false,
+        error: `member cap reached (${MAX_ROLES_PER_SWARM}) \u2014 destroy or pause some members first`
+      };
+    }
+    if (!coord.spawnRole) {
+      return { ok: false, error: "coordinator does not expose spawnRole" };
+    }
+    try {
+      const role = await coord.spawnRole(msg.swarmId, msg.roleName, {
+        backendOverride: msg.backend,
+        sandboxOverride: msg.sandbox,
+        customPrompt: msg.customPrompt,
+        taskPrompt: msg.taskPrompt,
+        isDynamicAdd: true
+      });
+      log.info(
+        { swarmId: msg.swarmId, roleName: msg.roleName, instanceId: role.instanceId },
+        "swarm_add_role: spawned"
+      );
+      return { ok: true, swarmId: msg.swarmId, instanceId: role.instanceId };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      log.error({ err, swarmId: msg.swarmId, roleName: msg.roleName }, "swarm_add_role 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 });
+    await coord.create(swarmId, { workDir, templateName: msg.teamName, displayName: msg.displayName });
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
     log.error({ err, teamName: msg.teamName }, "swarm_spawn: create failed");
@@ -698,10 +743,10 @@ var HubConnection = class {
     }
     if (msg.type === "load_session_history") {
       log2.info(
-        { workDir: msg.workDir, claudeSessionId: msg.claudeSessionId, before: msg.before, limit: msg.limit },
+        { workDir: msg.workDir, backendSessionId: msg.backendSessionId, before: msg.before, limit: msg.limit },
         "load_session_history"
       );
-      handleLoadSessionHistory(msg.workDir, msg.claudeSessionId, { before: msg.before, limit: msg.limit }).then((result) => {
+      handleLoadSessionHistory(msg.workDir, msg.backendSessionId, { before: msg.before, limit: msg.limit }).then((result) => {
         this.send({ type: "session_history_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
         log2.error({ err, workDir: msg.workDir }, "load_session_history failed");
@@ -939,6 +984,41 @@ var HubConnection = class {
       });
       return true;
     }
+    if (msg.type === "projects.swarm_add_role" && this.swarmCoordinator) {
+      const coord = this.swarmCoordinator;
+      const requestId = msg.requestId;
+      handleSwarmControl(
+        coord,
+        {
+          type: "swarm_add_role",
+          swarmId: msg.swarmId,
+          roleName: msg.roleName,
+          ...msg.backend ? { backend: msg.backend } : {},
+          ...msg.sandbox ? { sandbox: msg.sandbox } : {},
+          ...msg.customPrompt ? { customPrompt: msg.customPrompt } : {},
+          ...msg.taskPrompt ? { taskPrompt: msg.taskPrompt } : {}
+        },
+        { defaultWorkDir: process.cwd(), home: process.env.CLAWNET_HOME }
+      ).then((result) => {
+        this.send({
+          type: "projects.swarm_add_role_result",
+          requestId,
+          ok: result.ok,
+          ...result.swarmId ? { swarmId: result.swarmId } : {},
+          ...result.instanceId ? { instanceId: result.instanceId } : {},
+          ...result.error ? { error: result.error } : {}
+        });
+      }).catch((err) => {
+        log2.error({ err, swarmId: msg.swarmId }, "projects.swarm_add_role crashed");
+        this.send({
+          type: "projects.swarm_add_role_result",
+          requestId,
+          ok: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      return true;
+    }
     if (msg.type === "swarm.execute" && this.swarmCoordinator) {
       const { sessionId, content, workDir, targetInstance, crewConfig } = msg;
       if (this.swarmCoordinator.hasSwarm(sessionId)) {
@@ -955,8 +1035,9 @@ var HubConnection = class {
           this.finishedSwarms.delete(sessionId);
           const templateName = crewConfig.templateName;
           const roles = crewConfig.roles;
+          const displayName = crewConfig.displayName;
           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.swarmCoordinator.create(sessionId, { workDir, templateName, displayName, roles, task: content, isContinuation: true }).catch((err) => {
             this.send({
               type: "session.error",
               sessionId,
@@ -974,8 +1055,9 @@ var HubConnection = class {
       } else if (crewConfig?.templateName || crewConfig?.roles) {
         const templateName = crewConfig.templateName;
         const roles = crewConfig.roles;
+        const displayName = crewConfig.displayName;
         log2.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: creating new swarm");
-        this.swarmCoordinator.create(sessionId, { workDir, templateName, roles, task: content }).catch((err) => {
+        this.swarmCoordinator.create(sessionId, { workDir, templateName, displayName, roles, task: content }).catch((err) => {
           this.send({
             type: "session.error",
             sessionId,
@@ -1008,11 +1090,11 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "claude.execute") {
-      const { sessionId, content, workDir, claudeSessionId, useBrainCore } = msg;
+      const { sessionId, content, workDir, backendSessionId, useBrainCore } = msg;
       const sm = this.sessionManager;
       const spawnAndSend = (resumeId, label, maxOutputTokens) => {
         log2.info(
-          { sessionId, claudeSessionId: resumeId, workDir, label, maxOutputTokens },
+          { sessionId, backendSessionId: resumeId, workDir, label, maxOutputTokens },
           "claude.execute: spawning"
         );
         log2.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
@@ -1041,9 +1123,9 @@ var HubConnection = class {
         sm.sendUserInput(sessionId, content).catch((err) => {
           log2.warn({ err, sessionId }, "sendUserInput failed");
         });
-      } else if (sm.hasSession(sessionId) && claudeSessionId) {
+      } else if (sm.hasSession(sessionId) && backendSessionId) {
         const recommendedMax = sm.getRecommendedMaxOutputTokens(sessionId);
-        log2.warn({ sessionId, claudeSessionId }, "claude.execute: session unhealthy, recreating with --resume");
+        log2.warn({ sessionId, backendSessionId }, "claude.execute: session unhealthy, recreating with --resume");
         this.send({
           type: "session.died",
           sessionId,
@@ -1051,10 +1133,14 @@ var HubConnection = class {
         });
         sm.abortSession(sessionId).catch((err) => {
           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", sm.getRecommendedMaxOutputTokens(sessionId));
+        }).then(() => spawnAndSend(backendSessionId, "unhealthy_fallback_resume", recommendedMax));
+      } else if (backendSessionId) {
+        spawnAndSend(backendSessionId, "fresh_resume", sm.getRecommendedMaxOutputTokens(sessionId));
       } else {
+        log2.warn(
+          { sessionId, workDir },
+          "claude.execute: entering brand_new spawn path \u2014 no backendSessionId from hub; if this sessionId already has prior turns in db, upstream hub\u2192agent hydration is broken"
+        );
         spawnAndSend(void 0, "brand_new", void 0);
       }
       return true;
@@ -1086,11 +1172,11 @@ var HubConnection = class {
         workDir: msg.workDir,
         resumeId: msg.resumeId,
         roleId: DEFAULT_ASSISTANT_ROLE_ID
-      }).then((claudeSessionId) => {
+      }).then((backendSessionId) => {
         this.send({
           type: "session.created",
           sessionId: msg.sessionId,
-          claudeSessionId
+          backendSessionId
         });
       }).catch((err) => {
         this.send({
@@ -1117,6 +1203,14 @@ var HubConnection = class {
       });
       return true;
     }
+    if (msg.type === "client.permission_decision") {
+      const { sessionId, requestId, decision, reason } = msg;
+      log2.info({ sessionId, requestId, decision }, "client.permission_decision");
+      this.sessionManager.respondToPermission(sessionId, { callId: requestId, decision, reason }).catch((err) => {
+        log2.warn({ err, sessionId, requestId }, "respondToPermission failed");
+      });
+      return true;
+    }
     return false;
   }
   // ── Internal helpers ─────────────────────────────────────────────
@@ -1710,6 +1804,9 @@ function makeRealSwarmStarter(_deps) {
 
 // src/session-manager.ts
 import { createLogger as createLogger5, previewFields as previewFields2 } from "@mclawnet/logger";
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 import {
   buildMemorySection,
   EmbeddingService,
@@ -2076,6 +2173,68 @@ function isPidAlive(pid) {
   }
 }
 
+// src/normalize-backend-output.ts
+function normalizeBackendOutput(data, logger) {
+  if (data === null || typeof data !== "object") return data;
+  const d = data;
+  if (typeof d.type === "string" && d.message) return data;
+  if (typeof d.kind !== "string") return data;
+  const envelope = data;
+  switch (envelope.kind) {
+    case "assistant_text":
+      return {
+        type: "assistant",
+        message: {
+          content: [{ type: "text", text: envelope.text ?? "" }]
+        }
+      };
+    case "tool_use":
+      return {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "tool_use",
+              id: envelope.callId ?? "",
+              name: envelope.toolName ?? "",
+              input: envelope.input
+            }
+          ]
+        }
+      };
+    case "tool_result":
+      return {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: envelope.callId ?? "",
+              content: typeof envelope.output === "string" ? envelope.output : JSON.stringify(envelope.output),
+              is_error: Boolean(envelope.isError)
+            }
+          ]
+        }
+      };
+    case "system":
+      return null;
+    case "raw":
+      logger?.warn(
+        { backend: envelope.backend, payload: envelope.payload },
+        "normalize-backend-output: unmapped frame dropped"
+      );
+      return null;
+    default: {
+      const exhaustive = envelope;
+      logger?.warn(
+        { envelope: exhaustive },
+        "normalize-backend-output: unknown kind"
+      );
+      return null;
+    }
+  }
+}
+
 // src/session-manager.ts
 var sharedEmbeddingService = null;
 function getSharedEmbeddingService() {
@@ -2122,6 +2281,12 @@ var SessionManager = class {
   // handler. A leftover entry would only matter if a session id were reused,
   // which createSession already forbids (line 193 throws on duplicate).
   expectedExits = /* @__PURE__ */ new Set();
+  // Most recent adapter-emitted error per session, used to enrich the
+  // otherwise opaque "exit code=N" reason that swarm coordinator's crash
+  // inbox surfaces. Entries are auto-pruned on session exit and ignored if
+  // older than 5s (so a stale entry from a long-lived session doesn't
+  // misattribute a later unrelated exit).
+  lastSessionError = /* @__PURE__ */ new Map();
   idleSweepTimer = null;
   // PR-A: effective sweeper config. Initialized from env at construct time
   // and overridable per-instance via startIdleSweeper(overrides) — the
@@ -2152,6 +2317,23 @@ var SessionManager = class {
    */
   recoveredLadderIndex = /* @__PURE__ */ new Map();
   adapter;
+  /**
+   * Per-process adapter override. Populated by `createSession` when
+   * `options.backend` is set and `resolveAdapter` returns a non-default
+   * adapter. All adapter calls (send/stop/onOutput/...) consult
+   * `getAdapterFor(process)` instead of `this.adapter` directly.
+   */
+  processAdapters = /* @__PURE__ */ new WeakMap();
+  /**
+   * Optional resolver for per-spawn alternate backends. Wired by the agent
+   * host to `createBackendAdapter` so role.backend can pick codex/claude.
+   * When omitted, options.backend is ignored and `this.adapter` is used.
+   */
+  resolveAdapter;
+  /** Resolve the adapter that owns a particular spawned process. */
+  getAdapterFor(proc) {
+    return this.processAdapters.get(proc) ?? this.adapter;
+  }
   onOutput;
   onTurnComplete;
   onSessionError;
@@ -2165,6 +2347,7 @@ var SessionManager = class {
    * swarm-role exits to SwarmCoordinator.handleRoleCrashed.
    */
   onSessionExit;
+  onPermissionRequest;
   // 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
@@ -2173,12 +2356,14 @@ var SessionManager = class {
   classify;
   constructor(options) {
     this.adapter = options.adapter;
+    this.resolveAdapter = options.resolveAdapter;
     this.onOutput = options.onOutput;
     this.onTurnComplete = options.onTurnComplete;
     this.onSessionError = options.onSessionError;
     this.onSessionStarted = options.onSessionStarted;
     this.onBeforeClose = options.onBeforeClose;
     this.onSessionExit = options.onSessionExit;
+    this.onPermissionRequest = options.onPermissionRequest;
     this.classify = options.classify ?? (() => "chat");
     this.checkpointPath = options.checkpointPath ?? null;
     this.checkpointDebounceMs = options.checkpointDebounceMs ?? 5e3;
@@ -2234,7 +2419,37 @@ ${notice.text}`;
       options.systemPrompt = options.systemPrompt ? `${options.systemPrompt}${ideaHint}` : ideaHint.trimStart();
     }
     try {
-      const process2 = await this.adapter.spawn(options);
+      let spawnAdapter = this.adapter;
+      if (options.backend && this.resolveAdapter) {
+        const resolved = await this.resolveAdapter(options.backend);
+        log5.info(
+          {
+            sessionId: options.sessionId,
+            requested: options.backend,
+            resolvedType: resolved.type,
+            defaultType: this.adapter.type,
+            willSwitch: resolved.type !== this.adapter.type
+          },
+          "createSession: adapter resolved"
+        );
+        if (resolved.type !== this.adapter.type) {
+          spawnAdapter = resolved;
+        }
+      } else {
+        log5.info(
+          {
+            sessionId: options.sessionId,
+            requestedBackend: options.backend,
+            hasResolver: !!this.resolveAdapter,
+            defaultType: this.adapter.type
+          },
+          "createSession: using default adapter"
+        );
+      }
+      const process2 = await spawnAdapter.spawn(options);
+      if (spawnAdapter !== this.adapter) {
+        this.processAdapters.set(process2, spawnAdapter);
+      }
       this.sessions.set(options.sessionId, process2);
       const now = Date.now();
       const kind = this.classify(options.sessionId);
@@ -2253,7 +2468,9 @@ ${notice.text}`;
       });
       this.recoveredLadderIndex.delete(options.sessionId);
       this.scheduleCheckpoint();
-      this.adapter.onOutput(process2, (data) => {
+      spawnAdapter.onOutput(process2, (rawData) => {
+        const data = normalizeBackendOutput(rawData, log5);
+        if (data === null) return;
         const msg = data;
         if (msg?.type === "assistant" && msg?.message?.content) {
           const buf = this.conversationBuffer.get(options.sessionId) ?? [];
@@ -2265,7 +2482,7 @@ ${notice.text}`;
         }
         this.onOutput(options.sessionId, data);
       });
-      this.adapter.onTurnComplete?.(process2, (info) => {
+      spawnAdapter.onTurnComplete?.(process2, (info) => {
         const meta = this.sessionMeta.get(options.sessionId);
         if (meta) {
           meta.lastActivityAt = Date.now();
@@ -2274,11 +2491,12 @@ ${notice.text}`;
         this.activelyExecuting.delete(options.sessionId);
         this.onTurnComplete(options.sessionId, info);
       });
-      this.adapter.onError?.(process2, (error) => {
+      spawnAdapter.onError?.(process2, (error) => {
         this.activelyExecuting.delete(options.sessionId);
+        this.lastSessionError.set(options.sessionId, { message: error.message, ts: Date.now() });
         this.onSessionError(options.sessionId, error.message);
       });
-      this.adapter.onTokenBudgetWarning?.(process2, (info) => {
+      spawnAdapter.onTokenBudgetWarning?.(process2, (info) => {
         const meta = this.sessionMeta.get(options.sessionId);
         if (!meta) return;
         const currentIndex = clampLadderIndex(meta.currentLadderIndex);
@@ -2311,7 +2529,7 @@ ${notice.text}`;
         this.scheduleCheckpoint();
       });
       if (this.onSessionStarted) {
-        this.adapter.onSessionStarted?.(process2, (info) => {
+        spawnAdapter.onSessionStarted?.(process2, (info) => {
           if (this.aborting.has(options.sessionId)) {
             log5.debug(
               { sessionId: options.sessionId },
@@ -2323,12 +2541,49 @@ ${notice.text}`;
             return;
           }
           const meta = this.sessionMeta.get(options.sessionId);
-          if (meta) meta.claudeSessionId = info.claudeSessionId;
-          this.scheduleCheckpoint();
-          this.onSessionStarted(options.sessionId, info);
+          const sid = info.backendSessionId;
+          let sidIsTrustworthy = true;
+          const workDir = meta?.workDir;
+          const isClaudeAdapter = spawnAdapter.type === "claude-code";
+          if (isClaudeAdapter && workDir && sid) {
+            const encoded = workDir.replace(/\//g, "-");
+            const jsonlPath = join4(
+              homedir4(),
+              ".claude",
+              "projects",
+              encoded,
+              `${sid}.jsonl`
+            );
+            if (!existsSync4(jsonlPath)) {
+              log5.warn(
+                {
+                  sessionId: options.sessionId,
+                  backendSessionId: sid,
+                  jsonlPath
+                },
+                "session_started reports backendSessionId whose jsonl is missing on disk \u2014 refusing to persist to avoid ghost-sid propagation"
+              );
+              sidIsTrustworthy = false;
+            }
+          }
+          if (meta && sidIsTrustworthy) meta.backendSessionId = sid;
+          if (sidIsTrustworthy) this.scheduleCheckpoint();
+          this.onSessionStarted(options.sessionId, {
+            backendSessionId: sid
+          });
         });
       }
-      this.adapter.onExit?.(process2, (code) => {
+      if (this.onPermissionRequest) {
+        spawnAdapter.onPermissionRequest?.(process2, (req) => {
+          if (this.sessions.get(options.sessionId) !== process2) return;
+          this.onPermissionRequest(options.sessionId, req);
+        });
+      }
+      spawnAdapter.onExit?.(process2, (code) => {
+        const lastErr = this.lastSessionError.get(options.sessionId);
+        this.lastSessionError.delete(options.sessionId);
+        const enriched = lastErr && Date.now() - lastErr.ts < 5e3 ? lastErr.message : void 0;
+        const reasonText = enriched ? `exit code=${code ?? "null"} \u2014 ${enriched}` : `exit code=${code ?? "null"}`;
         if (this.sessions.get(options.sessionId) === process2) {
           const expected = this.expectedExits.delete(options.sessionId);
           this.sessions.delete(options.sessionId);
@@ -2337,7 +2592,7 @@ ${notice.text}`;
           this.conversationBuffer.delete(options.sessionId);
           this.scheduleCheckpoint();
           if (!expected) {
-            log5.warn({ sessionId: options.sessionId, exitCode: code }, "backend process exited unexpectedly, evicted from session map");
+            log5.warn({ sessionId: options.sessionId, exitCode: code, reason: enriched }, "backend process exited unexpectedly, evicted from session map");
             this.onSessionError(options.sessionId, `backend process exited (code=${code ?? "null"})`);
           } else {
             log5.debug({ sessionId: options.sessionId, exitCode: code }, "backend process exited as expected");
@@ -2346,7 +2601,7 @@ ${notice.text}`;
             this.onSessionExit?.(options.sessionId, {
               code: code ?? null,
               expected,
-              ...expected ? {} : { reason: `exit code=${code ?? "null"}` }
+              ...expected ? {} : { reason: reasonText }
             });
           } catch (err) {
             log5.warn({ err, sessionId: options.sessionId }, "onSessionExit listener threw");
@@ -2383,7 +2638,7 @@ ${notice.text}`;
       { sessionId, ...previewFields2(input) },
       "sendInput \u2192 backend stdin"
     );
-    this.adapter.send(process2, input);
+    this.getAdapterFor(process2).send(process2, input);
   }
   /**
    * User-input variant of sendInput: best-effort prepend a `<memory-context>`
@@ -2429,11 +2684,24 @@ ${content}`;
     this.activelyExecuting.delete(sessionId);
     this.scheduleCheckpoint();
     try {
-      await this.adapter.stop(process2);
+      await this.getAdapterFor(process2).stop(process2);
     } finally {
       this.aborting.delete(sessionId);
     }
   }
+  /**
+   * M3.S2b — Deliver a permission decision back to the adapter for the named
+   * session. No-ops silently when the adapter doesn't implement the optional
+   * `respondToPermission` (e.g. claude-adapter today). Throws when the session
+   * is unknown so callers don't silently lose decisions to dead sessions.
+   */
+  async respondToPermission(sessionId, decision) {
+    const process2 = this.sessions.get(sessionId);
+    if (!process2) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    await this.getAdapterFor(process2).respondToPermission?.(process2, decision);
+  }
   async closeSession(sessionId) {
     const process2 = this.sessions.get(sessionId);
     if (!process2) return;
@@ -2448,7 +2716,7 @@ ${content}`;
     this.sessionMeta.delete(sessionId);
     this.activelyExecuting.delete(sessionId);
     this.scheduleCheckpoint();
-    await this.adapter.stop(process2);
+    await this.getAdapterFor(process2).stop(process2);
   }
   async closeAll() {
     this.stopIdleSweeper();
@@ -2464,7 +2732,7 @@ ${content}`;
         this.sessions.delete(sessionId);
         this.sessionMeta.delete(sessionId);
         this.activelyExecuting.delete(sessionId);
-        await this.adapter.stop(process2).catch(() => {
+        await this.getAdapterFor(process2).stop(process2).catch(() => {
         });
       }
     );
@@ -2486,7 +2754,7 @@ ${content}`;
    * Stricter than hasSession(): also requires the underlying process to still
    * be alive (not exited, stdin still writable). Callers in the reuse path
    * must use this to avoid sending input into a dead pipe — if it returns
-   * false they should fall back to `--resume` against db's claudeSessionId.
+   * false they should fall back to `--resume` against db's backendSessionId.
    */
   isHealthy(sessionId) {
     if (this.aborting.has(sessionId)) return false;
@@ -2656,7 +2924,7 @@ ${content}`;
         sessionId: sid,
         kind: meta.kind,
         workDir: meta.workDir,
-        claudeSessionId: meta.claudeSessionId,
+        backendSessionId: meta.backendSessionId,
         agentInstanceId: meta.agentInstanceId,
         startedAt: meta.startedAt,
         lastActivityAt: meta.lastActivityAt,
@@ -2708,21 +2976,28 @@ ${content}`;
   }
 };
 
+// src/runtime-env-defaults.ts
+function ensureRuntimeEnvDefaults() {
+  if (!process.env.COPILOT_API_KEY) {
+    process.env.COPILOT_API_KEY = "dummy";
+  }
+}
+
 // src/start.ts
-import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
+import { SwarmCoordinator, initRoles, WakeupScheduler, listRecoverableSwarmIds as listRecoverableSwarmIds2 } from "@mclawnet/swarm";
 import { TaskStore as TaskStore2 } from "@mclawnet/task";
 
 // src/brain-bridge.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync4 } from "fs";
+import { join as join5 } 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 || join4(home, "BrainData");
-    this.brainCorePath = options?.brainCorePath || join4(home, ".brain", "BrainCore");
+    this.brainHome = options?.brainHomePath || process.env.BRAIN_HOME || join5(home, "BrainData");
+    this.brainCorePath = options?.brainCorePath || join5(home, ".brain", "BrainCore");
     this.hub.registerNamespace("brain", (msg) => this.handleRequest(msg));
     log6.info(
       { brainHome: this.brainHome, brainCorePath: this.brainCorePath },
@@ -2749,15 +3024,15 @@ var BrainBridge = class {
     }
   }
   checkSetup() {
-    if (!existsSync4(this.brainCorePath)) {
+    if (!existsSync5(this.brainCorePath)) {
       return "not_installed";
     }
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    const installJson = join4(home, ".brain", "install.json");
-    if (!existsSync4(installJson)) {
+    const installJson = join5(home, ".brain", "install.json");
+    if (!existsSync5(installJson)) {
       return "needs_config";
     }
-    if (!existsSync4(this.brainHome)) {
+    if (!existsSync5(this.brainHome)) {
       return "needs_config";
     }
     return "ready";
@@ -2765,8 +3040,8 @@ var BrainBridge = class {
   /** Read the most recent daily briefing report */
   async getBriefing(date) {
     const targetDate = date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const reportsDir = join4(this.brainHome, "reports", "daily");
-    if (!existsSync4(reportsDir)) {
+    const reportsDir = join5(this.brainHome, "reports", "daily");
+    if (!existsSync5(reportsDir)) {
       log6.info({ reportsDir }, "get_briefing: reports dir not found");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
@@ -2776,7 +3051,7 @@ var BrainBridge = class {
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
     log6.info({ targetDate, file: files[0] }, "get_briefing: reading report");
-    const content = readFileSync3(join4(reportsDir, files[0]), "utf-8");
+    const content = readFileSync3(join5(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);
@@ -2975,8 +3250,8 @@ var BrainBridge = class {
     if (!recapPath) {
       return { error: "No recap path provided" };
     }
-    const fullPath = join4(this.brainHome, recapPath);
-    if (!existsSync4(fullPath)) {
+    const fullPath = join5(this.brainHome, recapPath);
+    if (!existsSync5(fullPath)) {
       log6.warn({ fullPath }, "meeting recap file not found");
       return { error: "Recap file not found" };
     }
@@ -3013,7 +3288,7 @@ var BrainBridge = class {
 };
 
 // src/fs-bridge.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, 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" });
@@ -3071,7 +3346,7 @@ var FsBridge = class {
     if (!isAbsolute(filePath)) {
       throw new Error(`Access denied: only absolute paths allowed`);
     }
-    if (!existsSync5(filePath)) {
+    if (!existsSync6(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
     const stat2 = statSync2(filePath);
@@ -3093,37 +3368,124 @@ var FsBridge = class {
   }
 };
 
-// src/swarm-session-bridge.ts
+// src/templates-roles-bridge.ts
 import { createLogger as createLogger8 } from "@mclawnet/logger";
-var log8 = createLogger8({ module: "agent:swarm-bridge" });
+import {
+  listTemplatesWithSource,
+  getTemplateRaw,
+  getTemplateSource,
+  saveTemplate,
+  deleteTemplate,
+  loadTemplate as loadTemplate2,
+  listRolesWithSource,
+  getRoleRaw,
+  getRoleSource,
+  saveRole,
+  deleteRole,
+  loadRole as loadRole2
+} from "@mclawnet/swarm";
+var log8 = createLogger8({ module: "templates-roles-bridge" });
+function requireStringParam(params, key) {
+  const v = params[key];
+  if (typeof v !== "string" || !v) throw new Error(`Missing '${key}' parameter`);
+  return v;
+}
+var TemplatesRolesBridge = class {
+  constructor(hub) {
+    this.hub = hub;
+    this.hub.registerNamespace("templates", (msg) => this.handleTemplates(msg));
+    this.hub.registerNamespace("roles", (msg) => this.handleRoles(msg));
+    log8.info("TemplatesRolesBridge initialized");
+  }
+  async handleTemplates(msg) {
+    log8.info({ action: msg.action, requestId: msg.requestId }, "templates request");
+    switch (msg.action) {
+      case "list":
+        return { items: listTemplatesWithSource() };
+      case "get": {
+        const name = requireStringParam(msg.params, "name");
+        const raw = getTemplateRaw(name);
+        if (raw == null) throw new Error(`Template not found: ${name}`);
+        const parsed = loadTemplate2(name);
+        const source = getTemplateSource(name);
+        return { raw, parsed, source };
+      }
+      case "save": {
+        const name = requireStringParam(msg.params, "name");
+        const raw = requireStringParam(msg.params, "raw");
+        const source = saveTemplate(name, raw);
+        return { ok: true, source };
+      }
+      case "delete": {
+        const name = requireStringParam(msg.params, "name");
+        const r = deleteTemplate(name);
+        return { ok: true, ...r };
+      }
+      default:
+        throw new Error(`Unknown templates action: ${msg.action}`);
+    }
+  }
+  async handleRoles(msg) {
+    log8.info({ action: msg.action, requestId: msg.requestId }, "roles request");
+    switch (msg.action) {
+      case "list":
+        return { items: listRolesWithSource() };
+      case "get": {
+        const name = requireStringParam(msg.params, "name");
+        const raw = getRoleRaw(name);
+        if (raw == null) throw new Error(`Role not found: ${name}`);
+        const parsed = loadRole2(name);
+        const source = getRoleSource(name);
+        return { raw, parsed, source };
+      }
+      case "save": {
+        const name = requireStringParam(msg.params, "name");
+        const raw = requireStringParam(msg.params, "raw");
+        const source = saveRole(name, raw);
+        return { ok: true, source };
+      }
+      case "delete": {
+        const name = requireStringParam(msg.params, "name");
+        const r = deleteRole(name);
+        return { ok: true, ...r };
+      }
+      default:
+        throw new Error(`Unknown roles action: ${msg.action}`);
+    }
+  }
+};
+
+// src/swarm-session-bridge.ts
+import { createLogger as createLogger9 } from "@mclawnet/logger";
+var log9 = createLogger9({ module: "agent:swarm-bridge" });
 function createSwarmAwareSessionStartedHandler(deps) {
   return (sessionId, info) => {
     deps.hub.send({
       type: "claude.session_started",
       sessionId,
-      claudeSessionId: info.claudeSessionId
+      backendSessionId: info.backendSessionId
     });
     if (deps.swarmCoordinator.isSwarmSession(sessionId)) {
       try {
-        const ok = deps.swarmCoordinator.setRoleClaudeSessionIdBySession(
+        const ok = deps.swarmCoordinator.setRoleBackendSessionIdBySession(
           sessionId,
-          info.claudeSessionId
+          info.backendSessionId
         );
         if (!ok) {
-          log8.debug(
+          log9.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");
+        log9.warn({ err, sessionId }, "failed to bridge session_started into swarm");
       }
     }
   };
 }
 
 // src/start.ts
-import { createLogger as createLogger9 } from "@mclawnet/logger";
+import { createLogger as createLogger10 } from "@mclawnet/logger";
 import {
   initDatabase as initDatabase2,
   MemoryStore,
@@ -3139,15 +3501,16 @@ import {
   triggerFromAccumulation
 } from "@mclawnet/skill-manager";
 import { PROJECTS_RPC_CAPABILITY } from "@mclawnet/shared";
-var log9 = createLogger9({ module: "agent" });
+var log10 = createLogger10({ module: "agent" });
 async function startAgent(options) {
+  ensureRuntimeEnvDefaults();
   const config = loadConfig(options.config);
   if (!config.token) {
-    log9.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
+    log10.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
     process.exit(1);
   }
-  log9.info({ backend: options.adapter.type }, "starting agent");
-  log9.info({ hubUrl: config.hubUrl }, "connecting to hub");
+  log10.info({ backend: options.adapter.type }, "starting agent");
+  log10.info({ hubUrl: config.hubUrl }, "connecting to hub");
   await initRoles();
   await initSkills();
   const hub = new HubConnection({
@@ -3156,11 +3519,11 @@ async function startAgent(options) {
     hostname: config.name,
     capabilities: [PROJECTS_RPC_CAPABILITY],
     onConnect: (agentId) => {
-      log9.info({ agentId }, "connected to hub");
+      log10.info({ agentId }, "connected to hub");
       const skills = getSkillList();
       if (skills.length > 0) {
         hub.sendSkillList(skills);
-        log9.info({ count: skills.length }, "pushed skill list to hub");
+        log10.info({ count: skills.length }, "pushed skill list to hub");
       }
       void sessionManager.recoverFromCheckpoint().then((report) => {
         for (const entry of report.dead) {
@@ -3168,27 +3531,27 @@ async function startAgent(options) {
             type: "session.died",
             sessionId: entry.sessionId,
             reason: "agent_restart",
-            claudeSessionId: entry.claudeSessionId
+            backendSessionId: entry.backendSessionId
           });
         }
-        log9.info(
+        log10.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)");
+        log10.warn({ err }, "checkpoint recover: failed (degrading to no-op)");
       });
     },
     onDisconnect: (code, reason) => {
-      log9.info({ code, reason }, "disconnected from hub");
+      log10.info({ code, reason }, "disconnected from hub");
     },
     onError: (err) => {
-      log9.error({ err }, "hub connection error");
+      log10.error({ err }, "hub connection error");
     }
   });
   let swarmCoordinator;
-  const clawnetDir = process.env.CLAWNET_DIR ?? join5(homedir4(), ".clawnet");
-  const dbPath = process.env.CLAWNET_MEMORY_DB ?? join5(clawnetDir, "memory.db");
+  const clawnetDir = process.env.CLAWNET_DIR ?? join6(homedir5(), ".clawnet");
+  const dbPath = process.env.CLAWNET_MEMORY_DB ?? join6(clawnetDir, "memory.db");
   let memoryStore = null;
   let embeddingService = null;
   let evolutionPipeline = null;
@@ -3201,7 +3564,7 @@ async function startAgent(options) {
     skillStore = new SkillStore(clawnetDir);
     evolutionPipeline = new EvolutionPipeline(clawnetDir);
   } catch (err) {
-    log9.warn({ err }, "failed to init memory/skill infra; distillation disabled");
+    log10.warn({ err }, "failed to init memory/skill infra; distillation disabled");
   }
   const onBeforeClose = async (sessionId, messages) => {
     if (messages.length === 0) return;
@@ -3214,7 +3577,7 @@ async function startAgent(options) {
         embeddingService
       );
     } catch (err) {
-      log9.warn({ err, sessionId }, "distillation failed (non-fatal)");
+      log10.warn({ err, sessionId }, "distillation failed (non-fatal)");
     }
     try {
       if (!skillStore || !evolutionPipeline) return;
@@ -3236,11 +3599,15 @@ async function startAgent(options) {
         await triggerFromAccumulation(signals, evolutionPipeline);
       }
     } catch (err) {
-      log9.warn({ err, sessionId }, "accumulation scan failed (non-fatal)");
+      log10.warn({ err, sessionId }, "accumulation scan failed (non-fatal)");
     }
   };
   const sessionManager = new SessionManager({
     adapter: options.adapter,
+    resolveAdapter: async (kind) => {
+      const { createBackendAdapter } = await import("./backend-factory-VRPU3534.js");
+      return createBackendAdapter(kind);
+    },
     onOutput: (sessionId, data) => {
       if (swarmCoordinator.handleRoleOutput(sessionId, data)) return;
       hub.send({
@@ -3254,7 +3621,7 @@ async function startAgent(options) {
       hub.send({
         type: "claude.turn_complete",
         sessionId,
-        claudeSessionId: info.claudeSessionId,
+        backendSessionId: info.backendSessionId,
         cost: info.cost,
         duration: info.duration,
         contextUsage: info.contextUsage
@@ -3280,10 +3647,22 @@ async function startAgent(options) {
       try {
         swarmCoordinator.handleRoleCrashed(sessionId, info.reason ?? `exit code=${info.code ?? "null"}`);
       } catch (err) {
-        log9.warn({ err, sessionId }, "swarmCoordinator.handleRoleCrashed threw");
+        log10.warn({ err, sessionId }, "swarmCoordinator.handleRoleCrashed threw");
       }
     },
     onBeforeClose,
+    onPermissionRequest: (sessionId, req) => {
+      hub.send({
+        type: "agent.permission_request",
+        sessionId,
+        requestId: req.callId,
+        toolName: req.toolName,
+        args: req.input ?? {},
+        reason: req.meta?.reason,
+        backendType: req.meta?.backend,
+        meta: req.meta
+      });
+    },
     // 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
@@ -3293,28 +3672,41 @@ 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: join5(clawnetDir, "agent-sessions.json")
+    checkpointPath: join6(clawnetDir, "agent-sessions.json")
   });
   swarmCoordinator = new SwarmCoordinator(sessionManager, hub, (workDir) => {
     try {
       const env = process.env.CLAWNET_DIR;
-      const home = env ? env.replace(/\/\.clawnet\/?$/, "") : homedir4();
+      const home = env ? env.replace(/\/\.clawnet\/?$/, "") : homedir5();
       return new TaskStore2({ workDir, home });
     } catch (err) {
-      log9.warn({ err, workDir }, "TaskStore factory failed");
+      log10.warn({ err, workDir }, "TaskStore factory failed");
       return void 0;
     }
-  }, process.env.CLAWNET_HOME ?? homedir4());
+  }, process.env.CLAWNET_HOME ?? homedir5());
   hub.setSessionManager(sessionManager);
   hub.setSwarmCoordinator(swarmCoordinator);
+  const wakeupHome = process.env.CLAWNET_HOME ?? homedir5();
+  const wakeupScheduler = new WakeupScheduler(swarmCoordinator.inboxRelay);
+  try {
+    const knownSwarms = listRecoverableSwarmIds2().map(({ swarmId, workDir }) => ({
+      swarmId,
+      workDir
+    }));
+    await wakeupScheduler.restoreFromInbox(wakeupHome, knownSwarms);
+  } catch (err) {
+    log10.warn({ err }, "WakeupScheduler.restoreFromInbox failed (non-fatal)");
+  }
   const scheduleRuntime = new ScheduleRuntime({ hub, sessionManager, swarmCoordinator });
   hub.setScheduleRuntime(scheduleRuntime);
   await scheduleRuntime.start();
   const brainBridge = new BrainBridge(hub);
   const fsBridge = new FsBridge(hub);
+  const templatesRolesBridge = new TemplatesRolesBridge(hub);
   sessionManager.startIdleSweeper();
   const shutdown = async () => {
-    log9.info("shutting down");
+    log10.info("shutting down");
+    wakeupScheduler.dispose();
     await sessionManager.closeAll();
     await scheduleRuntime.stop();
     hub.destroy();
@@ -3322,7 +3714,7 @@ async function startAgent(options) {
       try {
         memoryDb.close();
       } catch (err) {
-        log9.warn({ err }, "failed to close memory db");
+        log10.warn({ err }, "failed to close memory db");
       }
     }
     process.exit(0);
@@ -3330,7 +3722,7 @@ async function startAgent(options) {
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   hub.connect();
-  return { hub, sessionManager, swarmCoordinator, scheduleRuntime, brainBridge, fsBridge };
+  return { hub, sessionManager, swarmCoordinator, scheduleRuntime, brainBridge, fsBridge, templatesRolesBridge };
 }
 
 export {
@@ -3340,4 +3732,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-QPLG5WHL.js.map
+//# sourceMappingURL=chunk-B733MQCA.js.map