@openacp/cli 2026.406.1 → 2026.406.2

package/dist/index.js

@@ -517,6 +517,7 @@ var init_config = __esm({
       defaultAgent: z.string(),
       workspace: z.object({
         baseDir: z.string().default("~/openacp-workspace"),
+        allowExternalWorkspaces: z.boolean().default(true),
         security: z.object({
           allowedPaths: z.array(z.string()).default([]),
           envWhitelist: z.array(z.string()).default([])
@@ -637,13 +638,22 @@ var init_config = __esm({
         if (input2.startsWith("/") || input2.startsWith("~")) {
           const resolved2 = expandHome3(input2);
           const base = expandHome3(this.config.workspace.baseDir);
-          if (resolved2 === base || resolved2.startsWith(base + path4.sep)) {
-            fs4.mkdirSync(resolved2, { recursive: true });
+          const isInternal = resolved2 === base || resolved2.startsWith(base + path4.sep);
+          if (!isInternal) {
+            if (!this.config.workspace.allowExternalWorkspaces) {
+              throw new Error(
+                `Workspace path "${input2}" is outside base directory "${this.config.workspace.baseDir}". Set allowExternalWorkspaces: true to allow this.`
+              );
+            }
+            if (!fs4.existsSync(resolved2)) {
+              throw new Error(
+                `Workspace path "${input2}" does not exist.`
+              );
+            }
             return resolved2;
           }
-          throw new Error(
-            `Workspace path "${input2}" is outside base directory "${this.config.workspace.baseDir}".`
-          );
+          fs4.mkdirSync(resolved2, { recursive: true });
+          return resolved2;
         }
         const name = input2.replace(/[^a-zA-Z0-9_-]/g, "");
         if (name !== input2) {
@@ -765,6 +775,104 @@ var init_read_text_file = __esm({
   }
 });
 
+// src/core/events.ts
+var Hook, BusEvent, SessionEv;
+var init_events = __esm({
+  "src/core/events.ts"() {
+    "use strict";
+    Hook = {
+      // --- Message flow ---
+      /** Incoming message from any adapter — modifiable, can block. */
+      MESSAGE_INCOMING: "message:incoming",
+      /** Outgoing message before it reaches the adapter — modifiable, can block. */
+      MESSAGE_OUTGOING: "message:outgoing",
+      // --- Agent / turn lifecycle ---
+      /** Before a user prompt is sent to the agent — modifiable, can block. */
+      AGENT_BEFORE_PROMPT: "agent:beforePrompt",
+      /** Before an agent event is dispatched — modifiable, can block. */
+      AGENT_BEFORE_EVENT: "agent:beforeEvent",
+      /** After an agent event is dispatched — read-only, fire-and-forget. */
+      AGENT_AFTER_EVENT: "agent:afterEvent",
+      /** Before the current prompt is cancelled — modifiable, can block. */
+      AGENT_BEFORE_CANCEL: "agent:beforeCancel",
+      /** Before the agent is switched — modifiable, can block. */
+      AGENT_BEFORE_SWITCH: "agent:beforeSwitch",
+      /** After the agent has been switched — read-only, fire-and-forget. */
+      AGENT_AFTER_SWITCH: "agent:afterSwitch",
+      // --- Turn boundaries ---
+      /** Turn started — read-only, fire-and-forget. */
+      TURN_START: "turn:start",
+      /** Turn ended (always fires, even on error) — read-only, fire-and-forget. */
+      TURN_END: "turn:end",
+      // --- Session lifecycle ---
+      /** Before a new session is created — modifiable, can block. */
+      SESSION_BEFORE_CREATE: "session:beforeCreate",
+      /** After a session is destroyed — read-only, fire-and-forget. */
+      SESSION_AFTER_DESTROY: "session:afterDestroy",
+      // --- Permissions ---
+      /** Before a permission request is shown to the user — modifiable, can block. */
+      PERMISSION_BEFORE_REQUEST: "permission:beforeRequest",
+      /** After a permission request is resolved — read-only, fire-and-forget. */
+      PERMISSION_AFTER_RESOLVE: "permission:afterResolve",
+      // --- Config ---
+      /** Before config options change — modifiable, can block. */
+      CONFIG_BEFORE_CHANGE: "config:beforeChange",
+      // --- Filesystem (agent-level) ---
+      /** Before a file read operation — modifiable. */
+      FS_BEFORE_READ: "fs:beforeRead",
+      /** Before a file write operation — modifiable. */
+      FS_BEFORE_WRITE: "fs:beforeWrite",
+      // --- Terminal ---
+      /** Before a terminal session is created — modifiable, can block. */
+      TERMINAL_BEFORE_CREATE: "terminal:beforeCreate",
+      /** After a terminal session exits — read-only, fire-and-forget. */
+      TERMINAL_AFTER_EXIT: "terminal:afterExit"
+    };
+    BusEvent = {
+      // --- Session lifecycle ---
+      SESSION_CREATED: "session:created",
+      SESSION_UPDATED: "session:updated",
+      SESSION_DELETED: "session:deleted",
+      SESSION_ENDED: "session:ended",
+      SESSION_NAMED: "session:named",
+      SESSION_THREAD_READY: "session:threadReady",
+      SESSION_CONFIG_CHANGED: "session:configChanged",
+      SESSION_AGENT_SWITCH: "session:agentSwitch",
+      // --- Agent ---
+      AGENT_EVENT: "agent:event",
+      AGENT_PROMPT: "agent:prompt",
+      // --- Permissions ---
+      PERMISSION_REQUEST: "permission:request",
+      PERMISSION_RESOLVED: "permission:resolved",
+      // --- Message visibility ---
+      MESSAGE_QUEUED: "message:queued",
+      MESSAGE_PROCESSING: "message:processing",
+      // --- System lifecycle ---
+      KERNEL_BOOTED: "kernel:booted",
+      SYSTEM_READY: "system:ready",
+      SYSTEM_SHUTDOWN: "system:shutdown",
+      SYSTEM_COMMANDS_READY: "system:commands-ready",
+      // --- Plugin lifecycle ---
+      PLUGIN_LOADED: "plugin:loaded",
+      PLUGIN_FAILED: "plugin:failed",
+      PLUGIN_DISABLED: "plugin:disabled",
+      PLUGIN_UNLOADED: "plugin:unloaded",
+      // --- Usage ---
+      USAGE_RECORDED: "usage:recorded"
+    };
+    SessionEv = {
+      AGENT_EVENT: "agent_event",
+      PERMISSION_REQUEST: "permission_request",
+      SESSION_END: "session_end",
+      STATUS_CHANGE: "status_change",
+      NAMED: "named",
+      ERROR: "error",
+      PROMPT_COUNT_CHANGED: "prompt_count_changed",
+      TURN_STARTED: "turn_started"
+    };
+  }
+});
+
 // src/core/utils/bypass-detection.ts
 function isPermissionBypass(value) {
   const lower = value.toLowerCase();
@@ -3108,6 +3216,7 @@ var MAX_SSE_CONNECTIONS, SSEManager;
 var init_sse_manager = __esm({
   "src/plugins/api-server/sse-manager.ts"() {
     "use strict";
+    init_events();
     MAX_SSE_CONNECTIONS = 50;
     SSEManager = class {
       constructor(eventBus, getSessionStats, startedAt) {
@@ -3122,14 +3231,14 @@ var init_sse_manager = __esm({
       setup() {
         if (!this.eventBus) return;
         const events = [
-          "session:created",
-          "session:updated",
-          "session:deleted",
-          "agent:event",
-          "permission:request",
-          "permission:resolved",
-          "message:queued",
-          "message:processing"
+          BusEvent.SESSION_CREATED,
+          BusEvent.SESSION_UPDATED,
+          BusEvent.SESSION_DELETED,
+          BusEvent.AGENT_EVENT,
+          BusEvent.PERMISSION_REQUEST,
+          BusEvent.PERMISSION_RESOLVED,
+          BusEvent.MESSAGE_QUEUED,
+          BusEvent.MESSAGE_PROCESSING
         ];
         for (const eventName of events) {
           const handler = (data) => {
@@ -3192,12 +3301,12 @@ data: ${JSON.stringify(data)}
 
 `;
         const sessionEvents = [
-          "agent:event",
-          "permission:request",
-          "permission:resolved",
-          "session:updated",
-          "message:queued",
-          "message:processing"
+          BusEvent.AGENT_EVENT,
+          BusEvent.PERMISSION_REQUEST,
+          BusEvent.PERMISSION_RESOLVED,
+          BusEvent.SESSION_UPDATED,
+          BusEvent.MESSAGE_QUEUED,
+          BusEvent.MESSAGE_PROCESSING
         ];
         for (const res of this.sseConnections) {
           const filter = res.sessionFilter;
@@ -7318,7 +7427,6 @@ var menu_exports = {};
 __export(menu_exports, {
   buildMenuKeyboard: () => buildMenuKeyboard,
   buildSkillMessages: () => buildSkillMessages,
-  handleClear: () => handleClear,
   handleHelp: () => handleHelp,
   handleMenu: () => handleMenu
 });
@@ -7379,31 +7487,11 @@ Each session gets its own topic \u2014 chat there to work with the agent.
 /bypass_permissions \u2014 Toggle bypass permissions
 /handoff \u2014 Continue session in terminal
 /archive \u2014 Archive session topic
-/clear \u2014 Clear assistant history
 
 \u{1F4AC} Need help? Just ask me in this topic!`,
     { parse_mode: "HTML" }
   );
 }
-async function handleClear(ctx, assistant) {
-  if (!assistant) {
-    await ctx.reply("\u26A0\uFE0F Assistant is not available.", { parse_mode: "HTML" });
-    return;
-  }
-  const threadId = ctx.message?.message_thread_id;
-  if (threadId !== assistant.topicId) {
-    await ctx.reply("\u2139\uFE0F /clear only works in the Assistant topic.", { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.reply("\u{1F504} Clearing assistant history...", { parse_mode: "HTML" });
-  try {
-    await assistant.respawn();
-    await ctx.reply("\u2705 Assistant history cleared.", { parse_mode: "HTML" });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    await ctx.reply(`\u274C Failed to clear: <code>${message}</code>`, { parse_mode: "HTML" });
-  }
-}
 function buildSkillMessages(commands) {
   const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
   const header2 = "\u{1F6E0} <b>Available Skills</b>\n";
@@ -8221,7 +8309,6 @@ var init_commands = __esm({
       { command: "menu", description: "Show menu" },
       { command: "integrate", description: "Manage agent integrations" },
       { command: "handoff", description: "Continue this session in your terminal" },
-      { command: "clear", description: "Clear assistant history" },
       { command: "restart", description: "Restart OpenACP" },
       { command: "update", description: "Update to latest version and restart" },
       { command: "doctor", description: "Run system diagnostics" },
@@ -9312,6 +9399,7 @@ var log35, TelegramAdapter;
 var init_adapter = __esm({
   "src/plugins/telegram/adapter.ts"() {
     "use strict";
+    init_events();
     init_log();
     init_topics();
     init_commands();
@@ -9781,7 +9869,7 @@ ${p}` : p;
             log35.warn({ err, sessionId }, "Failed to send initial messages for new session");
           });
         };
-        this.core.eventBus.on("session:threadReady", this._threadReadyHandler);
+        this.core.eventBus.on(BusEvent.SESSION_THREAD_READY, this._threadReadyHandler);
         this._configChangedHandler = ({ sessionId }) => {
           this.updateControlMessage(sessionId).catch(() => {
           });
@@ -9814,7 +9902,7 @@ ${p}` : p;
           log35.warn({ err }, "Failed to send welcome message");
         }
         try {
-          await this.core.assistantManager.spawn("telegram", String(this.assistantTopicId));
+          await this.core.assistantManager.getOrSpawn("telegram", String(this.assistantTopicId));
         } catch (err) {
           log35.error({ err }, "Failed to spawn assistant");
         }
@@ -9873,7 +9961,7 @@ OpenACP will automatically retry until this is resolved.`;
         }
         this.sessionTrackers.clear();
         if (this._threadReadyHandler) {
-          this.core.eventBus.off("session:threadReady", this._threadReadyHandler);
+          this.core.eventBus.off(BusEvent.SESSION_THREAD_READY, this._threadReadyHandler);
           this._threadReadyHandler = void 0;
         }
         if (this._configChangedHandler) {
@@ -10943,11 +11031,49 @@ var TypedEmitter = class _TypedEmitter {
 
 // src/core/agents/agent-instance.ts
 init_read_text_file();
+
+// src/core/agents/attachment-blocks.ts
+var SUPPORTED_IMAGE_MIMES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "image/heic",
+  "image/heif"
+]);
+var MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024;
+function buildAttachmentNote(att, capabilities) {
+  const tooLarge = att.size > MAX_ATTACHMENT_SIZE;
+  if (tooLarge) {
+    const sizeMB = Math.round(att.size / 1024 / 1024);
+    return `[Attachment skipped: "${att.fileName}" is too large (${sizeMB}MB > 10MB limit)]`;
+  }
+  if (att.type === "image") {
+    if (!capabilities.image) {
+      return null;
+    }
+    if (!SUPPORTED_IMAGE_MIMES.has(att.mimeType)) {
+      return `[Attachment skipped: image format not supported (${att.mimeType})]`;
+    }
+    return null;
+  }
+  if (att.type === "audio") {
+    if (!capabilities.audio) {
+      return null;
+    }
+    return null;
+  }
+  return null;
+}
+
+// src/core/agents/agent-instance.ts
 import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 
 // src/core/sessions/terminal-manager.ts
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
+init_events();
 var TerminalManager = class {
   terminals = /* @__PURE__ */ new Map();
   maxOutputBytes;
@@ -10964,7 +11090,7 @@ var TerminalManager = class {
       for (const ev of termEnvArr) {
         envRecord[ev.name] = ev.value;
       }
-      const result = await middlewareChain.execute("terminal:beforeCreate", {
+      const result = await middlewareChain.execute(Hook.TERMINAL_BEFORE_CREATE, {
         sessionId,
         command: termCommand,
         args: termArgs,
@@ -11018,7 +11144,7 @@ var TerminalManager = class {
     childProcess.on("exit", (code, signal) => {
       state.exitStatus = { exitCode: code, signal };
       if (middlewareChain) {
-        middlewareChain.execute("terminal:afterExit", {
+        middlewareChain.execute(Hook.TERMINAL_AFTER_EXIT, {
           sessionId,
           terminalId,
           command: state.command,
@@ -11148,6 +11274,7 @@ function createDebugTracer(sessionId, workingDirectory) {
 
 // src/core/agents/agent-instance.ts
 init_log();
+init_events();
 var log4 = createChildLogger({ module: "agent-instance" });
 function findPackageRoot(startDir) {
   let dir = startDir;
@@ -11230,7 +11357,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
     super();
     this.agentName = agentName;
   }
-  static async spawnSubprocess(agentDef, workingDirectory) {
+  static async spawnSubprocess(agentDef, workingDirectory, allowedPaths = []) {
     const instance = new _AgentInstance(agentDef.name);
     const resolved = resolveAgentCommand(agentDef.command);
     log4.debug(
@@ -11244,10 +11371,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
     const ignorePatterns = PathGuard.loadIgnoreFile(workingDirectory);
     instance.pathGuard = new PathGuard({
       cwd: workingDirectory,
-      // allowedPaths is wired from workspace.security.allowedPaths config;
-      // spawnSubprocess would need to receive a SecurityConfig param to use it.
-      // Tracked as follow-up: pass workspace security config through spawn/resume call chain.
-      allowedPaths: [],
+      allowedPaths,
       ignorePatterns
     });
     instance.child = spawn2(
@@ -11341,7 +11465,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
       if (signal === "SIGINT" || signal === "SIGTERM") return;
       if (code !== 0 && code !== null || signal) {
         const stderr = this.stderrCapture.getLastLines();
-        this.emit("agent_event", {
+        this.emit(SessionEv.AGENT_EVENT, {
           type: "error",
           message: signal ? `Agent killed by signal ${signal}
 ${stderr}` : `Agent crashed (exit code ${code})
@@ -11353,7 +11477,7 @@ ${stderr}`
       log4.debug({ sessionId: this.sessionId }, "ACP connection closed");
     });
   }
-  static async spawn(agentDef, workingDirectory, mcpServers) {
+  static async spawn(agentDef, workingDirectory, mcpServers, allowedPaths) {
     log4.debug(
       { agentName: agentDef.name, command: agentDef.command },
       "Spawning agent"
@@ -11361,7 +11485,8 @@ ${stderr}`
     const spawnStart = Date.now();
     const instance = await _AgentInstance.spawnSubprocess(
       agentDef,
-      workingDirectory
+      workingDirectory,
+      allowedPaths
     );
     const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
     const response = await instance.connection.newSession({
@@ -11384,12 +11509,13 @@ ${stderr}`
     );
     return instance;
   }
-  static async resume(agentDef, workingDirectory, agentSessionId, mcpServers) {
+  static async resume(agentDef, workingDirectory, agentSessionId, mcpServers, allowedPaths) {
     log4.debug({ agentName: agentDef.name, agentSessionId }, "Resuming agent");
     const spawnStart = Date.now();
     const instance = await _AgentInstance.spawnSubprocess(
       agentDef,
-      workingDirectory
+      workingDirectory,
+      allowedPaths
     );
     const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
     try {
@@ -11577,7 +11703,7 @@ ${stderr}`
             return;
         }
         if (event !== null) {
-          self.emit("agent_event", event);
+          self.emit(SessionEv.AGENT_EVENT, event);
         }
       },
       // ── Permission requests ──────────────────────────────────────────────
@@ -11604,7 +11730,7 @@ ${stderr}`
           throw new Error(`[Access denied] ${pathCheck.reason}`);
         }
         if (self.middlewareChain) {
-          const result = await self.middlewareChain.execute("fs:beforeRead", { sessionId: self.sessionId, path: p.path, line: p.line, limit: p.limit }, async (r) => r);
+          const result = await self.middlewareChain.execute(Hook.FS_BEFORE_READ, { sessionId: self.sessionId, path: p.path, line: p.line, limit: p.limit }, async (r) => r);
           if (!result) return { content: "" };
           p.path = result.path;
         }
@@ -11622,7 +11748,7 @@ ${stderr}`
           throw new Error(`[Access denied] ${pathCheck.reason}`);
         }
         if (self.middlewareChain) {
-          const result = await self.middlewareChain.execute("fs:beforeWrite", { sessionId: self.sessionId, path: writePath, content: writeContent }, async (r) => r);
+          const result = await self.middlewareChain.execute(Hook.FS_BEFORE_WRITE, { sessionId: self.sessionId, path: writePath, content: writeContent }, async (r) => r);
           if (!result) return {};
           writePath = result.path;
           writeContent = result.content;
@@ -11719,10 +11845,16 @@ ${stderr}`
   // ── Prompt & lifecycle ──────────────────────────────────────────────
   async prompt(text3, attachments) {
     const contentBlocks = [{ type: "text", text: text3 }];
-    const SUPPORTED_IMAGE_MIMES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+    const capabilities = this.promptCapabilities ?? {};
     for (const att of attachments ?? []) {
-      const tooLarge = att.size > 10 * 1024 * 1024;
-      if (att.type === "image" && this.promptCapabilities?.image && !tooLarge && SUPPORTED_IMAGE_MIMES.has(att.mimeType)) {
+      const skipNote = buildAttachmentNote(att, capabilities);
+      if (skipNote !== null) {
+        contentBlocks[0].text += `
+
+${skipNote}`;
+        continue;
+      }
+      if (att.type === "image" && capabilities.image && SUPPORTED_IMAGE_MIMES.has(att.mimeType)) {
         const attCheck = this.pathGuard.validatePath(att.filePath, "read");
         if (!attCheck.allowed) {
           contentBlocks[0].text += `
@@ -11732,7 +11864,7 @@ ${stderr}`
         }
         const data = await fs8.promises.readFile(att.filePath);
         contentBlocks.push({ type: "image", data: data.toString("base64"), mimeType: att.mimeType });
-      } else if (att.type === "audio" && this.promptCapabilities?.audio && !tooLarge) {
+      } else if (att.type === "audio" && capabilities.audio) {
         const attCheck = this.pathGuard.validatePath(att.filePath, "read");
         if (!attCheck.allowed) {
           contentBlocks[0].text += `
@@ -11743,9 +11875,9 @@ ${stderr}`
         const data = await fs8.promises.readFile(att.filePath);
         contentBlocks.push({ type: "audio", data: data.toString("base64"), mimeType: att.mimeType });
       } else {
-        if ((att.type === "image" || att.type === "audio") && !tooLarge) {
+        if (att.type === "image" || att.type === "audio") {
           log4.debug(
-            { type: att.type, capabilities: this.promptCapabilities ?? {} },
+            { type: att.type, capabilities },
             "Agent does not support %s content, falling back to file path",
             att.type
           );
@@ -11801,15 +11933,15 @@ var AgentManager = class {
   getAgent(name) {
     return this.catalog.resolve(name);
   }
-  async spawn(agentName, workingDirectory) {
+  async spawn(agentName, workingDirectory, allowedPaths) {
     const agentDef = this.getAgent(agentName);
     if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
-    return AgentInstance.spawn(agentDef, workingDirectory);
+    return AgentInstance.spawn(agentDef, workingDirectory, void 0, allowedPaths);
   }
-  async resume(agentName, workingDirectory, agentSessionId) {
+  async resume(agentName, workingDirectory, agentSessionId, allowedPaths) {
     const agentDef = this.getAgent(agentName);
     if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
-    return AgentInstance.resume(agentDef, workingDirectory, agentSessionId);
+    return AgentInstance.resume(agentDef, workingDirectory, agentSessionId, void 0, allowedPaths);
   }
 };
 
@@ -11982,6 +12114,7 @@ function isSystemEvent(event) {
 }
 
 // src/core/sessions/session.ts
+init_events();
 var moduleLog = createChildLogger({ module: "session" });
 var TTS_PROMPT_INSTRUCTION = `
 
@@ -12010,7 +12143,15 @@ var Session = class extends TypedEmitter {
   }
   agentName;
   workingDirectory;
-  agentInstance;
+  _agentInstance;
+  get agentInstance() {
+    return this._agentInstance;
+  }
+  set agentInstance(agent) {
+    this._agentInstance = agent;
+    this.wireAgentRelay();
+    this.wireCommandsBuffer();
+  }
   agentSessionId = "";
   _status = "initializing";
   name;
@@ -12034,9 +12175,6 @@ var Session = class extends TypedEmitter {
   threadIds = /* @__PURE__ */ new Map();
   /** Active turn context — sealed on prompt dequeue, cleared on turn end */
   activeTurnContext = null;
-  /** The agentInstance for which the agent→session event relay is wired (prevents duplicate relays from multiple bridges).
-   *  When the agent is swapped, the relay must be re-wired to the new instance. */
-  agentRelaySource = null;
   permissionGate = new PermissionGate();
   queue;
   speechService;
@@ -12060,23 +12198,37 @@ var Session = class extends TypedEmitter {
         this.log.error({ err }, "Prompt execution failed");
         const message = err instanceof Error ? err.message : String(err);
         this.fail(message);
-        this.emit("agent_event", { type: "error", message: `Prompt execution failed: ${message}` });
+        this.emit(SessionEv.AGENT_EVENT, { type: "error", message: `Prompt execution failed: ${message}` });
       }
     );
-    this.wireCommandsBuffer();
+  }
+  /** Wire the agent→session event relay on the current agentInstance.
+   *  Removes any previous relay first to avoid duplicates on agent switch.
+   *  This relay ensures session.emit("agent_event") fires for ALL sessions,
+   *  including headless API sessions that have no SessionBridge attached. */
+  agentRelayCleanup;
+  wireAgentRelay() {
+    this.agentRelayCleanup?.();
+    const instance = this._agentInstance;
+    const handler = (event) => {
+      this.emit(SessionEv.AGENT_EVENT, event);
+    };
+    instance.on(SessionEv.AGENT_EVENT, handler);
+    this.agentRelayCleanup = () => instance.off(SessionEv.AGENT_EVENT, handler);
   }
   /** Wire a listener on the current agentInstance to buffer commands_update events.
    *  Must be called after every agentInstance replacement (constructor + switchAgent). */
   commandsBufferCleanup;
   wireCommandsBuffer() {
     this.commandsBufferCleanup?.();
+    const instance = this._agentInstance;
     const handler = (event) => {
       if (event.type === "commands_update") {
         this.latestCommands = event.commands;
       }
     };
-    this.agentInstance.on("agent_event", handler);
-    this.commandsBufferCleanup = () => this.agentInstance.off("agent_event", handler);
+    instance.on(SessionEv.AGENT_EVENT, handler);
+    this.commandsBufferCleanup = () => instance.off(SessionEv.AGENT_EVENT, handler);
   }
   // --- State Machine ---
   get status() {
@@ -12090,12 +12242,12 @@ var Session = class extends TypedEmitter {
   fail(reason) {
     if (this._status === "error") return;
     this.transition("error");
-    this.emit("error", new Error(reason));
+    this.emit(SessionEv.ERROR, new Error(reason));
   }
   /** Transition to finished — from active only. Emits session_end for backward compat. */
   finish(reason) {
     this.transition("finished");
-    this.emit("session_end", reason ?? "completed");
+    this.emit(SessionEv.SESSION_END, reason ?? "completed");
   }
   /** Transition to cancelled — from active only (terminal session cancel) */
   markCancelled() {
@@ -12111,7 +12263,7 @@ var Session = class extends TypedEmitter {
     }
     this._status = to;
     this.log.debug({ from, to }, "Session status transition");
-    this.emit("status_change", from, to);
+    this.emit(SessionEv.STATUS_CHANGE, from, to);
   }
   /** Number of prompts waiting in queue */
   get queueDepth() {
@@ -12133,8 +12285,8 @@ var Session = class extends TypedEmitter {
   async enqueuePrompt(text3, attachments, routing, externalTurnId) {
     const turnId = externalTurnId ?? nanoid2(8);
     if (this.middlewareChain) {
-      const payload = { text: text3, attachments, sessionId: this.id };
-      const result = await this.middlewareChain.execute("agent:beforePrompt", payload, async (p) => p);
+      const payload = { text: text3, attachments, sessionId: this.id, sourceAdapterId: routing?.sourceAdapterId };
+      const result = await this.middlewareChain.execute(Hook.AGENT_BEFORE_PROMPT, payload, async (p) => p);
       if (!result) return turnId;
       text3 = result.text;
       attachments = result.attachments;
@@ -12149,9 +12301,9 @@ var Session = class extends TypedEmitter {
       routing?.responseAdapterId,
       turnId
     );
-    this.emit("turn_started", this.activeTurnContext);
+    this.emit(SessionEv.TURN_STARTED, this.activeTurnContext);
     this.promptCount++;
-    this.emit("prompt_count_changed", this.promptCount);
+    this.emit(SessionEv.PROMPT_COUNT_CHANGED, this.promptCount);
     if (this._status === "initializing" || this._status === "cancelled" || this._status === "error") {
       this.activate();
     }
@@ -12180,10 +12332,18 @@ ${text3}`;
       }
     } : null;
     if (accumulatorListener) {
-      this.on("agent_event", accumulatorListener);
+      this.on(SessionEv.AGENT_EVENT, accumulatorListener);
+    }
+    const mw = this.middlewareChain;
+    const afterEventListener = mw ? (event) => {
+      mw.execute(Hook.AGENT_AFTER_EVENT, { sessionId: this.id, event, outgoingMessage: { type: "text", text: "" } }, async (e) => e).catch(() => {
+      });
+    } : null;
+    if (afterEventListener) {
+      this.agentInstance.on(SessionEv.AGENT_EVENT, afterEventListener);
     }
     if (this.middlewareChain) {
-      this.middlewareChain.execute("turn:start", { sessionId: this.id, promptText: processed.text, promptNumber: this.promptCount }, async (p) => p).catch(() => {
+      this.middlewareChain.execute(Hook.TURN_START, { sessionId: this.id, promptText: processed.text, promptNumber: this.promptCount }, async (p) => p).catch(() => {
       });
     }
     let stopReason = "end_turn";
@@ -12204,10 +12364,13 @@ ${text3}`;
       promptError = err;
     } finally {
       if (accumulatorListener) {
-        this.off("agent_event", accumulatorListener);
+        this.off(SessionEv.AGENT_EVENT, accumulatorListener);
+      }
+      if (afterEventListener) {
+        this.agentInstance.off(SessionEv.AGENT_EVENT, afterEventListener);
       }
       if (this.middlewareChain) {
-        this.middlewareChain.execute("turn:end", { sessionId: this.id, stopReason, durationMs: Date.now() - promptStart }, async (p) => p).catch(() => {
+        this.middlewareChain.execute(Hook.TURN_END, { sessionId: this.id, stopReason, durationMs: Date.now() - promptStart }, async (p) => p).catch(() => {
         });
       }
       this.activeTurnContext = null;
@@ -12252,7 +12415,7 @@ ${text3}`;
         const audioBuffer = await fs9.promises.readFile(audioPath);
         const result = await this.speechService.transcribe(audioBuffer, audioMime);
         this.log.info({ provider: "stt", duration: result.duration }, "Voice transcribed");
-        this.emit("agent_event", {
+        this.emit(SessionEv.AGENT_EVENT, {
           type: "system_message",
           message: `\u{1F3A4} You said: ${result.text}`
         });
@@ -12261,7 +12424,7 @@ ${text3}`;
 ${result.text}` : result.text;
       } catch (err) {
         this.log.warn({ err }, "STT transcription failed, keeping audio attachment");
-        this.emit("agent_event", {
+        this.emit(SessionEv.AGENT_EVENT, {
           type: "error",
           message: `Voice transcription failed: ${err.message}`
         });
@@ -12295,12 +12458,12 @@ ${result.text}` : result.text;
           timeoutPromise
         ]);
         const base64 = result.audioBuffer.toString("base64");
-        this.emit("agent_event", {
+        this.emit(SessionEv.AGENT_EVENT, {
           type: "audio_content",
           data: base64,
           mimeType: result.mimeType
         });
-        this.emit("agent_event", { type: "tts_strip" });
+        this.emit(SessionEv.AGENT_EVENT, { type: "tts_strip" });
         this.log.info("TTS synthesis completed");
       } finally {
         clearTimeout(ttsTimer);
@@ -12315,19 +12478,19 @@ ${result.text}` : result.text;
     const captureHandler = (event) => {
       if (event.type === "text") title += event.content;
     };
-    this.pause((event) => event !== "agent_event");
-    this.agentInstance.on("agent_event", captureHandler);
+    this.pause((event) => event !== SessionEv.AGENT_EVENT);
+    this.agentInstance.on(SessionEv.AGENT_EVENT, captureHandler);
     try {
       await this.agentInstance.prompt(
         "Summarize this conversation in max 5 words for a topic title. Reply ONLY with the title, nothing else."
       );
       this.name = title.trim().slice(0, 50) || `Session ${this.id.slice(0, 6)}`;
       this.log.info({ name: this.name }, "Session auto-named");
-      this.emit("named", this.name);
+      this.emit(SessionEv.NAMED, this.name);
     } catch {
       this.name = `Session ${this.id.slice(0, 6)}`;
     } finally {
-      this.agentInstance.off("agent_event", captureHandler);
+      this.agentInstance.off(SessionEv.AGENT_EVENT, captureHandler);
       this.clearBuffer();
       this.resume();
     }
@@ -12389,7 +12552,7 @@ ${result.text}` : result.text;
   /** Set session name explicitly and emit 'named' event */
   setName(name) {
     this.name = name;
-    this.emit("named", name);
+    this.emit(SessionEv.NAMED, name);
   }
   /** Send a config option change to the agent and update local state from the response. */
   async setConfigOption(configId, value) {
@@ -12405,7 +12568,7 @@ ${result.text}` : result.text;
   }
   async updateConfigOptions(options) {
     if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("config:beforeChange", { sessionId: this.id, configId: "options", oldValue: this.configOptions, newValue: options }, async (p) => p);
+      const result = await this.middlewareChain.execute(Hook.CONFIG_BEFORE_CHANGE, { sessionId: this.id, configId: "options", oldValue: this.configOptions, newValue: options }, async (p) => p);
       if (!result) return;
     }
     this.configOptions = options;
@@ -12425,7 +12588,7 @@ ${result.text}` : result.text;
   /** Cancel the current prompt and clear the queue. Stays in active state. */
   async abortPrompt() {
     if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("agent:beforeCancel", { sessionId: this.id }, async (p) => p);
+      const result = await this.middlewareChain.execute(Hook.AGENT_BEFORE_CANCEL, { sessionId: this.id }, async (p) => p);
       if (!result) return;
     }
     this.queue.clear();
@@ -12466,7 +12629,6 @@ ${result.text}` : result.text;
     this.configOptions = [];
     this.latestCommands = null;
     this.applySpawnResponse(newAgent.initialSessionResponse, newAgent.agentCapabilities);
-    this.wireCommandsBuffer();
     this.log.info({ from: this.agentSwitchHistory.at(-1).agentName, to: agentName }, "Agent switched");
   }
   async destroy() {
@@ -12905,6 +13067,7 @@ var MessageTransformer = class {
 };
 
 // src/core/sessions/session-manager.ts
+init_events();
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
   store;
@@ -13009,18 +13172,18 @@ var SessionManager = class {
       }
     }
     if (this.middlewareChain) {
-      this.middlewareChain.execute("session:afterDestroy", { sessionId }, async (p) => p).catch(() => {
+      this.middlewareChain.execute(Hook.SESSION_AFTER_DESTROY, { sessionId }, async (p) => p).catch(() => {
       });
     }
   }
   listSessions(channelId) {
-    const all = Array.from(this.sessions.values());
+    const all = Array.from(this.sessions.values()).filter((s) => !s.isAssistant);
     if (channelId) return all.filter((s) => s.channelId === channelId);
     return all;
   }
   listAllSessions(channelId) {
     if (this.store) {
-      let records = this.store.list();
+      let records = this.store.list().filter((r) => !r.isAssistant);
       if (channelId) records = records.filter((r) => r.channelId === channelId);
       return records.map((record) => {
         const live2 = this.sessions.get(record.sessionId);
@@ -13060,7 +13223,7 @@ var SessionManager = class {
         };
       });
     }
-    let live = Array.from(this.sessions.values());
+    let live = Array.from(this.sessions.values()).filter((s) => !s.isAssistant);
     if (channelId) live = live.filter((s) => s.channelId === channelId);
     return live.map((s) => ({
       id: s.id,
@@ -13081,7 +13244,7 @@ var SessionManager = class {
   }
   listRecords(filter) {
     if (!this.store) return [];
-    let records = this.store.list();
+    let records = this.store.list().filter((r) => !r.isAssistant);
     if (filter?.statuses?.length) {
       records = records.filter((r) => filter.statuses.includes(r.status));
     }
@@ -13090,7 +13253,7 @@ var SessionManager = class {
   async removeRecord(sessionId) {
     if (!this.store) return;
     await this.store.remove(sessionId);
-    this.eventBus?.emit("session:deleted", { sessionId });
+    this.eventBus?.emit(BusEvent.SESSION_DELETED, { sessionId });
   }
   /**
    * Graceful shutdown: persist session state without killing agent subprocesses.
@@ -13138,7 +13301,7 @@ var SessionManager = class {
     this.sessions.clear();
     if (this.middlewareChain) {
       for (const sessionId of sessionIds) {
-        this.middlewareChain.execute("session:afterDestroy", { sessionId }, async (p) => p).catch(() => {
+        this.middlewareChain.execute(Hook.SESSION_AFTER_DESTROY, { sessionId }, async (p) => p).catch(() => {
         });
       }
     }
@@ -13148,6 +13311,7 @@ var SessionManager = class {
 // src/core/sessions/session-bridge.ts
 init_log();
 init_bypass_detection();
+init_events();
 var log6 = createChildLogger({ module: "session-bridge" });
 var SessionBridge = class {
   constructor(session, adapter, deps, adapterId) {
@@ -13172,7 +13336,7 @@ var SessionBridge = class {
     try {
       const mw = this.deps.middlewareChain;
       if (mw) {
-        const result = await mw.execute("message:outgoing", { sessionId, message }, async (m) => m);
+        const result = await mw.execute(Hook.MESSAGE_OUTGOING, { sessionId, message }, async (m) => m);
         this.tracer?.log("core", { step: "middleware:outgoing", sessionId, hook: "message:outgoing", blocked: !result });
         if (!result) return;
         this.tracer?.log("core", { step: "dispatch", sessionId, message: result.message });
@@ -13201,17 +13365,11 @@ var SessionBridge = class {
   connect() {
     if (this.connected) return;
     this.connected = true;
-    if (this.session.agentRelaySource !== this.session.agentInstance) {
-      this.listen(this.session.agentInstance, "agent_event", (event) => {
-        this.session.emit("agent_event", event);
-      });
-      this.session.agentRelaySource = this.session.agentInstance;
-    }
-    this.listen(this.session, "agent_event", (event) => {
+    this.listen(this.session, SessionEv.AGENT_EVENT, (event) => {
       if (this.shouldForward(event)) {
         this.dispatchAgentEvent(event);
       } else {
-        this.deps.eventBus?.emit("agent:event", { sessionId: this.session.id, event });
+        this.deps.eventBus?.emit(BusEvent.AGENT_EVENT, { sessionId: this.session.id, event });
       }
     });
     if (!this.session.agentInstance.onPermissionRequest || this.session.agentInstance.onPermissionRequest.__bridgeId === void 0) {
@@ -13221,7 +13379,7 @@ var SessionBridge = class {
       handler.__bridgeId = this.adapterId;
       this.session.agentInstance.onPermissionRequest = handler;
     }
-    this.listen(this.session, "permission_request", async (request) => {
+    this.listen(this.session, SessionEv.PERMISSION_REQUEST, async (request) => {
       const current = this.session.agentInstance.onPermissionRequest;
       if (current?.__bridgeId === this.adapterId) return;
       if (!this.session.permissionGate.isPending) return;
@@ -13231,37 +13389,41 @@ var SessionBridge = class {
         log6.error({ err, sessionId: this.session.id, adapterId: this.adapterId }, "Failed to send permission request to adapter");
       }
     });
-    this.listen(this.session, "status_change", (from, to) => {
+    this.listen(this.session, SessionEv.STATUS_CHANGE, (from, to) => {
       this.deps.sessionManager.patchRecord(this.session.id, {
         status: to,
         lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      this.deps.eventBus?.emit("session:updated", {
-        sessionId: this.session.id,
-        status: to
-      });
+      if (!this.session.isAssistant) {
+        this.deps.eventBus?.emit(BusEvent.SESSION_UPDATED, {
+          sessionId: this.session.id,
+          status: to
+        });
+      }
       if (to === "finished") {
         queueMicrotask(() => this.disconnect());
       }
     });
-    this.listen(this.session, "named", async (name) => {
+    this.listen(this.session, SessionEv.NAMED, async (name) => {
       const record = this.deps.sessionManager.getSessionRecord(this.session.id);
       const alreadyNamed = !!record?.name;
       await this.deps.sessionManager.patchRecord(this.session.id, { name });
-      this.deps.eventBus?.emit("session:updated", {
-        sessionId: this.session.id,
-        name
-      });
+      if (!this.session.isAssistant) {
+        this.deps.eventBus?.emit(BusEvent.SESSION_UPDATED, {
+          sessionId: this.session.id,
+          name
+        });
+      }
       if (!alreadyNamed) {
         await this.adapter.renameSessionThread(this.session.id, name);
       }
     });
-    this.listen(this.session, "prompt_count_changed", (count) => {
+    this.listen(this.session, SessionEv.PROMPT_COUNT_CHANGED, (count) => {
       this.deps.sessionManager.patchRecord(this.session.id, { currentPromptCount: count });
     });
-    this.listen(this.session, "turn_started", (ctx) => {
+    this.listen(this.session, SessionEv.TURN_STARTED, (ctx) => {
       if (ctx.sourceAdapterId !== "sse" && ctx.sourceAdapterId !== "api") {
-        this.deps.eventBus?.emit("message:processing", {
+        this.deps.eventBus?.emit(BusEvent.MESSAGE_PROCESSING, {
           sessionId: this.session.id,
           turnId: ctx.turnId,
           sourceAdapterId: ctx.sourceAdapterId,
@@ -13270,10 +13432,10 @@ var SessionBridge = class {
       }
     });
     if (this.session.latestCommands !== null) {
-      this.session.emit("agent_event", { type: "commands_update", commands: this.session.latestCommands });
+      this.session.emit(SessionEv.AGENT_EVENT, { type: "commands_update", commands: this.session.latestCommands });
     }
     if (this.session.configOptions.length > 0) {
-      this.session.emit("agent_event", { type: "config_option_update", options: this.session.configOptions });
+      this.session.emit(SessionEv.AGENT_EVENT, { type: "config_option_update", options: this.session.configOptions });
     }
   }
   disconnect() {
@@ -13293,17 +13455,11 @@ var SessionBridge = class {
     const mw = this.deps.middlewareChain;
     if (mw) {
       try {
-        const result = await mw.execute("agent:beforeEvent", { sessionId: this.session.id, event }, async (e) => e);
+        const result = await mw.execute(Hook.AGENT_BEFORE_EVENT, { sessionId: this.session.id, event }, async (e) => e);
         this.tracer?.log("core", { step: "middleware:before", sessionId: this.session.id, hook: "agent:beforeEvent", blocked: !result });
         if (!result) return;
         const transformedEvent = result.event;
-        const outgoing = this.handleAgentEvent(transformedEvent);
-        mw.execute("agent:afterEvent", {
-          sessionId: this.session.id,
-          event: transformedEvent,
-          outgoingMessage: outgoing ?? { type: "text", text: "" }
-        }, async (e) => e).catch(() => {
-        });
+        this.handleAgentEvent(transformedEvent);
       } catch {
         try {
           this.handleAgentEvent(event);
@@ -13436,7 +13592,7 @@ var SessionBridge = class {
         this.adapter.stripTTSBlock?.(this.session.id);
         break;
     }
-    this.deps.eventBus?.emit("agent:event", {
+    this.deps.eventBus?.emit(BusEvent.AGENT_EVENT, {
       sessionId: this.session.id,
       event
     });
@@ -13455,7 +13611,7 @@ var SessionBridge = class {
     let permReq = request;
     if (mw) {
       const payload = { sessionId: this.session.id, request, autoResolve: void 0 };
-      const result = await mw.execute("permission:beforeRequest", payload, async (r) => r);
+      const result = await mw.execute(Hook.PERMISSION_BEFORE_REQUEST, payload, async (r) => r);
       if (!result) return "";
       permReq = result.request;
       if (result.autoResolve) {
@@ -13463,21 +13619,21 @@ var SessionBridge = class {
         return result.autoResolve;
       }
     }
-    this.deps.eventBus?.emit("permission:request", {
+    this.deps.eventBus?.emit(BusEvent.PERMISSION_REQUEST, {
       sessionId: this.session.id,
       permission: permReq
     });
     const autoDecision = this.checkAutoApprove(permReq);
     if (autoDecision) {
-      this.session.emit("permission_request", permReq);
+      this.session.emit(SessionEv.PERMISSION_REQUEST, permReq);
       this.emitAfterResolve(mw, permReq.id, autoDecision, "system", startTime);
       return autoDecision;
     }
     const promise = this.session.permissionGate.setPending(permReq);
-    this.session.emit("permission_request", permReq);
+    this.session.emit(SessionEv.PERMISSION_REQUEST, permReq);
     await this.adapter.sendPermissionRequest(this.session.id, permReq);
     const optionId = await promise;
-    this.deps.eventBus?.emit("permission:resolved", {
+    this.deps.eventBus?.emit(BusEvent.PERMISSION_RESOLVED, {
       sessionId: this.session.id,
       requestId: permReq.id,
       decision: optionId,
@@ -13509,7 +13665,7 @@ var SessionBridge = class {
   /** Emit permission:afterResolve middleware hook (fire-and-forget) */
   emitAfterResolve(mw, requestId, decision, userId, startTime) {
     if (mw) {
-      mw.execute("permission:afterResolve", {
+      mw.execute(Hook.PERMISSION_AFTER_RESOLVE, {
         sessionId: this.session.id,
         requestId,
         decision,
@@ -13523,6 +13679,7 @@ var SessionBridge = class {
 
 // src/core/sessions/session-factory.ts
 init_log();
+init_events();
 var log7 = createChildLogger({ module: "session-factory" });
 var SessionFactory = class {
   constructor(agentManager, sessionManager, speechServiceAccessor, eventBus, instanceRoot) {
@@ -13565,7 +13722,7 @@ var SessionFactory = class {
         threadId: ""
         // threadId is assigned after session creation
       };
-      const result = await this.middlewareChain.execute("session:beforeCreate", payload, async (p) => p);
+      const result = await this.middlewareChain.execute(Hook.SESSION_BEFORE_CREATE, payload, async (p) => p);
       if (!result) throw new Error("Session creation blocked by middleware");
       createParams = {
         ...params,
@@ -13574,6 +13731,7 @@ var SessionFactory = class {
         channelId: result.channelId
       };
     }
+    const configAllowedPaths = this.configManager?.get().workspace?.security?.allowedPaths ?? [];
     let agentInstance;
     try {
       if (createParams.resumeAgentSessionId) {
@@ -13581,7 +13739,8 @@ var SessionFactory = class {
           agentInstance = await this.agentManager.resume(
             createParams.agentName,
             createParams.workingDirectory,
-            createParams.resumeAgentSessionId
+            createParams.resumeAgentSessionId,
+            configAllowedPaths
           );
         } catch (resumeErr) {
           log7.warn(
@@ -13590,13 +13749,15 @@ var SessionFactory = class {
           );
           agentInstance = await this.agentManager.spawn(
             createParams.agentName,
-            createParams.workingDirectory
+            createParams.workingDirectory,
+            configAllowedPaths
           );
         }
       } else {
         agentInstance = await this.agentManager.spawn(
           createParams.agentName,
-          createParams.workingDirectory
+          createParams.workingDirectory,
+          configAllowedPaths
         );
       }
     } catch (err) {
@@ -13628,7 +13789,7 @@ var SessionFactory = class {
         message: guidanceLines.join("\n")
       };
       const failedSessionId = createParams.existingSessionId ?? `failed-${Date.now()}`;
-      this.eventBus.emit("agent:event", {
+      this.eventBus.emit(BusEvent.AGENT_EVENT, {
         sessionId: failedSessionId,
         event: guidance
       });
@@ -13654,11 +13815,13 @@ var SessionFactory = class {
     }
     session.applySpawnResponse(agentInstance.initialSessionResponse, agentInstance.agentCapabilities);
     this.sessionManager.registerSession(session);
-    this.eventBus.emit("session:created", {
-      sessionId: session.id,
-      agent: session.agentName,
-      status: session.status
-    });
+    if (!session.isAssistant) {
+      this.eventBus.emit(BusEvent.SESSION_CREATED, {
+        sessionId: session.id,
+        agent: session.agentName,
+        status: session.status
+      });
+    }
     return session;
   }
   /**
@@ -13676,6 +13839,7 @@ var SessionFactory = class {
     if (!this.sessionStore || !this.createFullSession) return null;
     const record = this.sessionStore.get(sessionId);
     if (!record) return null;
+    if (record.isAssistant) return null;
     if (record.status === "error" || record.status === "cancelled") return null;
     const existing = this.resumeLocks.get(sessionId);
     if (existing) return existing;
@@ -13743,6 +13907,7 @@ var SessionFactory = class {
       log7.debug({ threadId, channelId }, "No session record found for thread");
       return null;
     }
+    if (record.isAssistant) return null;
     if (record.status === "error" || record.status === "cancelled") {
       log7.warn(
         { threadId, sessionId: record.sessionId, status: record.status },
@@ -13902,9 +14067,9 @@ var SessionFactory = class {
     return { session, contextResult };
   }
   wireSideEffects(session, deps) {
-    session.on("agent_event", (event) => {
+    session.on(SessionEv.AGENT_EVENT, (event) => {
       if (event.type !== "usage") return;
-      deps.eventBus.emit("usage:recorded", {
+      deps.eventBus.emit(BusEvent.USAGE_RECORDED, {
         sessionId: session.id,
         agentName: session.agentName,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13913,7 +14078,7 @@ var SessionFactory = class {
         cost: event.cost
       });
     });
-    session.on("status_change", (_from, to) => {
+    session.on(SessionEv.STATUS_CHANGE, (_from, to) => {
       if ((to === "finished" || to === "cancelled") && deps.tunnelService) {
         deps.tunnelService.stopBySession(session.id).then((stopped) => {
           for (const entry of stopped) {
@@ -13993,6 +14158,14 @@ var JsonFileSessionStore = class {
     }
     return void 0;
   }
+  findAssistant(channelId) {
+    for (const record of this.records.values()) {
+      if (record.isAssistant === true && record.channelId === channelId) {
+        return record;
+      }
+    }
+    return void 0;
+  }
   list(channelId) {
     const all = [...this.records.values()];
     if (channelId) return all.filter((r) => r.channelId === channelId);
@@ -14072,6 +14245,8 @@ var JsonFileSessionStore = class {
     for (const [id, record] of this.records) {
       if (record.status === "active" || record.status === "initializing")
         continue;
+      if (record.isAssistant === true)
+        continue;
       const raw = record.lastActiveAt;
       if (!raw) continue;
       const lastActive = new Date(raw).getTime();
@@ -14100,6 +14275,7 @@ init_agent_registry();
 // src/core/agent-switch-handler.ts
 init_agent_registry();
 init_log();
+init_events();
 var log9 = createChildLogger({ module: "agent-switch" });
 var AgentSwitchHandler = class {
   constructor(deps) {
@@ -14125,7 +14301,7 @@ var AgentSwitchHandler = class {
     if (!agentDef) throw new Error(`Agent "${toAgent}" is not installed`);
     const fromAgent = session.agentName;
     const middlewareChain = this.deps.getMiddlewareChain();
-    const result = await middlewareChain?.execute("agent:beforeSwitch", {
+    const result = await middlewareChain?.execute(Hook.AGENT_BEFORE_SWITCH, {
       sessionId,
       fromAgent,
       toAgent
@@ -14139,9 +14315,9 @@ var AgentSwitchHandler = class {
       type: "system_message",
       message: `Switching from ${fromAgent} to ${toAgent}...`
     };
-    session.emit("agent_event", startEvent);
-    eventBus.emit("agent:event", { sessionId, event: startEvent });
-    eventBus.emit("session:agentSwitch", {
+    session.emit(SessionEv.AGENT_EVENT, startEvent);
+    eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, event: startEvent });
+    eventBus.emit(BusEvent.SESSION_AGENT_SWITCH, {
       sessionId,
       fromAgent,
       toAgent,
@@ -14165,11 +14341,12 @@ var AgentSwitchHandler = class {
     }
     const fromAgentSessionId = session.agentSessionId;
     const fileService = this.deps.getService("file-service");
+    const configAllowedPaths = configManager.get().workspace?.security?.allowedPaths ?? [];
     try {
       await session.switchAgent(toAgent, async () => {
         if (canResume) {
           try {
-            const instance2 = await agentManager.resume(toAgent, session.workingDirectory, lastEntry.agentSessionId);
+            const instance2 = await agentManager.resume(toAgent, session.workingDirectory, lastEntry.agentSessionId, configAllowedPaths);
             if (fileService) instance2.addAllowedPath(fileService.baseDir);
             resumed = true;
             return instance2;
@@ -14177,7 +14354,7 @@ var AgentSwitchHandler = class {
             log9.warn({ sessionId, toAgent }, "Resume failed, falling back to new agent with context injection");
           }
         }
-        const instance = await agentManager.spawn(toAgent, session.workingDirectory);
+        const instance = await agentManager.spawn(toAgent, session.workingDirectory, configAllowedPaths);
         if (fileService) instance.addAllowedPath(fileService.baseDir);
         try {
           const contextService = this.deps.getService("context");
@@ -14201,9 +14378,9 @@ var AgentSwitchHandler = class {
         type: "system_message",
         message: resumed ? `Switched to ${toAgent} (resumed previous session).` : `Switched to ${toAgent} (new session).`
       };
-      session.emit("agent_event", successEvent);
-      eventBus.emit("agent:event", { sessionId, event: successEvent });
-      eventBus.emit("session:agentSwitch", {
+      session.emit(SessionEv.AGENT_EVENT, successEvent);
+      eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, event: successEvent });
+      eventBus.emit(BusEvent.SESSION_AGENT_SWITCH, {
         sessionId,
         fromAgent,
         toAgent,
@@ -14216,9 +14393,9 @@ var AgentSwitchHandler = class {
         type: "system_message",
         message: `Failed to switch to ${toAgent}: ${errorMessage}`
       };
-      session.emit("agent_event", failedEvent);
-      eventBus.emit("agent:event", { sessionId, event: failedEvent });
-      eventBus.emit("session:agentSwitch", {
+      session.emit(SessionEv.AGENT_EVENT, failedEvent);
+      eventBus.emit(BusEvent.AGENT_EVENT, { sessionId, event: failedEvent });
+      eventBus.emit(BusEvent.SESSION_AGENT_SWITCH, {
         sessionId,
         fromAgent,
         toAgent,
@@ -14267,7 +14444,7 @@ var AgentSwitchHandler = class {
       currentPromptCount: 0,
       agentSwitchHistory: session.agentSwitchHistory
     });
-    middlewareChain?.execute("agent:afterSwitch", {
+    middlewareChain?.execute(Hook.AGENT_AFTER_SWITCH, {
       sessionId,
       fromAgent,
       toAgent,
@@ -15109,6 +15286,7 @@ function createPluginContext(opts) {
 }
 
 // src/core/plugin/lifecycle-manager.ts
+init_events();
 var SETUP_TIMEOUT_MS = 3e4;
 var TEARDOWN_TIMEOUT_MS = 1e4;
 function withTimeout(promise, ms, label) {
@@ -15254,7 +15432,7 @@ var LifecycleManager = class {
       }
       const registryEntry = this.pluginRegistry?.get(plugin.name);
       if (registryEntry && registryEntry.enabled === false) {
-        this.eventBus?.emit("plugin:disabled", { name: plugin.name });
+        this.eventBus?.emit(BusEvent.PLUGIN_DISABLED, { name: plugin.name });
         continue;
       }
       if (registryEntry && plugin.migrate && registryEntry.version !== plugin.version && this.settingsManager) {
@@ -15297,7 +15475,7 @@ var LifecycleManager = class {
         if (!validation.valid) {
           this._failed.add(plugin.name);
           this.getPluginLogger(plugin.name).error(`Settings validation failed: ${validation.errors?.join("; ")}`);
-          this.eventBus?.emit("plugin:failed", { name: plugin.name, error: `Settings validation failed: ${validation.errors?.join("; ")}` });
+          this.eventBus?.emit(BusEvent.PLUGIN_FAILED, { name: plugin.name, error: `Settings validation failed: ${validation.errors?.join("; ")}` });
           continue;
         }
       }
@@ -15320,13 +15498,13 @@ var LifecycleManager = class {
         await withTimeout(plugin.setup(ctx), SETUP_TIMEOUT_MS, `${plugin.name}.setup()`);
         this.contexts.set(plugin.name, ctx);
         this._loaded.add(plugin.name);
-        this.eventBus?.emit("plugin:loaded", { name: plugin.name, version: plugin.version });
+        this.eventBus?.emit(BusEvent.PLUGIN_LOADED, { name: plugin.name, version: plugin.version });
       } catch (err) {
         this._failed.add(plugin.name);
         ctx.cleanup();
         console.error(`[lifecycle] Plugin ${plugin.name} setup() FAILED:`, err);
         this.getPluginLogger(plugin.name).error(`setup() failed: ${err}`);
-        this.eventBus?.emit("plugin:failed", { name: plugin.name, error: String(err) });
+        this.eventBus?.emit(BusEvent.PLUGIN_FAILED, { name: plugin.name, error: String(err) });
       }
     }
   }
@@ -15347,7 +15525,7 @@ var LifecycleManager = class {
     this._loaded.delete(name);
     this._failed.delete(name);
     this.loadOrder = this.loadOrder.filter((p) => p.name !== name);
-    this.eventBus?.emit("plugin:unloaded", { name });
+    this.eventBus?.emit(BusEvent.PLUGIN_UNLOADED, { name });
   }
   async shutdown() {
     const reversed = [...this.loadOrder].reverse();
@@ -15364,7 +15542,7 @@ var LifecycleManager = class {
         ctx.cleanup();
         this.contexts.delete(plugin.name);
       }
-      this.eventBus?.emit("plugin:unloaded", { name: plugin.name });
+      this.eventBus?.emit(BusEvent.PLUGIN_UNLOADED, { name: plugin.name });
     }
     this._loaded.clear();
     this.loadOrder = [];
@@ -15512,21 +15690,25 @@ var AssistantManager = class {
     this.registry = registry;
   }
   sessions = /* @__PURE__ */ new Map();
-  respawning = /* @__PURE__ */ new Set();
   pendingSystemPrompts = /* @__PURE__ */ new Map();
-  async spawn(channelId, threadId) {
+  async getOrSpawn(channelId, threadId) {
+    const existing = this.core.sessionStore?.findAssistant(channelId);
     const session = await this.core.createSession({
       channelId,
       agentName: this.core.configManager.get().defaultAgent,
       workingDirectory: this.core.configManager.resolveWorkspace(),
       initialName: "Assistant",
       isAssistant: true,
-      threadId
+      threadId,
+      existingSessionId: existing?.sessionId
     });
     this.sessions.set(channelId, session);
     const systemPrompt = this.registry.buildSystemPrompt(channelId);
     this.pendingSystemPrompts.set(channelId, systemPrompt);
-    log15.info({ sessionId: session.id, channelId }, "Assistant spawned (system prompt deferred)");
+    log15.info(
+      { sessionId: session.id, channelId, reused: !!existing },
+      existing ? "Assistant session reused (system prompt deferred)" : "Assistant spawned (system prompt deferred)"
+    );
     return session;
   }
   get(channelId) {
@@ -15547,19 +15729,6 @@ var AssistantManager = class {
     }
     return false;
   }
-  async respawn(channelId, threadId) {
-    if (this.respawning.has(channelId)) {
-      return this.sessions.get(channelId);
-    }
-    this.respawning.add(channelId);
-    try {
-      const old = this.sessions.get(channelId);
-      if (old) await old.destroy();
-      return await this.spawn(channelId, threadId);
-    } finally {
-      this.respawning.delete(channelId);
-    }
-  }
 };
 
 // src/core/assistant/sections/sessions.ts
@@ -15729,6 +15898,7 @@ function registerCoreMenuItems(registry) {
 
 // src/core/core.ts
 init_log();
+init_events();
 var log16 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
@@ -15963,7 +16133,7 @@ var OpenACPCore = class {
     );
     if (this.lifecycleManager?.middlewareChain) {
       const result = await this.lifecycleManager.middlewareChain.execute(
-        "message:incoming",
+        Hook.MESSAGE_INCOMING,
         message,
         async (msg) => msg
       );
@@ -16015,9 +16185,10 @@ ${text3}`;
       }
     }
     const sourceAdapterId = message.routing?.sourceAdapterId ?? message.channelId;
+    const routing = sourceAdapterId !== message.routing?.sourceAdapterId ? { ...message.routing, sourceAdapterId } : message.routing;
     if (sourceAdapterId && sourceAdapterId !== "sse" && sourceAdapterId !== "api") {
       const turnId = nanoid3(8);
-      this.eventBus.emit("message:queued", {
+      this.eventBus.emit(BusEvent.MESSAGE_QUEUED, {
         sessionId: session.id,
         turnId,
         text: text3,
@@ -16026,9 +16197,9 @@ ${text3}`;
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         queueDepth: session.queueDepth
       });
-      await session.enqueuePrompt(text3, message.attachments, message.routing, turnId);
+      await session.enqueuePrompt(text3, message.attachments, routing, turnId);
     } else {
-      await session.enqueuePrompt(text3, message.attachments, message.routing);
+      await session.enqueuePrompt(text3, message.attachments, routing);
     }
   }
   // --- Unified Session Creation Pipeline ---
@@ -16072,6 +16243,7 @@ ${text3}`;
       createdAt: session.createdAt.toISOString(),
       lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
       name: session.name,
+      isAssistant: params.isAssistant,
       platform: platform2,
       platforms,
       firstAgent: session.firstAgent,
@@ -16087,7 +16259,7 @@ ${text3}`;
         log16.warn({ err, sessionId: session.id }, "Failed to flush pending skill commands");
       });
       if (params.createThread && session.threadId) {
-        this.eventBus.emit("session:threadReady", {
+        this.eventBus.emit(BusEvent.SESSION_THREAD_READY, {
           sessionId: session.id,
           channelId: params.channelId,
           threadId: session.threadId
@@ -16111,6 +16283,36 @@ ${text3}`;
         );
         return allowOption.id;
       };
+      session.on(SessionEv.NAMED, async (name) => {
+        await this.sessionManager.patchRecord(session.id, { name });
+        this.eventBus.emit(BusEvent.SESSION_UPDATED, { sessionId: session.id, name });
+      });
+      const mw = () => this.lifecycleManager?.middlewareChain;
+      session.on(SessionEv.AGENT_EVENT, async (event) => {
+        let processedEvent = event;
+        const chain = mw();
+        if (chain) {
+          const result = await chain.execute(Hook.AGENT_BEFORE_EVENT, { sessionId: session.id, event }, async (e) => e);
+          if (!result) return;
+          processedEvent = result.event;
+        }
+        if (processedEvent.type === "session_end") {
+          session.finish(processedEvent.reason);
+        } else if (processedEvent.type === "error") {
+          session.fail(processedEvent.message);
+        }
+        this.eventBus.emit(BusEvent.AGENT_EVENT, { sessionId: session.id, event: processedEvent });
+      });
+      session.on(SessionEv.STATUS_CHANGE, (_from, to) => {
+        this.sessionManager.patchRecord(session.id, {
+          status: to,
+          lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        this.eventBus.emit(BusEvent.SESSION_UPDATED, { sessionId: session.id, status: to });
+      });
+      session.on(SessionEv.PROMPT_COUNT_CHANGED, (count) => {
+        this.sessionManager.patchRecord(session.id, { currentPromptCount: count });
+      });
     }
     this.sessionFactory.wireSideEffects(session, {
       eventBus: this.eventBus,