abtars 0.3.4-alpha.6 → 0.3.4-alpha.8

package/bundle/abtars.js

@@ -19,10 +19,10 @@ import {
   createSkillStatsFlushTask,
   createUpdateCheckTask,
   phasePipelineDeps
-} from "./chunk-IRZOWJ5S.js";
+} from "./chunk-IHYKTDIP.js";
 import {
   loadNLMConfig
-} from "./chunk-NC72HN4Y.js";
+} from "./chunk-SMPHE3ZM.js";
 import "./chunk-63A7ZRIH.js";
 import "./chunk-OKAQICWY.js";
 import {
@@ -31,13 +31,13 @@ import {
   init_heartbeat_system,
   init_platform_detect,
   setHeartbeatInstance
-} from "./chunk-MGHNCO5V.js";
+} from "./chunk-LDUOOKQY.js";
 import {
   sendNotification
 } from "./chunk-7BSQ5UQO.js";
 import {
   phaseTransport
-} from "./chunk-7YQGRUXI.js";
+} from "./chunk-VXCETPZU.js";
 import {
   resetAllCtxStarts
 } from "./chunk-JQDJPUHM.js";
@@ -45,11 +45,8 @@ import "./chunk-ZAA7B5BN.js";
 import {
   loadAndValidateConfig
 } from "./chunk-NDCRWEEJ.js";
-import "./chunk-V3DZFJZ2.js";
+import "./chunk-CXXU3HAU.js";
 import "./chunk-5QUTMUIK.js";
-import {
-  SubagentRuntime
-} from "./chunk-Q33GFBXL.js";
 import {
   createCapabilityRegistry
 } from "./chunk-XX6BGTPO.js";
@@ -60,16 +57,17 @@ import {
 } from "./chunk-YRSMGJFP.js";
 import {
   setPeerActivityCallback
-} from "./chunk-56SV72K4.js";
-import "./chunk-AW2FTHQO.js";
+} from "./chunk-P2K2K6XL.js";
+import "./chunk-7JN2MMU7.js";
 import "./chunk-MV6CJFWR.js";
 import "./chunk-URQPDCK5.js";
 import "./chunk-VOLAZHA2.js";
-import "./chunk-PROPYS3P.js";
+import "./chunk-YPAQEQSC.js";
 import {
   init_spin,
   spin
-} from "./chunk-AO32N2VB.js";
+} from "./chunk-M3JEX6L4.js";
+import "./chunk-C7K6VZNY.js";
 import "./chunk-FRKW6LWB.js";
 import "./chunk-YWZPKBO6.js";
 import {
@@ -81,18 +79,17 @@ import {
   resetAbmindCache
 } from "./chunk-IKUZPMVA.js";
 import "./chunk-TEFZ4JA4.js";
+import "./chunk-PU5HSKWH.js";
 import {
   init_kanban_channel,
   kanban_channel_exports
-} from "./chunk-KTYGKPYM.js";
-import "./chunk-5GCLBUBS.js";
-import "./chunk-EFJVUJBE.js";
+} from "./chunk-W2R2HFOQ.js";
 import "./chunk-AFREM7FX.js";
+import "./chunk-EFJVUJBE.js";
 import {
   init_user_registry,
   loadUsers
 } from "./chunk-ZV4IWKDJ.js";
-import "./chunk-Y76VUJSF.js";
 import {
   gossip_exports,
   init_gossip
@@ -654,9 +651,209 @@ import { execFileSync } from "node:child_process";
 // src/boot/context.ts
 init_spin();
 
+// src/components/subagent-runtime.ts
+init_log_and_swallow();
+init_logger();
+import { randomBytes } from "node:crypto";
+var TAG = "runtime";
+var DEFAULT_SESSION = {
+  professor: "reuse",
+  dreamy: "fresh",
+  browsie: "fresh",
+  coding: "reuse",
+  task: "fresh"
+};
+var DEFAULT_SPAWN_TIMEOUT_MS = 6e5;
+var SubagentRuntime = class {
+  cache = /* @__PURE__ */ new Map();
+  activeSpawns = /* @__PURE__ */ new Map();
+  _registry = null;
+  _mainTransport = null;
+  _lastUsage = null;
+  /** Token usage from last complete() call. */
+  get lastUsage() {
+    return this._lastUsage;
+  }
+  _sessionManager = null;
+  _sandboxEnabled = false;
+  /** Set shared model health registry (from boot ctx). */
+  setRegistry(registry) {
+    this._registry = registry;
+  }
+  /** Set main transport reference for currentModel reads. */
+  setMainTransport(transport) {
+    this._mainTransport = transport;
+  }
+  /** Set session manager for auto-spawn sub-session creation (#510). */
+  setSessionManager(mgr) {
+    this._sessionManager = mgr;
+  }
+  /** Get session manager (may be null before boot completes). */
+  get sessionManager() {
+    return this._sessionManager;
+  }
+  /** Enable Docker sandbox for W/B/C sessions (#478). */
+  setSandboxEnabled(enabled) {
+    this._sandboxEnabled = enabled;
+  }
+  /** Send a prompt to a named agent and get the response. */
+  async complete(agent, prompt, opts) {
+    const { checkBudget, sendBudgetNotification } = await import("./budget-45QOBDWA.js");
+    const budgetCheck = checkBudget(agent);
+    if (!budgetCheck.allowed) {
+      const reason = budgetCheck.remaining.tokens <= 0 ? "token" : "call";
+      void sendBudgetNotification(agent, reason);
+      throw new Error(`Daily ${reason} budget exceeded for ${agent}. Resets at midnight.`);
+    }
+    const sessionStrategy = opts?.session ?? DEFAULT_SESSION[agent] ?? "fresh";
+    const start = Date.now();
+    const cached = this.cache.get(agent);
+    if (cached && sessionStrategy === "fresh") {
+      await cached.transport.resetSession?.(cached.sessionKey);
+      (await import("./tool-registry-7FK3OQGL.js")).resetStoreCounter();
+    }
+    const { transport, model, sessionKey } = cached ?? await this.createAgent(agent, opts?.sessionType);
+    if (opts?.timeoutMs && transport.setTimeoutOverride) {
+      transport.setTimeoutOverride(opts.timeoutMs);
+    }
+    if (opts?.maxToolRounds != null && transport.setMaxToolRoundsOverride) {
+      transport.setMaxToolRoundsOverride(opts.maxToolRounds);
+    }
+    try {
+      const response = await transport.sendPrompt(sessionKey, prompt);
+      const elapsed = Date.now() - start;
+      this._lastUsage = transport.lastUsage?.() ?? null;
+      logInfo(TAG, `${agent} complete: ${prompt.length}ch \u2192 ${response?.length ?? 0}ch (${elapsed}ms, ${model})`);
+      return response ?? "";
+    } catch (err) {
+      logWarn(TAG, `${agent} complete failed: ${err instanceof Error ? err.message : String(err)}`);
+      this.cache.delete(agent);
+      throw err;
+    } finally {
+      if (opts?.timeoutMs && transport.setTimeoutOverride) {
+        transport.setTimeoutOverride(null);
+      }
+      if (opts?.maxToolRounds != null && transport.setMaxToolRoundsOverride) {
+        transport.setMaxToolRoundsOverride(null);
+      }
+    }
+  }
+  /** Get a persistent session handle for multi-turn callers. */
+  async session(agent, key) {
+    const cacheKey = key ? `${agent}:${key}` : agent;
+    const cached = this.cache.get(cacheKey) ?? await this.createAgent(agent, void 0, cacheKey);
+    return {
+      sendPrompt: (sessionKey, prompt) => cached.transport.sendPrompt(sessionKey, prompt),
+      destroy: async () => {
+        try {
+          cached.transport.destroy();
+        } catch (err) {
+          logAndSwallow("subagent_runtime", "op", err);
+        }
+        this.cache.delete(cacheKey);
+        logInfo(TAG, `${cacheKey} session destroyed`);
+      },
+      get isReady() {
+        return cached.transport.isReady;
+      },
+      get transport() {
+        return cached.transport;
+      }
+    };
+  }
+  /** Fire-and-forget: run complete() in background, deliver result via callback. */
+  async spawn(agent, prompt, opts) {
+    const taskId = randomBytes(4).toString("hex");
+    const abort = new AbortController();
+    this.activeSpawns.set(taskId, { abort, startedAt: Date.now() });
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_SPAWN_TIMEOUT_MS;
+    const timer = setTimeout(() => abort.abort(), timeoutMs);
+    void (async () => {
+      try {
+        const result = await this.complete(agent, prompt);
+        if (!abort.signal.aborted) opts?.onComplete?.(taskId, result);
+      } catch (err) {
+        if (!abort.signal.aborted) opts?.onError?.(taskId, err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        clearTimeout(timer);
+        this.activeSpawns.delete(taskId);
+      }
+    })();
+    logInfo(TAG, `${agent} spawned: taskId=${taskId}, timeout=${timeoutMs}ms`);
+    return { taskId };
+  }
+  /** Shut down all cached transports and abort active spawns. */
+  async shutdown() {
+    for (const [id, { abort }] of this.activeSpawns) {
+      abort.abort();
+      logInfo(TAG, `spawn ${id} aborted`);
+    }
+    this.activeSpawns.clear();
+    for (const [name, cached] of this.cache) {
+      try {
+        cached.transport.destroy();
+      } catch (err) {
+        logAndSwallow("subagent_runtime", "op", err);
+      }
+      logInfo(TAG, `${name} transport closed`);
+    }
+    this.cache.clear();
+  }
+  /** Active registry: list running background spawns. */
+  listActive() {
+    return [...this.activeSpawns.entries()].map(([taskId, entry]) => ({
+      taskId,
+      startedAt: entry.startedAt ?? 0
+    }));
+  }
+  /** Interrupt a specific spawn by taskId. Returns true if found. */
+  interruptSpawn(taskId) {
+    const entry = this.activeSpawns.get(taskId);
+    if (!entry) return false;
+    entry.abort.abort();
+    this.activeSpawns.delete(taskId);
+    logInfo(TAG, `spawn ${taskId} interrupted`);
+    return true;
+  }
+  async createAgent(agent, sessionType, cacheKey) {
+    const typeMap = { browsie: "B", coding: "C", task: "T" };
+    const resolvedType = sessionType || typeMap[agent];
+    const sandboxTypes = /* @__PURE__ */ new Set(["B", "C", "W"]);
+    if (this._sandboxEnabled && resolvedType && sandboxTypes.has(resolvedType)) {
+      const { logInfo: logInfo2 } = await import("./logger-OWCSNYCA.js");
+      logInfo2("subagent", `Sandbox spawn: ${agent} (type=${resolvedType}) \u2192 Docker container`);
+    }
+    const { createSubagentTransport } = await import("./agent-registry-GHNG2PH3.js");
+    const role = AGENT_TO_ROLE[agent];
+    const mainModel = this._mainTransport && "currentModel" in this._mainTransport ? this._mainTransport.currentModel : void 0;
+    const { transport, model } = await createSubagentTransport(role, this._registry ?? void 0, mainModel);
+    if (transport.agent?.pid) {
+      import("./bridge-lock-transport-4ZH7QTJP.js").then(({ trackAcpPid }) => trackAcpPid(transport.agent.pid)).catch(() => {
+      });
+    }
+    if (resolvedType && "setSystemPrompt" in transport && typeof transport.setSystemPrompt === "function") {
+      const { buildSoulBundle } = await import("./soul-bundle-VWAVHCZ6.js");
+      const bundle = buildSoulBundle(resolvedType);
+      if (bundle) transport.setSystemPrompt(bundle);
+    }
+    const sessionKey = `system:${cacheKey ?? agent}`;
+    const entry = { transport, model, sessionKey };
+    this.cache.set(cacheKey ?? agent, entry);
+    (await import("./tool-registry-7FK3OQGL.js")).resetStoreCounter();
+    return entry;
+  }
+};
+var AGENT_TO_ROLE = {
+  professor: "task",
+  dreamy: "sleep",
+  browsie: "browse",
+  coding: "coding",
+  task: "task"
+};
+
 // src/components/service-registry.ts
 init_logger();
-var TAG = "service-registry";
+var TAG2 = "service-registry";
 function jitter(ms) {
   return Math.round(ms * (0.8 + Math.random() * 0.4));
 }
@@ -688,20 +885,20 @@ var ServiceRegistry = class {
         await instance.start();
         this.instances.set(name, instance);
         this.pending.delete(name);
-        logInfo(TAG, `Started service: ${name}${attempt > 1 ? ` (attempt ${attempt})` : ""}`);
+        logInfo(TAG2, `Started service: ${name}${attempt > 1 ? ` (attempt ${attempt})` : ""}`);
         return { ok: true };
       } catch (err) {
         lastError = err instanceof Error ? err.message : String(err);
         if (attempt < retries) {
-          logWarn(TAG, `Failed to start ${name} (attempt ${attempt}/${retries}): ${lastError} \u2014 retrying in ${delayMs / 1e3}s`);
+          logWarn(TAG2, `Failed to start ${name} (attempt ${attempt}/${retries}): ${lastError} \u2014 retrying in ${delayMs / 1e3}s`);
           await new Promise((r) => setTimeout(r, delayMs));
         } else {
           if (backgroundRetry) {
-            logWarn(TAG, `Failed to start ${name} after ${retries} attempts: ${lastError} \u2014 retrying in background`);
+            logWarn(TAG2, `Failed to start ${name} after ${retries} attempts: ${lastError} \u2014 retrying in background`);
             this.spawnBackgroundRetry(name, factory);
             return { ok: false, error: lastError, retryingInBackground: true };
           }
-          logError(TAG, `Failed to start ${name} after ${retries} attempts: ${lastError}`);
+          logError(TAG2, `Failed to start ${name} after ${retries} attempts: ${lastError}`);
           return { ok: false, error: lastError };
         }
       }
@@ -711,7 +908,7 @@ var ServiceRegistry = class {
   stop(name) {
     if (this.pending.has(name)) {
       this.cancelPending(name);
-      logInfo(TAG, `Cancelled pending retry for ${name}`);
+      logInfo(TAG2, `Cancelled pending retry for ${name}`);
       return { ok: true };
     }
     const instance = this.instances.get(name);
@@ -719,11 +916,11 @@ var ServiceRegistry = class {
     try {
       instance.stop();
       this.instances.delete(name);
-      logInfo(TAG, `Stopped service: ${name}`);
+      logInfo(TAG2, `Stopped service: ${name}`);
       return { ok: true };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      logError(TAG, `Failed to stop ${name}: ${msg}`);
+      logError(TAG2, `Failed to stop ${name}: ${msg}`);
       return { ok: false, error: msg };
     }
   }
@@ -770,7 +967,7 @@ var ServiceRegistry = class {
   scheduleNextAttempt(name, factory, state) {
     const delay = backoffDelay(state.attempt);
     state.nextAttemptAt = Date.now() + delay;
-    logDebug(TAG, `Background retry for ${name}: attempt ${state.attempt + 4} in ${Math.round(delay / 1e3)}s`);
+    logDebug(TAG2, `Background retry for ${name}: attempt ${state.attempt + 4} in ${Math.round(delay / 1e3)}s`);
     state.timer = setTimeout(async () => {
       state.timer = null;
       if (state.aborted) return;
@@ -792,12 +989,12 @@ var ServiceRegistry = class {
         if (state.aborted) return;
         this.instances.set(name, instance);
         this.pending.delete(name);
-        logInfo(TAG, `Started service: ${name} (background retry, attempt ${state.attempt + 4})`);
+        logInfo(TAG2, `Started service: ${name} (background retry, attempt ${state.attempt + 4})`);
       } catch (err) {
         if (state.aborted) return;
         state.lastError = err instanceof Error ? err.message : String(err);
         state.attempt++;
-        logWarn(TAG, `Background retry for ${name} failed (attempt ${state.attempt + 3}): ${state.lastError}`);
+        logWarn(TAG2, `Background retry for ${name} failed (attempt ${state.attempt + 3}): ${state.lastError}`);
         this.scheduleNextAttempt(name, factory, state);
       }
     }, delay);
@@ -806,7 +1003,7 @@ var ServiceRegistry = class {
 
 // src/components/conversation-buffer.ts
 init_logger();
-var TAG2 = "ConversationBuffer";
+var TAG3 = "ConversationBuffer";
 var ConversationBuffer = class {
   limit;
   history = /* @__PURE__ */ new Map();
@@ -822,7 +1019,7 @@ var ConversationBuffer = class {
     }
     entries.push({ sender, text, ts: Date.now() });
     while (entries.length > this.limit) entries.shift();
-    logDebug(TAG2, `Buffered message in ${channelKey} (size=${entries.length})`);
+    logDebug(TAG3, `Buffered message in ${channelKey} (size=${entries.length})`);
   }
   /**
    * Drain all buffered messages for a channel key, returning them as
@@ -834,7 +1031,7 @@ var ConversationBuffer = class {
     if (!entries || entries.length === 0) return "";
     const lines = entries.map((e) => `[${e.sender}]: ${e.text}`);
     this.history.delete(channelKey);
-    logDebug(TAG2, `Drained ${lines.length} entries from ${channelKey}`);
+    logDebug(TAG3, `Drained ${lines.length} entries from ${channelKey}`);
     return "--- Recent conversation context ---\n" + lines.join("\n") + "\n--- End context ---\n\n";
   }
   /** Clear the buffer for a specific channel key. */
@@ -1059,6 +1256,30 @@ async function phaseMemory(ctx) {
     await memory.initialize();
     ctx.memory = memory;
     logDebug("main", `\u{1F9E0} Memory enabled (dir=${ctx.memoryConfig.memoryDir})`);
+    const { setMemoryBackend } = await import("./tool-registry-7FK3OQGL.js");
+    const mm = ctx.memory;
+    const backend = {
+      initialize: async () => {
+      },
+      close: () => {
+      },
+      instantStore: (p) => mm.editor.instantStore(p),
+      editMemory: (p) => mm.editor.editMemory(p),
+      reclassifyMemory: (id, level, uo) => {
+        mm.editor.reclassifyMemory(id, level, uo);
+        return Promise.resolve();
+      },
+      adjustRelevance: (id, delta) => {
+        mm.editor.adjustRelevance(id, delta);
+        return Promise.resolve();
+      },
+      mergeMemories: (a, b) => mm.editor.mergeMemories(a, b),
+      cascadeDelete: (ids, uid) => mm.editor.cascadeDelete(ids, uid),
+      recall: (p) => mm.recallSearch(p),
+      rebuildFtsIndexes: () => mm.rebuildFtsIndexes()
+    };
+    setMemoryBackend(backend);
+    logInfo("main", "\u{1F9E0} In-process memory wired to tool registry (shared handle)");
     return "ran";
   } catch (err) {
     logWarn("main", `\u26A0\uFE0F Memory init failed: ${err instanceof Error ? err.message : String(err)}. Running without persistent memory.`);
@@ -1147,7 +1368,7 @@ async function phasePlatformsConnect(ctx) {
   registry.register("telegram", {
     configured: Boolean(config.telegram.botToken && config.telegram.allowedUserIds.size > 0),
     async create() {
-      const { TelegramAdapter } = await import("./telegram-adapter-SIW2DMQX.js");
+      const { TelegramAdapter } = await import("./telegram-adapter-4TX7QWKC.js");
       const adapter = new TelegramAdapter(
         { botToken: config.telegram.botToken, allowedUserIds: config.telegram.allowedUserIds, pollTimeoutS: config.telegram.pollTimeoutS },
         { pipeline: { handleInbound: (msg) => recovery.handle(msg, adapter) }, conversationBuffer: ctx.conversationBuffer, transport: null, memory: null, sessionManager: ctx.sessionManager, actionGate: ctx.actionGate }
@@ -1179,7 +1400,7 @@ async function phasePlatformsConnect(ctx) {
       if (!config.discord.appId || !isValidSnowflake(config.discord.appId)) {
         throw new Error("DISCORD_APP_ID missing or invalid \u2014 Discord disabled");
       }
-      const { DiscordAdapter } = await import("./discord-adapter-6GRRMO4M.js");
+      const { DiscordAdapter } = await import("./discord-adapter-UTXUWX3A.js");
       const adapter = new DiscordAdapter(
         { botToken: config.discord.botToken, appId: config.discord.appId, allowedUserIds: config.discord.allowedUserIds },
         { pipeline: { handleInbound: (msg) => recovery.handle(msg, adapter) }, transport: null, memory: null, conversationBuffer: ctx.conversationBuffer }
@@ -1257,13 +1478,13 @@ async function phaseCapabilities(ctx) {
   let loaded = [];
   let staticCaps;
   try {
-    ({ capabilities: staticCaps } = await import("./_registry.generated-VN2OU54H.js"));
+    ({ capabilities: staticCaps } = await import("./_registry.generated-YP5GLSG7.js"));
   } catch (err) {
     logError("capabilities", `Registry import failed: ${err instanceof Error ? err.message : String(err)}. Loading individually.`);
     staticCaps = [];
     const individualCaps = [
       { name: "hotskills", load: () => import("./hotskills-FWX4QI7V.js") },
-      { name: "browser", load: () => import("./browser-EJNS35NT.js") }
+      { name: "browser", load: () => import("./browser-D3LZV7ZK.js") }
     ];
     for (const { name, load } of individualCaps) {
       if (disabled.has(name)) continue;
@@ -1355,7 +1576,7 @@ function startInProcWatchdog(opts) {
 }
 
 // src/boot/phase-heartbeat.ts
-var TAG3 = "heartbeat";
+var TAG4 = "heartbeat";
 async function phaseHeartbeat(ctx) {
   const { init: initSkillStats } = await import("./skill-stats-JORH5DGM.js");
   initSkillStats();
@@ -1389,7 +1610,7 @@ async function phaseHeartbeat(ctx) {
   heartbeat.registerTask(createSkillStatsFlushTask());
   heartbeat.registerTask(createSkillReloadTask());
   heartbeat.registerTask(createUpdateCheckTask((msg) => {
-    import("./notification-BFSIEECG.js").then(({ sendNotification: sendNotification2 }) => sendNotification2(ctx, msg)).catch((err) => logAndSwallow(TAG3, "sendNotification update-check", err));
+    import("./notification-BFSIEECG.js").then(({ sendNotification: sendNotification2 }) => sendNotification2(ctx, msg)).catch((err) => logAndSwallow(TAG4, "sendNotification update-check", err));
   }));
   heartbeat.registerTask({
     name: "restart-check",
@@ -1401,16 +1622,12 @@ async function phaseHeartbeat(ctx) {
       }
     }
   });
-  const { spin: spin2 } = await import("./spin-IMW2MZOH.js");
+  const { spin: spin2 } = await import("./spin-E3ZDEDKT.js");
   const masterUser = loadUsers().users.find((u) => u.role === "master");
   const masterUserId = masterUser?.userId ?? "master";
   ctx.sendSystemMessage = async (prompt) => {
     try {
-      const response = await spin2.inject(masterUserId, `[SYSTEM] ${prompt}`, { deliver: true });
-      if (response) {
-        const { sendNotification: sendNotification2 } = await import("./notification-BFSIEECG.js");
-        sendNotification2(ctx, response);
-      }
+      await spin2.injectGreeting(masterUserId, `[SYSTEM] ${prompt}`);
     } catch (err) {
       logWarn("main", `System message failed: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -1423,21 +1640,29 @@ async function phaseHeartbeat(ctx) {
 // src/boot/phase-sleep.ts
 init_logger();
 async function phaseSleep(ctx) {
-  const { memoryConfig, memory, sendSystemMessage } = ctx;
+  const { memoryConfig, memory, sendSystemMessage, sessionManager } = ctx;
   if (!sendSystemMessage) {
     ctx.phaseHealth.set(phaseSleep.name, { status: "skipped", error: "no sendSystemMessage" });
     logWarn("boot", `${phaseSleep.name}: skipping \u2014 heartbeat not available`);
     return "skipped";
   }
-  const { createSleepHandle } = await import("./sleep-36XS6MHJ.js");
-  const { killWakeInhibit } = await import("./commands-BARN6XQ7.js");
+  const { createSleepHandle } = await import("./sleep-BEWAUFCL.js");
+  const { killWakeInhibit } = await import("./commands-OIISYHTD.js");
   const SLEEP_HOUR = parseInt(readEnvWithDefault("BED_TIME", "2", "bedtime hour").split(":")[0] ?? "2", 10);
-  let subagent = null;
+  let nightSessionId;
   const { getEnv: getEnv2 } = await import("./env-schema-4JXQUOH4.js");
   const runtime = {
     async complete(prompt) {
-      if (!subagent) subagent = new SubagentRuntime();
-      return subagent.complete("dreamy", prompt, { session: "reuse", timeoutMs: getEnv2().modelApiTimeoutMs * 3 });
+      const { result, sessionId } = await sessionManager.spin({
+        type: "D",
+        prompt,
+        sessionId: nightSessionId,
+        // undefined on step 1 → transient alloc; reused on steps 2+
+        timeoutMs: getEnv2().modelApiTimeoutMs * 3,
+        await: true
+      });
+      if (sessionId && !nightSessionId) nightSessionId = sessionId;
+      return result ?? "";
     }
   };
   ctx.sleepHandle = createSleepHandle({
@@ -1445,10 +1670,21 @@ async function phaseSleep(ctx) {
     sleepAuditDir: ctx.sleepAuditDir,
     memoryEnabled: memoryConfig.memoryEnabled,
     runtime,
-    onComplete: () => resetAllCtxStarts(memoryConfig.memoryDir),
+    onComplete: () => {
+      if (nightSessionId) {
+        const s = sessionManager.getSessionById(nightSessionId);
+        if (s) s.status = "ended";
+        nightSessionId = void 0;
+      }
+      resetAllCtxStarts(memoryConfig.memoryDir);
+    },
     getLastMsgTs: () => memory?.getLastMessageTimestamp(true) ?? 0,
     sendSystemMessage,
-    killWakeInhibit
+    killWakeInhibit,
+    allocateSleepSession: (name) => {
+      const s = sessionManager.allocateDreamySession(name);
+      nightSessionId = s.id;
+    }
   });
   return "ran";
 }
@@ -1620,7 +1856,7 @@ var AuthGate = class {
 
 // src/components/memory-search-controller.ts
 init_logger();
-var TAG4 = "memory-search-ctrl";
+var TAG5 = "memory-search-ctrl";
 var VALID_STAGES = /* @__PURE__ */ new Set(["Sf", "Ss", "Se", "S6"]);
 var MemorySearchController = class {
   deps;
@@ -1633,7 +1869,7 @@ var MemorySearchController = class {
       return { status: 200, body: { userIds } };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      logWarn(TAG4, `listChats failed: ${msg}`);
+      logWarn(TAG5, `listChats failed: ${msg}`);
       return { status: 500, body: { error: msg } };
     }
   }
@@ -1643,7 +1879,7 @@ var MemorySearchController = class {
       return { status: 200, body: { memories } };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      logWarn(TAG4, `listAll failed: ${msg}`);
+      logWarn(TAG5, `listAll failed: ${msg}`);
       return { status: 500, body: { error: msg } };
     }
   }
@@ -1673,7 +1909,7 @@ var MemorySearchController = class {
       return { status: 200, body: response };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      logWarn(TAG4, `search failed: ${msg}`);
+      logWarn(TAG5, `search failed: ${msg}`);
       return { status: 500, body: { error: msg } };
     }
   }
@@ -1809,7 +2045,7 @@ var StatusBroadcaster = class {
 
 // src/components/dashboard/dashboard-server.ts
 init_logger();
-var TAG5 = "dashboard-server";
+var TAG6 = "dashboard-server";
 var DashboardServer = class {
   deps;
   _broadcaster;
@@ -1841,7 +2077,7 @@ var DashboardServer = class {
         reject(err);
       });
       this.server.listen(config.webPort, config.webHost, () => {
-        logInfo(TAG5, `Dashboard listening on ${config.webHost}:${config.webPort}`);
+        logInfo(TAG6, `Dashboard listening on ${config.webHost}:${config.webPort}`);
         resolve3();
       });
     });
@@ -2025,25 +2261,25 @@ var DashboardServer = class {
     }
     const token = this.deps.authGate.extractToken(req);
     if (!token || !this.deps.authGate.validate(token)) {
-      logInfo(TAG5, `WebSocket auth failed (token ${token ? "provided but invalid" : "missing"}) from ${req.socket.remoteAddress}`);
+      logInfo(TAG6, `WebSocket auth failed (token ${token ? "provided but invalid" : "missing"}) from ${req.socket.remoteAddress}`);
       socket.write(
         "HTTP/1.1 401 Unauthorized\r\nContent-Type: application/json\r\n\r\n" + JSON.stringify({ error: "Unauthorized" })
       );
       socket.destroy();
       return;
     }
-    logInfo(TAG5, `WebSocket client authenticated from ${req.socket.remoteAddress}`);
+    logInfo(TAG6, `WebSocket client authenticated from ${req.socket.remoteAddress}`);
     this.wss.handleUpgrade(req, socket, head, (ws) => {
       this.wss.emit("connection", ws, req);
       this._broadcaster.addClient(ws);
-      logInfo(TAG5, "WebSocket client connected");
+      logInfo(TAG6, "WebSocket client connected");
     });
   }
   // ── Helpers ───────────────────────────────────────────────────────────
   /** Send an error response, logging the error. */
   sendError(res, status, err) {
     const message = err instanceof Error ? err.message : String(err);
-    logError(TAG5, `Request error: ${message}`);
+    logError(TAG6, `Request error: ${message}`);
     if (!res.headersSent) {
       res.writeHead(status, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: message }));
@@ -2095,7 +2331,7 @@ function loadAgentApiConfig(env) {
 }
 
 // src/boot/phase-dashboard.ts
-var TAG6 = "dashboard";
+var TAG7 = "dashboard";
 async function phaseDashboard(ctx) {
   const { platforms, memory, transport, registry, heartbeat, nlmConfig } = ctx;
   if (!platforms.web) return "skipped";
@@ -2106,9 +2342,9 @@ async function phaseDashboard(ctx) {
   }
   const dashConfig = loadDashboardConfig(process.env);
   if (!dashConfig.webAuthToken) {
-    const { randomBytes } = await import("node:crypto");
+    const { randomBytes: randomBytes2 } = await import("node:crypto");
     const { readFile, writeFile } = await import("node:fs/promises");
-    const token = randomBytes(32).toString("hex");
+    const token = randomBytes2(32).toString("hex");
     dashConfig.webAuthToken = token;
     process.env["WEB_AUTH"] = token;
     const envPath = join5(process.cwd(), "config", ".env");
@@ -2133,7 +2369,7 @@ WEB_AUTH=${token}
     try {
       return loadAgentApiConfig(process.env);
     } catch (err) {
-      logAndSwallow(TAG6, "loadAgentApiConfig", err);
+      logAndSwallow(TAG7, "loadAgentApiConfig", err);
       return null;
     }
   })() : null;
@@ -2215,11 +2451,11 @@ WEB_AUTH=${token}
     }
   }
   if (!bound) {
-    logWarn(TAG6, `All ports ${basePort}-${basePort + 10} in use \u2014 dashboard disabled`);
+    logWarn(TAG7, `All ports ${basePort}-${basePort + 10} in use \u2014 dashboard disabled`);
     return "skipped";
   }
   ctx.dashboardServer = dashboardServer;
-  if (dashConfig.webPort !== basePort) logWarn(TAG6, `Port ${basePort} in use \u2014 dashboard bound to :${dashConfig.webPort}`);
+  if (dashConfig.webPort !== basePort) logWarn(TAG7, `Port ${basePort} in use \u2014 dashboard bound to :${dashConfig.webPort}`);
   logInfo("main", `Web dashboard on ${dashConfig.webHost}:${dashConfig.webPort}${customModule ? ` (custom: ${customModule})` : ""}`);
   return "ran";
 }
@@ -2271,7 +2507,7 @@ function bufferedStreamBody(content, opts) {
 
 // src/components/openai-compat-routes.ts
 init_logger();
-var TAG7 = "openai-compat";
+var TAG8 = "openai-compat";
 function handleModels() {
   return {
     status: 200,
@@ -2355,7 +2591,7 @@ async function handleChatCompletions(rawBody, req, deps) {
   const stream = body.stream === true;
   const model = body.model;
   if (body.tools || body.tool_choice) {
-    logDebug(TAG7, `tools[]/tool_choice present in request \u2014 ignored in v1`);
+    logDebug(TAG8, `tools[]/tool_choice present in request \u2014 ignored in v1`);
   }
   const flat = flattenMessages(messages);
   for (let i = 0; i < flat.allContents.length; i++) {
@@ -2364,7 +2600,7 @@ async function handleChatCompletions(rawBody, req, deps) {
     const scan = abmind().scanForInjection(content);
     if (!scan.safe) {
       const top = scan.flags[0];
-      logWarn(TAG7, `BLOCKED /v1/chat/completions \u2014 injection in messages[${i}]: ${top.category} (score=${scan.score}) from guest=${deps.guestName}`);
+      logWarn(TAG8, `BLOCKED /v1/chat/completions \u2014 injection in messages[${i}]: ${top.category} (score=${scan.score}) from guest=${deps.guestName}`);
       const refusal = buildChatResponse({
         model,
         content: "I can't process that request \u2014 it triggered the injection guard. Please rephrase."
@@ -2394,8 +2630,19 @@ ${fullPrompt}`;
   const effectiveSessionKey = isPeer ? `${Math.floor(Date.now() / 1e3)}_P_01` : sessionKey;
   const now = Date.now();
   if (!isPeer) deps.memory?.recordMessage({ role: "user", content: flat.prompt, timestamp: now, userId: "master", sessionId: effectiveSessionKey });
-  logInfo(TAG7, `/v1/chat/completions guest=${deps.guestName} session=${effectiveSessionKey} promptLen=${flat.prompt.length} stream=${stream}`);
-  const reply = await deps.session.sendPrompt(effectiveSessionKey, fullPrompt);
+  logInfo(TAG8, `/v1/chat/completions guest=${deps.guestName} session=${effectiveSessionKey} promptLen=${flat.prompt.length} stream=${stream}`);
+  let reply;
+  if (deps.sessionManager) {
+    const r = await deps.sessionManager.spin({
+      type: "A",
+      sessionId: effectiveSessionKey,
+      prompt: fullPrompt,
+      await: true
+    });
+    reply = r.result ?? "";
+  } else {
+    reply = await deps.session.sendPrompt(effectiveSessionKey, fullPrompt);
+  }
   if (!isPeer) deps.memory?.recordMessage({ role: "assistant", content: reply, timestamp: Date.now(), userId: "master", sessionId: effectiveSessionKey });
   if (stream) {
     return {
@@ -2431,7 +2678,7 @@ function writeResult(res, result) {
 }
 
 // src/components/agent-api-server.ts
-var TAG8 = "agent-api";
+var TAG9 = "agent-api";
 var MAX_TRAFFIC_LOG = 50;
 var IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
 function normalizeIp(raw) {
@@ -2468,6 +2715,7 @@ var AgentApiServer = class {
   agentSession = null;
   idleTimer = null;
   runtime;
+  sessionManager;
   guestName = "GUEST";
   onPeerActivity;
   tlsEnabled = false;
@@ -2479,6 +2727,7 @@ var AgentApiServer = class {
     this.workingDir = deps.workingDir;
     this.memory = deps.memory;
     this.runtime = deps.runtime;
+    this.sessionManager = deps.sessionManager;
     this.onPeerActivity = deps.onPeerActivity;
     this.a2aAdapter = deps.a2aAdapter;
     const configDir = join6(abtarsHome(), "config");
@@ -2494,12 +2743,12 @@ var AgentApiServer = class {
         }, (req, res) => this.handle(req, res));
         hasTls = true;
         this.tlsEnabled = true;
-        logInfo(TAG8, "TLS 1.3 enabled for agent-api (self-signed cert)");
+        logInfo(TAG9, "TLS 1.3 enabled for agent-api (self-signed cert)");
       } catch (err) {
-        logAndSwallow(TAG8, "TLS setup", err);
+        logAndSwallow(TAG9, "TLS setup", err);
       }
     } else {
-      logWarn(TAG8, "identity.crt/identity.tls.key not found \u2014 agent-api starting without TLS (plain HTTP)");
+      logWarn(TAG9, "identity.crt/identity.tls.key not found \u2014 agent-api starting without TLS (plain HTTP)");
     }
     if (!hasTls) {
       this.server = createServer2((req, res) => this.handle(req, res));
@@ -2523,7 +2772,7 @@ var AgentApiServer = class {
         }
       }
     } catch (err) {
-      logAndSwallow(TAG8, "load agentRules", err);
+      logAndSwallow(TAG9, "load agentRules", err);
       this.agentRules = "";
     }
   }
@@ -2550,10 +2799,10 @@ var AgentApiServer = class {
             if (result.ok) {
               this.peerWss.handleUpgrade(req, socket, head, (ws) => {
                 this.peerWsConnections.set(name, ws);
-                logInfo(TAG8, `Peer WS connected: ${name}`);
+                logInfo(TAG9, `Peer WS connected: ${name}`);
                 ws.on("close", () => {
                   this.peerWsConnections.delete(name);
-                  logInfo(TAG8, `Peer WS disconnected: ${name}`);
+                  logInfo(TAG9, `Peer WS disconnected: ${name}`);
                 });
                 ws.on("error", () => {
                   this.peerWsConnections.delete(name);
@@ -2600,7 +2849,7 @@ var AgentApiServer = class {
     try {
       const msg = JSON.parse(raw);
       if (msg.type === "request") {
-        this.handlePeerWsRequest(peerName, msg).catch((err) => logAndSwallow(TAG8, "ws-request", err));
+        this.handlePeerWsRequest(peerName, msg).catch((err) => logAndSwallow(TAG9, "ws-request", err));
       }
     } catch {
     }
@@ -2610,7 +2859,7 @@ var AgentApiServer = class {
     if (!ws || ws.readyState !== ws.OPEN) return;
     let result = { error: "unknown method" };
     if (msg.method === "delegate") {
-      const { spin: spin2 } = await import("./spin-IMW2MZOH.js");
+      const { spin: spin2 } = await import("./spin-E3ZDEDKT.js");
       const p = msg.payload;
       const { cardId } = spin2.dispatch({ type: "W", goal: p.goal, title: p.goal.slice(0, 60), source: "peer", priority: p.priority ?? "MEDIUM" });
       result = { ok: true, taskId: cardId };
@@ -2641,7 +2890,7 @@ var AgentApiServer = class {
       this.idleTimer = null;
     }
     if (!this.agentSession) return;
-    logInfo(TAG8, "A2A idle timeout \u2014 saving transcript, closing log, killing session");
+    logInfo(TAG9, "A2A idle timeout \u2014 saving transcript, closing log, killing session");
     try {
       const today = localDate();
       const dir = join6(this.workingDir, "memory", "working", today);
@@ -2649,9 +2898,9 @@ var AgentApiServer = class {
       const dest = join6(dir, "transcript_a2a.log");
       const transcript = this.agentSession.getMessages?.()?.map((m) => `[${m.role}] ${m.content}`).join("\n") ?? "";
       writeFileSync3(dest, transcript, "utf-8");
-      logInfo(TAG8, `A2A transcript saved to ${dest}`);
+      logInfo(TAG9, `A2A transcript saved to ${dest}`);
     } catch (e) {
-      logWarn(TAG8, `A2A transcript save failed: ${e}`);
+      logWarn(TAG9, `A2A transcript save failed: ${e}`);
     }
     this.log("SYSTEM", "Idle timeout \u2014 session closed");
     await this.agentSession.destroy();
@@ -2713,7 +2962,7 @@ var AgentApiServer = class {
       if (caller === null) return;
       this.guestName = caller;
       this.handleV1ChatCompletions(req, res, caller).catch((err) => {
-        logWarn(TAG8, `/v1/chat/completions error: ${err instanceof Error ? err.message : String(err)}`);
+        logWarn(TAG9, `/v1/chat/completions error: ${err instanceof Error ? err.message : String(err)}`);
         if (!res.headersSent) {
           res.writeHead(500, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Internal server error", "server_error")));
         }
@@ -2723,7 +2972,7 @@ var AgentApiServer = class {
     if (url === "/v1/embeddings" && method === "POST") {
       if (this.requireBearer(req, res) === null) return;
       this.handleV1Embeddings(req, res).catch((err) => {
-        logWarn(TAG8, `/v1/embeddings error: ${err instanceof Error ? err.message : String(err)}`);
+        logWarn(TAG9, `/v1/embeddings error: ${err instanceof Error ? err.message : String(err)}`);
         if (!res.headersSent) {
           res.writeHead(500, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Internal server error", "server_error")));
         }
@@ -2734,7 +2983,7 @@ var AgentApiServer = class {
       const caller = this.requireBearerRateLimited(req, res);
       if (caller === null) return;
       this.handleV1Tasks(req, res, caller).catch((err) => {
-        logWarn(TAG8, `/v1/tasks error: ${err instanceof Error ? err.message : String(err)}`);
+        logWarn(TAG9, `/v1/tasks error: ${err instanceof Error ? err.message : String(err)}`);
         if (!res.headersSent) {
           res.writeHead(500, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Internal server error", "server_error")));
         }
@@ -2777,7 +3026,7 @@ var AgentApiServer = class {
   }
   async handleOrcRoute(url, method, req, res) {
     try {
-      const { getOrcTools } = await import("./orc-tools-A3G7WCSJ.js");
+      const { getOrcTools } = await import("./orc-tools-TOD4WHTM.js");
       if (url === "/v1/orc/spawn" && method === "POST") {
         const body = JSON.parse(await readBody(req));
         const tool = getOrcTools().find((t) => t.name === "spawn_worker");
@@ -2805,7 +3054,7 @@ var AgentApiServer = class {
           res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({ ok: false, error: "peer and goal required" }));
           return;
         }
-        const { getPeerTransport } = await import("./peer-transport-I6JPLFZ2.js");
+        const { getPeerTransport } = await import("./peer-transport-5VKK2I7P.js");
         const transport = getPeerTransport();
         const remoteId = await transport.delegateTask(peer, goal, { priority: "MEDIUM", context: title });
         res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ ok: true, result: `Delegated to ${peer} \u2014 remote card #${remoteId}` }));
@@ -2832,13 +3081,13 @@ var AgentApiServer = class {
     for (const [name, peer] of Object.entries(config.peers)) {
       const result = verifyJwt(token, peer.token, config.self.name);
       if (result.ok && result.payload.iss === name) {
-        logInfo(TAG8, `PEER_CALL iss=${result.payload.iss} aud=${result.payload.aud} verified`);
+        logInfo(TAG9, `PEER_CALL iss=${result.payload.iss} aud=${result.payload.aud} verified`);
         return result.payload.iss;
       }
     }
     for (const [name, peer] of Object.entries(config.peers)) {
       if (token === peer.token) {
-        logInfo(TAG8, `PEER_CALL caller=${name} (raw token, no JWT)`);
+        logInfo(TAG9, `PEER_CALL caller=${name} (raw token, no JWT)`);
         return name;
       }
     }
@@ -2871,7 +3120,7 @@ var AgentApiServer = class {
     if (!limit.allowed) {
       const retryAfter = Math.ceil((limit.retryAfterMs ?? 6e4) / 1e3);
       res.writeHead(429, { "Retry-After": String(retryAfter), "Content-Type": "application/json" }).end(JSON.stringify(openaiError(`Rate limit exceeded for ${caller}`, "rate_limit_error", "rate_limit")));
-      logWarn(TAG8, `Rate limited ${caller} \u2014 retry in ${retryAfter}s`);
+      logWarn(TAG9, `Rate limited ${caller} \u2014 retry in ${retryAfter}s`);
       return;
     }
     const { setCurrentPeerHops } = await import("./peer-client-RGEU5HOK.js");
@@ -2880,7 +3129,7 @@ var AgentApiServer = class {
     try {
       body = JSON.parse(await readBody(req));
     } catch (err) {
-      logAndSwallow(TAG8, "JSON.parse chat completions body", err);
+      logAndSwallow(TAG9, "JSON.parse chat completions body", err);
       res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Invalid JSON body", "invalid_request_error", "invalid_body")));
       setCurrentPeerHops(null);
       return;
@@ -2899,14 +3148,14 @@ var AgentApiServer = class {
         commsType = result2.valid ? "signed" : "sig-invalid";
         if (result2.valid) lastMsg.content = result2.text;
       } else if (peerEntry2?.mode === "signed" && !hasSigTag) {
-        logWarn(TAG8, `Rejected unsigned message from ${caller} (mode=signed)`);
+        logWarn(TAG9, `Rejected unsigned message from ${caller} (mode=signed)`);
         res.writeHead(403, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Signature required", "authentication_error", "signature_missing")));
         setCurrentPeerHops(null);
         this.onPeerActivity?.(`\u{1F916} Agents: ${caller} \u2192 ${this.config.agentCodename} [rejected \u26A0\uFE0F no signature]`);
         return;
       }
       if (commsType === "sig-invalid" && peerEntry2?.mode === "signed") {
-        logWarn(TAG8, `Rejected invalid signature from ${caller}`);
+        logWarn(TAG9, `Rejected invalid signature from ${caller}`);
         res.writeHead(403, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Invalid signature", "authentication_error", "signature_invalid")));
         setCurrentPeerHops(null);
         this.onPeerActivity?.(`\u{1F916} Agents: ${caller} \u2192 ${this.config.agentCodename} [rejected \u26A0\uFE0F invalid sig]`);
@@ -2914,7 +3163,7 @@ var AgentApiServer = class {
       }
     }
     if (lastMsg?.content && /\[NO-REPLY\]/i.test(lastMsg.content)) {
-      logInfo(TAG8, `Peer ${caller} sent [NO_REPLY] \u2014 returning empty completion`);
+      logInfo(TAG9, `Peer ${caller} sent [NO_REPLY] \u2014 returning empty completion`);
       res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ id: "no-reply", object: "chat.completion", choices: [{ index: 0, message: { role: "assistant", content: "" }, finish_reason: "stop" }] }));
       setCurrentPeerHops(null);
       return;
@@ -2923,7 +3172,7 @@ var AgentApiServer = class {
       const { hasPending, popPendingPrompt } = await import("./pending-callback-NHFHL2JC.js");
       if (hasPending(caller)) {
         const pendingPrompt = popPendingPrompt(caller);
-        logInfo(TAG8, `Callback from ${caller} \u2014 returning pending prompt (${pendingPrompt?.length ?? 0} chars)`);
+        logInfo(TAG9, `Callback from ${caller} \u2014 returning pending prompt (${pendingPrompt?.length ?? 0} chars)`);
         res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ id: "cb", object: "chat.completion", choices: [{ index: 0, message: { role: "assistant", content: pendingPrompt ?? "" }, finish_reason: "stop" }] }));
         setCurrentPeerHops(null);
         return;
@@ -2933,13 +3182,13 @@ var AgentApiServer = class {
       const { resolvePending } = await import("./pending-callback-NHFHL2JC.js");
       const answer = lastMsg.content.slice("[CB-RESPONSE]".length).trim();
       if (resolvePending(caller, answer)) {
-        logInfo(TAG8, `CB-RESPONSE from ${caller} \u2014 resolved pending (${answer.length} chars)`);
+        logInfo(TAG9, `CB-RESPONSE from ${caller} \u2014 resolved pending (${answer.length} chars)`);
       }
       res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ id: "cb-ack", object: "chat.completion", choices: [{ index: 0, message: { role: "assistant", content: "" }, finish_reason: "stop" }] }));
       setCurrentPeerHops(null);
       return;
     }
-    logInfo(TAG8, `Peer call: ${caller} \u2192 ${this.config.agentCodename} [${commsType}]`);
+    logInfo(TAG9, `Peer call: ${caller} \u2192 ${this.config.agentCodename} [${commsType}]`);
     const secLabel = `${this.tlsEnabled ? "tls" : "http"}+${commsType === "signed" ? "signed" : "jwt"}`;
     this.onPeerActivity?.(`\u{1F916} Agents: ${caller} \u2192 ${this.config.agentCodename} [${secLabel}]`);
     const { loadPeerConfig } = await import("./peer-config-TN55LFDC.js");
@@ -2979,7 +3228,7 @@ var AgentApiServer = class {
     try {
       session = await this.ensureAgentSession();
     } catch (err) {
-      logAndSwallow(TAG8, "ensureAgentSession", err);
+      logAndSwallow(TAG9, "ensureAgentSession", err);
       res.writeHead(503, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Failed to spawn agent kiro-cli", "server_error", "spawn_failed")));
       setCurrentPeerHops(null);
       return;
@@ -2995,7 +3244,8 @@ var AgentApiServer = class {
       markRulesInjected: () => {
         this.rulesInjected = true;
       },
-      guestName: this.guestName
+      guestName: this.guestName,
+      sessionManager: this.sessionManager
     });
     const reqBody = body;
     const promptPreview = Array.isArray(reqBody.messages) && reqBody.messages.length > 0 ? String(reqBody.messages[reqBody.messages.length - 1]?.content ?? "").slice(0, 200) : "";
@@ -3018,7 +3268,7 @@ var AgentApiServer = class {
     try {
       body = JSON.parse(await readBody(req));
     } catch (err) {
-      logAndSwallow(TAG8, "JSON.parse embeddings body", err);
+      logAndSwallow(TAG9, "JSON.parse embeddings body", err);
       res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Invalid JSON body", "invalid_request_error", "invalid_body")));
       return;
     }
@@ -3031,7 +3281,7 @@ var AgentApiServer = class {
     try {
       body = JSON.parse(await readBody(req));
     } catch (err) {
-      logAndSwallow(TAG8, "JSON.parse tasks body", err);
+      logAndSwallow(TAG9, "JSON.parse tasks body", err);
       res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Invalid JSON body", "invalid_request_error", "invalid_body")));
       return;
     }
@@ -3040,7 +3290,7 @@ var AgentApiServer = class {
       res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Missing 'goal' field", "invalid_request_error", "missing_field")));
       return;
     }
-    const { spin: spin2 } = await import("./spin-IMW2MZOH.js");
+    const { spin: spin2 } = await import("./spin-E3ZDEDKT.js");
     const { cardId, sessionId } = spin2.dispatch({
       type: "O",
       goal: body.context ? `${goal}
@@ -3060,10 +3310,10 @@ Context: ${body.context}` : goal,
         const safeName = bn(art.name);
         writeFileSync3(join6(dir, safeName), Buffer.from(art.content, "base64"));
       }
-      logDebug(TAG8, `Wrote ${body.artifacts.length} artifact(s) to card#${cardId} workspace`);
+      logDebug(TAG9, `Wrote ${body.artifacts.length} artifact(s) to card#${cardId} workspace`);
     }
-    logInfo(TAG8, `A2A task from ${caller}: card #${cardId} "${goal.slice(0, 60)}"${body.callback_peer ? ` (callback\u2192${body.callback_peer})` : ""}`);
-    logTrace(TAG8, `A2A task from ${caller} full goal: ${goal.slice(0, 500)}`);
+    logInfo(TAG9, `A2A task from ${caller}: card #${cardId} "${goal.slice(0, 60)}"${body.callback_peer ? ` (callback\u2192${body.callback_peer})` : ""}`);
+    logTrace(TAG9, `A2A task from ${caller} full goal: ${goal.slice(0, 500)}`);
     this.onPeerActivity?.(`\u{1F4CB} A2A task from ${caller}: "${goal.slice(0, 60)}" \u2192 card #${cardId}`);
     this.pushTraffic({
       ts: Date.now(),
@@ -3144,8 +3394,8 @@ Context: ${body.context}` : goal,
       res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("Missing task_id or status", "invalid_request_error", "missing_field")));
       return;
     }
-    logDebug(TAG8, `\u2190 callback from ${caller}: task_id=${taskId} status=${body.status}`);
-    logTrace(TAG8, `\u2190 callback from ${caller} result: ${(body.result_summary ?? "").slice(0, 300)}`);
+    logDebug(TAG9, `\u2190 callback from ${caller}: task_id=${taskId} status=${body.status}`);
+    logTrace(TAG9, `\u2190 callback from ${caller} result: ${(body.result_summary ?? "").slice(0, 300)}`);
     const { kanbanList, kanbanComplete, kanbanFail } = (init_kanban_board(), __toCommonJS(kanban_board_exports));
     const remoteCards = kanbanList("running", "status").filter((c) => {
       if (c.type !== "remote") return false;
@@ -3157,7 +3407,7 @@ Context: ${body.context}` : goal,
       }
     });
     if (remoteCards.length === 0) {
-      logWarn(TAG8, `Callback from ${caller} for task_id=${taskId} \u2014 no matching local card`);
+      logWarn(TAG9, `Callback from ${caller} for task_id=${taskId} \u2014 no matching local card`);
       res.writeHead(404, { "Content-Type": "application/json" }).end(JSON.stringify(openaiError("No matching local card", "not_found_error", "not_found")));
       return;
     }
@@ -3170,21 +3420,21 @@ Context: ${body.context}` : goal,
         const safeName = bn(art.name);
         writeFileSync3(join6(dir, safeName), Buffer.from(art.content, "base64"));
       }
-      logDebug(TAG8, `Wrote ${body.artifacts.length} result artifact(s) to local card#${card.id}`);
+      logDebug(TAG9, `Wrote ${body.artifacts.length} result artifact(s) to local card#${card.id}`);
     }
     if (body.status === "done") {
       kanbanComplete(card.id, null, body.result_summary?.slice(0, 500) ?? "completed");
-      logInfo(TAG8, `PEER_CALLBACK ${caller}#${taskId} \u2192 local#${card.id} done (${(body.result_summary ?? "").length}ch)`);
+      logInfo(TAG9, `PEER_CALLBACK ${caller}#${taskId} \u2192 local#${card.id} done (${(body.result_summary ?? "").length}ch)`);
     } else {
       kanbanFail(card.id, body.error ?? "remote task failed");
-      logInfo(TAG8, `PEER_CALLBACK ${caller}#${taskId} \u2192 local#${card.id} failed: ${(body.error ?? "").slice(0, 100)}`);
+      logInfo(TAG9, `PEER_CALLBACK ${caller}#${taskId} \u2192 local#${card.id} failed: ${(body.error ?? "").slice(0, 100)}`);
     }
     if (body.tokens_used && typeof body.tokens_used === "number") {
       const { kanbanAddTokens } = (init_kanban_board(), __toCommonJS(kanban_board_exports));
       kanbanAddTokens(card.id, body.tokens_used);
     }
     try {
-      const { spin: spin2 } = await import("./spin-IMW2MZOH.js");
+      const { spin: spin2 } = await import("./spin-E3ZDEDKT.js");
       const meta = JSON.parse(card.notes ?? "{}");
       if (meta.remote_session_id) {
         const hollow = spin2.listAllSessions().find((s) => s.peer === caller && s.remoteSessionId === meta.remote_session_id);
@@ -3210,7 +3460,7 @@ Context: ${body.context}` : goal,
 // src/boot/phase-agent-api.ts
 init_log_and_swallow();
 init_logger();
-var TAG9 = "agent_api";
+var TAG10 = "agent_api";
 async function phaseAgentApi(ctx) {
   const { config, memory, runtime, platforms, registry } = ctx;
   const agentConfig = loadAgentApiConfig(process.env);
@@ -3219,7 +3469,7 @@ async function phaseAgentApi(ctx) {
     sendNotification(ctx, msg);
   };
   setPeerActivityCallback(notifyPeer);
-  const { AgentApiAdapter } = await import("./agent-api-adapter-PTJYZKQK.js");
+  const { AgentApiAdapter } = await import("./agent-api-adapter-WRGEQ6DV.js");
   const a2aAdapter = new AgentApiAdapter();
   registry.register("agent-api", {
     configured: Boolean(agentConfig.port),
@@ -3230,6 +3480,7 @@ async function phaseAgentApi(ctx) {
         workingDir: config.transport.workingDir,
         memory,
         runtime,
+        sessionManager: ctx.sessionManager,
         onPeerActivity: notifyPeer,
         a2aAdapter
       });
@@ -3263,7 +3514,7 @@ async function phaseAgentApi(ctx) {
       startGossipListener();
     }
     if (Object.keys(peerConfig.peers).length > 0) {
-      import("./peer-transport-I6JPLFZ2.js").then(({ initPeerTransport }) => initPeerTransport()).catch(() => {
+      import("./peer-transport-5VKK2I7P.js").then(({ initPeerTransport }) => initPeerTransport()).catch(() => {
       });
     }
     if (Object.keys(peerConfig.peers).length > 0) {
@@ -3282,7 +3533,7 @@ async function phaseAgentApi(ctx) {
                 try {
                   resolve3(JSON.parse(data)?.choices?.[0]?.message?.content ?? "");
                 } catch (err) {
-                  logAndSwallow(TAG9, "JSON.parse agent-api response", err);
+                  logAndSwallow(TAG10, "JSON.parse agent-api response", err);
                   resolve3("");
                 }
               });
@@ -3524,7 +3775,7 @@ ${lines.join("\n")}`);
     }
   }
   if (ctx.telegramAdapter) {
-    const { spin: spin2 } = await import("./spin-IMW2MZOH.js");
+    const { spin: spin2 } = await import("./spin-E3ZDEDKT.js");
     spin2.setGreetingAdapter(ctx.telegramAdapter);
   }
   return bridge.waitForExit();
@@ -3628,6 +3879,11 @@ try {
 } catch {
 }
 process.on("uncaughtException", (err) => {
+  const e = err;
+  if (e.code === "ENOENT" && typeof e.syscall === "string" && e.syscall.startsWith("spawn")) {
+    console.error(`[WARN] Suppressed spawn ENOENT (binary not found, bridge continues): ${e.syscall} \u2014 ${e.message}`);
+    return;
+  }
   console.error(`[FATAL] Uncaught exception: ${err.stack ?? err.message ?? err}`);
   process.exit(1);
 });