@openacp/cli 2026.405.2 → 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";
@@ -8096,7 +8184,10 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
     const menuRegistry = core.lifecycleManager?.serviceRegistry?.get("menu-registry");
     if (!menuRegistry) return;
     const item = menuRegistry.getItem(itemId);
-    if (!item) return;
+    if (!item) {
+      log30.warn({ itemId }, "Menu item not found in registry");
+      return;
+    }
     const topicId = ctx.callbackQuery.message?.message_thread_id;
     const registry = core.lifecycleManager?.serviceRegistry?.get("command-registry");
     switch (item.action.type) {
@@ -8180,7 +8271,7 @@ ${lines}`, { parse_mode: "HTML" }).catch(() => {
     }
   });
 }
-var STATIC_COMMANDS;
+var log30, STATIC_COMMANDS;
 var init_commands = __esm({
   "src/plugins/telegram/commands/index.ts"() {
     "use strict";
@@ -8193,6 +8284,7 @@ var init_commands = __esm({
     init_tunnel2();
     init_switch();
     init_telegram_overrides();
+    init_log();
     init_menu();
     init_menu();
     init_telegram_overrides();
@@ -8204,6 +8296,7 @@ var init_commands = __esm({
     init_settings();
     init_doctor2();
     init_resume();
+    log30 = createChildLogger({ module: "telegram-menu-callbacks" });
     STATIC_COMMANDS = [
       { command: "new", description: "Create new session" },
       { command: "newchat", description: "New chat, same agent & workspace" },
@@ -8216,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" },
@@ -8239,14 +8331,14 @@ var init_commands = __esm({
 // src/plugins/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard11 } from "grammy";
 import { nanoid as nanoid4 } from "nanoid";
-var log30, PermissionHandler;
+var log31, PermissionHandler;
 var init_permissions = __esm({
   "src/plugins/telegram/permissions.ts"() {
     "use strict";
     init_formatting();
     init_topics();
     init_log();
-    log30 = createChildLogger({ module: "telegram-permissions" });
+    log31 = createChildLogger({ module: "telegram-permissions" });
     PermissionHandler = class {
       constructor(bot, chatId, getSession, sendNotification) {
         this.bot = bot;
@@ -8290,11 +8382,11 @@ ${escapeHtml(request.description)}`,
         });
       }
       setupCallbackHandler() {
-        this.bot.on("callback_query:data", async (ctx) => {
+        this.bot.on("callback_query:data", async (ctx, next) => {
           const data = ctx.callbackQuery.data;
-          if (!data.startsWith("p:")) return;
+          if (!data.startsWith("p:")) return next();
           const parts = data.split(":");
-          if (parts.length < 3) return;
+          if (parts.length < 3) return next();
           const [, callbackKey, optionId] = parts;
           const pending = this.pending.get(callbackKey);
           if (!pending) {
@@ -8306,7 +8398,7 @@ ${escapeHtml(request.description)}`,
           }
           const session = this.getSession(pending.sessionId);
           const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-          log30.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+          log31.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
           if (session?.permissionGate.requestId === pending.requestId) {
             session.permissionGate.resolve(optionId);
           }
@@ -8326,7 +8418,7 @@ ${escapeHtml(request.description)}`,
 });
 
 // src/plugins/telegram/activity.ts
-var log31, THINKING_REFRESH_MS, THINKING_MAX_MS, ThinkingIndicator, ToolCard, ActivityTracker2;
+var log32, THINKING_REFRESH_MS, THINKING_MAX_MS, ThinkingIndicator, ToolCard, ActivityTracker2;
 var init_activity = __esm({
   "src/plugins/telegram/activity.ts"() {
     "use strict";
@@ -8336,7 +8428,7 @@ var init_activity = __esm({
     init_stream_accumulator();
     init_stream_accumulator();
     init_display_spec_builder();
-    log31 = createChildLogger({ module: "telegram:activity" });
+    log32 = createChildLogger({ module: "telegram:activity" });
     THINKING_REFRESH_MS = 15e3;
     THINKING_MAX_MS = 3 * 60 * 1e3;
     ThinkingIndicator = class {
@@ -8377,7 +8469,7 @@ var init_activity = __esm({
             }
           }
         } catch (err) {
-          log31.warn({ err }, "ThinkingIndicator.show() failed");
+          log32.warn({ err }, "ThinkingIndicator.show() failed");
         } finally {
           this.sending = false;
         }
@@ -8545,7 +8637,7 @@ var init_activity = __esm({
             this.tracer?.log("telegram", { action: "telegram:delete:overflow", sessionId: this.sessionId, msgId: staleId });
           }
         } catch (err) {
-          log31.warn({ err }, "[ToolCard] send/edit failed");
+          log32.warn({ err }, "[ToolCard] send/edit failed");
         }
       }
     };
@@ -8649,7 +8741,7 @@ var init_activity = __esm({
         const entry = this.toolStateMap.merge(id, status, rawInput, content, viewerLinks, diffStats);
         if (!existed || !entry) return;
         if (viewerLinks || entry.viewerLinks) {
-          log31.debug({ toolId: id, status, hasIncomingLinks: !!viewerLinks, hasEntryLinks: !!entry.viewerLinks, entryLinks: entry.viewerLinks }, "toolUpdate: viewer links trace");
+          log32.debug({ toolId: id, status, hasIncomingLinks: !!viewerLinks, hasEntryLinks: !!entry.viewerLinks, entryLinks: entry.viewerLinks }, "toolUpdate: viewer links trace");
         }
         const spec = this.specBuilder.buildToolSpec(entry, this._outputMode, this.sessionContext);
         this.toolCard.updateFromSpec(spec);
@@ -8968,13 +9060,13 @@ var init_draft_manager = __esm({
 });
 
 // src/plugins/telegram/skill-command-manager.ts
-var log32, SkillCommandManager;
+var log33, SkillCommandManager;
 var init_skill_command_manager = __esm({
   "src/plugins/telegram/skill-command-manager.ts"() {
     "use strict";
     init_commands();
     init_log();
-    log32 = createChildLogger({ module: "skill-commands" });
+    log33 = createChildLogger({ module: "skill-commands" });
     SkillCommandManager = class {
       // sessionId → pinned msgId
       constructor(bot, chatId, sendQueue, sessionManager) {
@@ -9040,7 +9132,7 @@ var init_skill_command_manager = __esm({
             disable_notification: true
           });
         } catch (err) {
-          log32.error({ err, sessionId }, "Failed to send skill commands");
+          log33.error({ err, sessionId }, "Failed to send skill commands");
         }
       }
       async cleanup(sessionId) {
@@ -9219,7 +9311,7 @@ async function validateBotAdmin(token, chatId) {
       };
     }
     const { status } = data.result;
-    log33.info(
+    log34.info(
       { status, can_manage_topics: data.result.can_manage_topics, raw_result: data.result },
       "validateBotAdmin: getChatMember raw result"
     );
@@ -9239,7 +9331,7 @@ async function validateBotAdmin(token, chatId) {
 }
 async function checkTopicsPrerequisites(token, chatId) {
   const issues = [];
-  log33.info({ chatId }, "checkTopicsPrerequisites: starting checks");
+  log34.info({ chatId }, "checkTopicsPrerequisites: starting checks");
   try {
     const res = await fetch(`https://api.telegram.org/bot${token}/getChat`, {
       method: "POST",
@@ -9247,7 +9339,7 @@ async function checkTopicsPrerequisites(token, chatId) {
       body: JSON.stringify({ chat_id: chatId })
     });
     const data = await res.json();
-    log33.info(
+    log34.info(
       { chatId, apiOk: data.ok, is_forum: data.result?.is_forum, type: data.result?.type, title: data.result?.title },
       "checkTopicsPrerequisites: getChat result"
     );
@@ -9257,11 +9349,11 @@ async function checkTopicsPrerequisites(token, chatId) {
       );
     }
   } catch (err) {
-    log33.warn({ err, chatId }, "checkTopicsPrerequisites: getChat failed (network error)");
+    log34.warn({ err, chatId }, "checkTopicsPrerequisites: getChat failed (network error)");
     issues.push("\u274C Could not check if Topics are enabled (network error).");
   }
   const adminResult = await validateBotAdmin(token, chatId);
-  log33.info(
+  log34.info(
     { chatId, adminOk: adminResult.ok, canManageTopics: adminResult.ok ? adminResult.canManageTopics : void 0, error: !adminResult.ok ? adminResult.error : void 0 },
     "checkTopicsPrerequisites: validateBotAdmin result"
   );
@@ -9275,16 +9367,16 @@ async function checkTopicsPrerequisites(token, chatId) {
       '\u274C Bot cannot manage topics.\n\u2192 In Admin settings, enable the "Manage Topics" permission'
     );
   }
-  log33.info({ chatId, issueCount: issues.length, ok: issues.length === 0 }, "checkTopicsPrerequisites: result");
+  log34.info({ chatId, issueCount: issues.length, ok: issues.length === 0 }, "checkTopicsPrerequisites: result");
   if (issues.length > 0) return { ok: false, issues };
   return { ok: true };
 }
-var log33;
+var log34;
 var init_validators = __esm({
   "src/plugins/telegram/validators.ts"() {
     "use strict";
     init_log();
-    log33 = createChildLogger({ module: "telegram-validators" });
+    log34 = createChildLogger({ module: "telegram-validators" });
   }
 });
 
@@ -9303,10 +9395,11 @@ function patchedFetch(input2, init) {
   }
   return fetch(input2, init);
 }
-var log34, TelegramAdapter;
+var log35, TelegramAdapter;
 var init_adapter = __esm({
   "src/plugins/telegram/adapter.ts"() {
     "use strict";
+    init_events();
     init_log();
     init_topics();
     init_commands();
@@ -9322,7 +9415,7 @@ var init_adapter = __esm({
     init_messaging_adapter();
     init_renderer2();
     init_output_mode_resolver();
-    log34 = createChildLogger({ module: "telegram" });
+    log35 = createChildLogger({ module: "telegram" });
     TelegramAdapter = class extends MessagingAdapter {
       name = "telegram";
       renderer = new TelegramRenderer();
@@ -9449,7 +9542,7 @@ var init_adapter = __esm({
         );
         this.bot.catch((err) => {
           const rootCause = err.error instanceof Error ? err.error : err;
-          log34.error({ err: rootCause }, "Telegram bot error");
+          log35.error({ err: rootCause }, "Telegram bot error");
         });
         this.bot.api.config.use(async (prev, method, payload, signal) => {
           const maxRetries = 3;
@@ -9467,7 +9560,7 @@ var init_adapter = __esm({
             if (rateLimitedMethods.includes(method)) {
               this.sendQueue.onRateLimited();
             }
-            log34.warn(
+            log35.warn(
               { method, retryAfter, attempt: attempt + 1 },
               "Rate limited by Telegram, retrying"
             );
@@ -9655,9 +9748,9 @@ ${p}` : p;
         this.setupRoutes();
         this.bot.start({
           allowed_updates: ["message", "callback_query"],
-          onStart: () => log34.info({ chatId: this.telegramConfig.chatId }, "Telegram bot started")
+          onStart: () => log35.info({ chatId: this.telegramConfig.chatId }, "Telegram bot started")
         });
-        log34.info(
+        log35.info(
           {
             chatId: this.telegramConfig.chatId,
             notificationTopicId: this.telegramConfig.notificationTopicId,
@@ -9671,12 +9764,12 @@ ${p}` : p;
           this.telegramConfig.chatId
         );
         if (prereqResult.ok) {
-          log34.info("Telegram adapter: prerequisites OK, initializing topic-dependent features");
+          log35.info("Telegram adapter: prerequisites OK, initializing topic-dependent features");
           await this.initTopicDependentFeatures();
         } else {
-          log34.warn({ issues: prereqResult.issues }, "Telegram adapter: prerequisites NOT met, starting watcher");
+          log35.warn({ issues: prereqResult.issues }, "Telegram adapter: prerequisites NOT met, starting watcher");
           for (const issue of prereqResult.issues) {
-            log34.warn({ issue }, "Telegram prerequisite not met");
+            log35.warn({ issue }, "Telegram prerequisite not met");
           }
           this.startPrerequisiteWatcher(prereqResult.issues);
         }
@@ -9692,7 +9785,7 @@ ${p}` : p;
           } catch (err) {
             if (attempt === maxRetries) throw err;
             const delay = baseDelayMs * Math.pow(2, attempt - 1);
-            log34.warn(
+            log35.warn(
               { err, attempt, maxRetries, delayMs: delay, operation: label },
               `${label} failed, retrying in ${delay}ms`
             );
@@ -9712,12 +9805,12 @@ ${p}` : p;
           }),
           "setMyCommands"
         ).catch((err) => {
-          log34.warn({ err }, "Failed to register Telegram commands after retries (non-critical)");
+          log35.warn({ err }, "Failed to register Telegram commands after retries (non-critical)");
         });
       }
       async initTopicDependentFeatures() {
         if (this._topicsInitialized) return;
-        log34.info(
+        log35.info(
           { notificationTopicId: this.telegramConfig.notificationTopicId, assistantTopicId: this.telegramConfig.assistantTopicId },
           "initTopicDependentFeatures: starting (existing IDs in config)"
         );
@@ -9742,7 +9835,7 @@ ${p}` : p;
         this.assistantTopicId = topics.assistantTopicId;
         this._systemTopicIds.notificationTopicId = topics.notificationTopicId;
         this._systemTopicIds.assistantTopicId = topics.assistantTopicId;
-        log34.info(
+        log35.info(
           { notificationTopicId: this.notificationTopicId, assistantTopicId: this.assistantTopicId },
           "initTopicDependentFeatures: topics ready"
         );
@@ -9773,16 +9866,16 @@ ${p}` : p;
           ).then((msg) => {
             if (msg) this.storeControlMsgId(sessionId, msg.message_id);
           }).catch((err) => {
-            log34.warn({ err, sessionId }, "Failed to send initial messages for new session");
+            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(() => {
           });
         };
         this.core.eventBus.on("session:configChanged", this._configChangedHandler);
-        log34.info({ assistantTopicId: this.assistantTopicId }, "initTopicDependentFeatures: sending welcome message");
+        log35.info({ assistantTopicId: this.assistantTopicId }, "initTopicDependentFeatures: sending welcome message");
         try {
           const config = this.core.configManager.get();
           const agents = this.core.agentManager.getAvailableAgents();
@@ -9804,17 +9897,17 @@ ${p}` : p;
               this.core.lifecycleManager?.serviceRegistry?.get("menu-registry")
             )
           });
-          log34.info("initTopicDependentFeatures: welcome message sent");
+          log35.info("initTopicDependentFeatures: welcome message sent");
         } catch (err) {
-          log34.warn({ err }, "Failed to send welcome message");
+          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) {
-          log34.error({ err }, "Failed to spawn assistant");
+          log35.error({ err }, "Failed to spawn assistant");
         }
         this._topicsInitialized = true;
-        log34.info("Telegram adapter fully initialized");
+        log35.info("Telegram adapter fully initialized");
       }
       startPrerequisiteWatcher(issues) {
         const setupMessage = `\u26A0\uFE0F <b>OpenACP needs setup before it can start.</b>
@@ -9825,7 +9918,7 @@ OpenACP will automatically retry until this is resolved.`;
         this.bot.api.sendMessage(this.telegramConfig.chatId, setupMessage, {
           parse_mode: "HTML"
         }).catch((err) => {
-          log34.warn({ err }, "Failed to send setup guidance to General topic");
+          log35.warn({ err }, "Failed to send setup guidance to General topic");
         });
         const schedule = [5e3, 1e4, 3e4];
         let attempt = 1;
@@ -9838,7 +9931,7 @@ OpenACP will automatically retry until this is resolved.`;
           );
           if (result.ok) {
             this._prerequisiteWatcher = null;
-            log34.info("Prerequisites met \u2014 completing Telegram adapter initialization");
+            log35.info("Prerequisites met \u2014 completing Telegram adapter initialization");
             try {
               await this.initTopicDependentFeatures();
               await this.bot.api.sendMessage(
@@ -9847,11 +9940,11 @@ OpenACP will automatically retry until this is resolved.`;
                 { parse_mode: "HTML" }
               );
             } catch (err) {
-              log34.error({ err }, "Failed to complete initialization after prerequisites met");
+              log35.error({ err }, "Failed to complete initialization after prerequisites met");
             }
             return;
           }
-          log34.debug({ issues: result.issues }, "Prerequisites not yet met, retrying");
+          log35.debug({ issues: result.issues }, "Prerequisites not yet met, retrying");
           const delay = schedule[Math.min(attempt, schedule.length - 1)];
           attempt++;
           this._prerequisiteWatcher = setTimeout(retry, delay);
@@ -9868,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) {
@@ -9877,7 +9970,7 @@ OpenACP will automatically retry until this is resolved.`;
         }
         this.sendQueue.clear();
         await this.bot.stop();
-        log34.info("Telegram bot stopped");
+        log35.info("Telegram bot stopped");
       }
       // --- CommandRegistry response rendering ---
       async renderCommandResponse(response, chatId, topicId) {
@@ -9962,6 +10055,13 @@ ${lines.join("\n")}`;
       }
       setupRoutes() {
         this.bot.on("message:text", async (ctx) => {
+          if (!this._topicsInitialized) {
+            await ctx.reply(
+              "\u23F3 OpenACP is still setting up. Check the General topic for instructions."
+            ).catch(() => {
+            });
+            return;
+          }
           const threadId = ctx.message.message_thread_id;
           const text3 = ctx.message.text;
           if (!threadId) {
@@ -9994,7 +10094,7 @@ ${lines.join("\n")}`;
             threadId: String(threadId),
             userId: String(ctx.from.id),
             text: forwardText
-          }).catch((err) => log34.error({ err }, "handleMessage error"));
+          }).catch((err) => log35.error({ err }, "handleMessage error"));
         });
         this.bot.on("message:photo", async (ctx) => {
           const threadId = ctx.message.message_thread_id;
@@ -10083,7 +10183,7 @@ ${lines.join("\n")}`;
         if (session.archiving) return;
         const threadId = Number(session.threadId);
         if (!threadId || isNaN(threadId)) {
-          log34.warn(
+          log35.warn(
             { sessionId, threadId: session.threadId },
             "Session has no valid threadId, skipping message"
           );
@@ -10099,7 +10199,7 @@ ${lines.join("\n")}`;
             this._sessionThreadIds.delete(sessionId);
           }
         }).catch((err) => {
-          log34.warn({ err, sessionId }, "Dispatch queue error");
+          log35.warn({ err, sessionId }, "Dispatch queue error");
         });
         this._dispatchQueues.set(sessionId, next);
         await next;
@@ -10221,7 +10321,7 @@ ${lines.join("\n")}`;
           );
           usageMsgId = result?.message_id;
         } catch (err) {
-          log34.warn({ err, sessionId }, "Failed to send usage message");
+          log35.warn({ err, sessionId }, "Failed to send usage message");
         }
         if (this.notificationTopicId && sessionId !== this.core.assistantManager?.get("telegram")?.id) {
           const sess = this.core.sessionManager.getSession(sessionId);
@@ -10249,7 +10349,7 @@ Task completed.
         if (!content.attachment) return;
         const { attachment } = content;
         if (attachment.size > 50 * 1024 * 1024) {
-          log34.warn(
+          log35.warn(
             {
               sessionId,
               fileName: attachment.fileName,
@@ -10293,7 +10393,7 @@ Task completed.
             );
           }
         } catch (err) {
-          log34.error(
+          log35.error(
             { err, sessionId, fileName: attachment.fileName },
             "Failed to send attachment"
           );
@@ -10392,7 +10492,7 @@ Task completed.
       }
       async sendPermissionRequest(sessionId, request) {
         this.getTracer(sessionId)?.log("telegram", { action: "permission:send", sessionId, requestId: request.id, description: request.description });
-        log34.info({ sessionId, requestId: request.id }, "Permission request sent");
+        log35.info({ sessionId, requestId: request.id }, "Permission request sent");
         const session = this.core.sessionManager.getSession(sessionId);
         if (!session) return;
         await this.sendQueue.enqueue(
@@ -10402,7 +10502,7 @@ Task completed.
       async sendNotification(notification) {
         this.getTracer(notification.sessionId)?.log("telegram", { action: "notification:send", sessionId: notification.sessionId, type: notification.type });
         if (notification.sessionId === this.core.assistantManager?.get("telegram")?.id) return;
-        log34.info(
+        log35.info(
           { sessionId: notification.sessionId, type: notification.type },
           "Notification sent"
         );
@@ -10441,7 +10541,7 @@ Task completed.
       }
       async createSessionThread(sessionId, name) {
         this.getTracer(sessionId)?.log("telegram", { action: "thread:create", sessionId, name });
-        log34.info({ sessionId, name }, "Session topic created");
+        log35.info({ sessionId, name }, "Session topic created");
         return String(
           await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
         );
@@ -10452,7 +10552,7 @@ Task completed.
         if (!session) return;
         const threadId = Number(session.threadId);
         if (!threadId) {
-          log34.debug({ sessionId, newName }, "Cannot rename thread \u2014 threadId not set yet");
+          log35.debug({ sessionId, newName }, "Cannot rename thread \u2014 threadId not set yet");
           return;
         }
         await renameSessionTopic(
@@ -10471,7 +10571,7 @@ Task completed.
         try {
           await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
         } catch (err) {
-          log34.warn(
+          log35.warn(
             { err, sessionId, topicId },
             "Failed to delete forum topic (may already be deleted)"
           );
@@ -10515,7 +10615,7 @@ Task completed.
           const buffer = Buffer.from(await response.arrayBuffer());
           return { buffer, filePath: file.file_path };
         } catch (err) {
-          log34.error({ err }, "Failed to download file from Telegram");
+          log35.error({ err }, "Failed to download file from Telegram");
           return null;
         }
       }
@@ -10536,7 +10636,7 @@ Task completed.
           try {
             buffer = await this.fileService.convertOggToWav(buffer);
           } catch (err) {
-            log34.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
+            log35.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
             fileName = "voice.ogg";
             mimeType = "audio/ogg";
             originalFilePath = void 0;
@@ -10568,7 +10668,7 @@ Task completed.
           userId: String(userId),
           text: text3,
           attachments: [att]
-        }).catch((err) => log34.error({ err }, "handleMessage error"));
+        }).catch((err) => log35.error({ err }, "handleMessage error"));
       }
       async cleanupSkillCommands(sessionId) {
         this._pendingSkillCommands.delete(sessionId);
@@ -10931,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;
@@ -10952,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,
@@ -11006,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,
@@ -11136,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;
@@ -11218,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(
@@ -11232,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(
@@ -11329,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})
@@ -11341,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"
@@ -11349,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({
@@ -11372,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 {
@@ -11565,7 +11703,7 @@ ${stderr}`
             return;
         }
         if (event !== null) {
-          self.emit("agent_event", event);
+          self.emit(SessionEv.AGENT_EVENT, event);
         }
       },
       // ── Permission requests ──────────────────────────────────────────────
@@ -11592,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;
         }
@@ -11610,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;
@@ -11707,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 += `
@@ -11720,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 += `
@@ -11731,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
           );
@@ -11789,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);
   }
 };
 
@@ -11970,6 +12114,7 @@ function isSystemEvent(event) {
 }
 
 // src/core/sessions/session.ts
+init_events();
 var moduleLog = createChildLogger({ module: "session" });
 var TTS_PROMPT_INSTRUCTION = `
 
@@ -11998,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;
@@ -12022,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;
@@ -12048,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() {
@@ -12078,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() {
@@ -12099,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() {
@@ -12121,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;
@@ -12137,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();
     }
@@ -12168,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";
@@ -12192,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;
@@ -12240,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}`
         });
@@ -12249,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}`
         });
@@ -12283,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);
@@ -12303,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();
     }
@@ -12377,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) {
@@ -12393,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;
@@ -12413,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();
@@ -12454,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() {
@@ -12893,6 +13067,7 @@ var MessageTransformer = class {
 };
 
 // src/core/sessions/session-manager.ts
+init_events();
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
   store;
@@ -12997,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);
@@ -13048,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,
@@ -13069,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));
     }
@@ -13078,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.
@@ -13126,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(() => {
         });
       }
     }
@@ -13136,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) {
@@ -13160,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 });
@@ -13189,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) {
@@ -13209,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;
@@ -13219,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,
@@ -13258,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() {
@@ -13281,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);
@@ -13424,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
     });
@@ -13443,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) {
@@ -13451,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,
@@ -13497,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,
@@ -13511,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) {
@@ -13553,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,
@@ -13562,6 +13731,7 @@ var SessionFactory = class {
         channelId: result.channelId
       };
     }
+    const configAllowedPaths = this.configManager?.get().workspace?.security?.allowedPaths ?? [];
     let agentInstance;
     try {
       if (createParams.resumeAgentSessionId) {
@@ -13569,7 +13739,8 @@ var SessionFactory = class {
           agentInstance = await this.agentManager.resume(
             createParams.agentName,
             createParams.workingDirectory,
-            createParams.resumeAgentSessionId
+            createParams.resumeAgentSessionId,
+            configAllowedPaths
           );
         } catch (resumeErr) {
           log7.warn(
@@ -13578,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) {
@@ -13616,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
       });
@@ -13642,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;
   }
   /**
@@ -13664,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;
@@ -13731,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 },
@@ -13890,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(),
@@ -13901,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) {
@@ -13981,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);
@@ -14060,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();
@@ -14088,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) {
@@ -14113,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
@@ -14127,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,
@@ -14153,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;
@@ -14165,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");
@@ -14189,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,
@@ -14204,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,
@@ -14255,7 +14444,7 @@ var AgentSwitchHandler = class {
       currentPromptCount: 0,
       agentSwitchHistory: session.agentSwitchHistory
     });
-    middlewareChain?.execute("agent:afterSwitch", {
+    middlewareChain?.execute(Hook.AGENT_AFTER_SWITCH, {
       sessionId,
       fromAgent,
       toAgent,
@@ -14940,7 +15129,7 @@ function createPluginContext(opts) {
     }
   };
   const baseLog = opts.log ?? noopLog;
-  const log35 = typeof baseLog.child === "function" ? baseLog.child({ plugin: pluginName }) : baseLog;
+  const log36 = typeof baseLog.child === "function" ? baseLog.child({ plugin: pluginName }) : baseLog;
   const storageImpl = new PluginStorageImpl(storagePath);
   const storage = {
     async get(key) {
@@ -14967,7 +15156,7 @@ function createPluginContext(opts) {
   const ctx = {
     pluginName,
     pluginConfig,
-    log: log35,
+    log: log36,
     storage,
     on(event, handler) {
       requirePermission(permissions, "events:read", "on()");
@@ -15002,7 +15191,7 @@ function createPluginContext(opts) {
       const registry = serviceRegistry.get("command-registry");
       if (registry && typeof registry.register === "function") {
         registry.register(def, pluginName);
-        log35.debug(`Command '/${def.name}' registered`);
+        log36.debug(`Command '/${def.name}' registered`);
       }
     },
     async sendMessage(_sessionId, _content) {
@@ -15045,7 +15234,7 @@ function createPluginContext(opts) {
       const registry = serviceRegistry.get("field-registry");
       if (registry && typeof registry.register === "function") {
         registry.register(pluginName, fields);
-        log35.debug(`Registered ${fields.length} editable field(s) for ${pluginName}`);
+        log36.debug(`Registered ${fields.length} editable field(s) for ${pluginName}`);
       }
     },
     get sessions() {
@@ -15097,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) {
@@ -15242,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) {
@@ -15285,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;
         }
       }
@@ -15308,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) });
       }
     }
   }
@@ -15335,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();
@@ -15352,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 = [];
@@ -15500,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) {
@@ -15535,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
@@ -15717,6 +15898,7 @@ function registerCoreMenuItems(registry) {
 
 // src/core/core.ts
 init_log();
+init_events();
 var log16 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
@@ -15951,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
       );
@@ -16003,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,
@@ -16014,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 ---
@@ -16060,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,
@@ -16075,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
@@ -16099,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,