@openacp/cli 0.3.1 → 0.4.1

package/dist/{chunk-SWQRUVBW.js → chunk-YD7ILGA6.js}

@@ -1,7 +1,7 @@
 import {
   createChildLogger,
   createSessionLogger
-} from "./chunk-JOSJGZGF.js";
+} from "./chunk-LYKCQTH5.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -504,10 +504,174 @@ var AgentManager = class {
   }
 };
 
+// src/core/typed-emitter.ts
+var TypedEmitter = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  listeners = /* @__PURE__ */ new Map();
+  paused = false;
+  buffer = [];
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    if (this.paused) {
+      if (this.passthroughFn?.(event, args)) {
+        this.deliver(event, args);
+      } else {
+        this.buffer.push({ event, args });
+      }
+      return;
+    }
+    this.deliver(event, args);
+  }
+  /**
+   * Pause event delivery. Events emitted while paused are buffered.
+   * Optionally pass a filter to allow specific events through even while paused.
+   */
+  pause(passthrough) {
+    this.paused = true;
+    this.passthroughFn = passthrough;
+  }
+  passthroughFn;
+  /** Resume event delivery and replay buffered events in order. */
+  resume() {
+    this.paused = false;
+    this.passthroughFn = void 0;
+    const buffered = this.buffer.splice(0);
+    for (const { event, args } of buffered) {
+      this.deliver(event, args);
+    }
+  }
+  /** Discard all buffered events without delivering them. */
+  clearBuffer() {
+    this.buffer.length = 0;
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  get bufferSize() {
+    return this.buffer.length;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  deliver(event, args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const listener of set) {
+      listener(...args);
+    }
+  }
+};
+
+// src/core/prompt-queue.ts
+var PromptQueue = class {
+  constructor(processor, onError) {
+    this.processor = processor;
+    this.onError = onError;
+  }
+  queue = [];
+  processing = false;
+  async enqueue(text) {
+    if (this.processing) {
+      return new Promise((resolve) => {
+        this.queue.push({ text, resolve });
+      });
+    }
+    await this.process(text);
+  }
+  async process(text) {
+    this.processing = true;
+    try {
+      await this.processor(text);
+    } catch (err) {
+      this.onError?.(err);
+    } finally {
+      this.processing = false;
+      this.drainNext();
+    }
+  }
+  drainNext() {
+    const next = this.queue.shift();
+    if (next) {
+      this.process(next.text).then(next.resolve);
+    }
+  }
+  clear() {
+    for (const item of this.queue) {
+      item.resolve();
+    }
+    this.queue = [];
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  get isProcessing() {
+    return this.processing;
+  }
+};
+
+// src/core/permission-gate.ts
+var PermissionGate = class {
+  request;
+  resolveFn;
+  rejectFn;
+  settled = false;
+  setPending(request) {
+    this.request = request;
+    this.settled = false;
+    return new Promise((resolve, reject) => {
+      this.resolveFn = resolve;
+      this.rejectFn = reject;
+    });
+  }
+  resolve(optionId) {
+    if (this.settled || !this.resolveFn) return;
+    this.settled = true;
+    this.resolveFn(optionId);
+    this.cleanup();
+  }
+  reject(reason) {
+    if (this.settled || !this.rejectFn) return;
+    this.settled = true;
+    this.rejectFn(new Error(reason ?? "Permission rejected"));
+    this.cleanup();
+  }
+  get isPending() {
+    return !!this.request && !this.settled;
+  }
+  get currentRequest() {
+    return this.isPending ? this.request : void 0;
+  }
+  /** The request ID of the current pending request, undefined after settlement */
+  get requestId() {
+    return this.request?.id;
+  }
+  cleanup() {
+    this.request = void 0;
+    this.resolveFn = void 0;
+    this.rejectFn = void 0;
+  }
+};
+
 // src/core/session.ts
 import { nanoid } from "nanoid";
 var moduleLog = createChildLogger({ module: "session" });
-var Session = class {
+var Session = class extends TypedEmitter {
   id;
   channelId;
   threadId = "";
@@ -517,15 +681,15 @@ var Session = class {
   agentSessionId = "";
   status = "initializing";
   name;
-  promptQueue = [];
-  promptRunning = false;
   createdAt = /* @__PURE__ */ new Date();
   adapter;
   // Set by wireSessionEvents for renaming
-  pendingPermission;
   dangerousMode = false;
   log;
+  permissionGate = new PermissionGate();
+  queue;
   constructor(opts) {
+    super();
     this.id = opts.id || nanoid(12);
     this.channelId = opts.channelId;
     this.agentName = opts.agentName;
@@ -533,45 +697,57 @@ var Session = class {
     this.agentInstance = opts.agentInstance;
     this.log = createSessionLogger(this.id, moduleLog);
     this.log.info({ agentName: this.agentName }, "Session created");
+    this.queue = new PromptQueue(
+      (text) => this.processPrompt(text),
+      (err) => {
+        this.status = "error";
+        this.log.error({ err }, "Prompt execution failed");
+      }
+    );
+  }
+  // --- Backward-compatible properties ---
+  /** @deprecated Use permissionGate directly */
+  get pendingPermission() {
+    if (!this.permissionGate.isPending) return void 0;
+    return {
+      requestId: this.permissionGate.requestId,
+      resolve: (optionId) => this.permissionGate.resolve(optionId)
+    };
+  }
+  set pendingPermission(val) {
+  }
+  /** Number of prompts waiting in queue */
+  get queueDepth() {
+    return this.queue.pending;
+  }
+  get promptRunning() {
+    return this.queue.isProcessing;
   }
+  // --- Public API ---
   async enqueuePrompt(text) {
-    if (this.promptRunning) {
-      this.promptQueue.push(text);
-      this.log.debug({ queueDepth: this.promptQueue.length }, "Prompt queued");
+    await this.queue.enqueue(text);
+  }
+  async processPrompt(text) {
+    if (text === "\0__warmup__") {
+      await this.runWarmup();
       return;
     }
-    await this.runPrompt(text);
-  }
-  async runPrompt(text) {
-    this.promptRunning = true;
     this.status = "active";
     const promptStart = Date.now();
     this.log.debug("Prompt execution started");
-    try {
-      await this.agentInstance.prompt(text);
-      this.log.info(
-        { durationMs: Date.now() - promptStart },
-        "Prompt execution completed"
-      );
-      if (!this.name) {
-        await this.autoName();
-      }
-    } catch (err) {
-      this.status = "error";
-      this.log.error({ err }, "Prompt execution failed");
-    } finally {
-      this.promptRunning = false;
-      if (this.promptQueue.length > 0) {
-        const next = this.promptQueue.shift();
-        await this.runPrompt(next);
-      }
+    await this.agentInstance.prompt(text);
+    this.log.info(
+      { durationMs: Date.now() - promptStart },
+      "Prompt execution completed"
+    );
+    if (!this.name) {
+      await this.autoName();
     }
   }
   // NOTE: This injects a summary prompt into the agent's conversation history.
-  // Known Phase 1 limitation — the agent sees this prompt in its context.
   async autoName() {
     let title = "";
-    const prevHandler = this.agentInstance.onSessionUpdate;
+    const originalHandler = this.agentInstance.onSessionUpdate;
     this.agentInstance.onSessionUpdate = (event) => {
       if (event.type === "text") title += event.content;
     };
@@ -579,7 +755,7 @@ var Session = class {
       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);
+      this.name = title.trim().slice(0, 50) || `Session ${this.id.slice(0, 6)}`;
       this.log.info({ name: this.name }, "Session auto-named");
       if (this.adapter && this.name) {
         await this.adapter.renameSessionThread(this.id, this.name);
@@ -587,16 +763,18 @@ var Session = class {
     } catch {
       this.name = `Session ${this.id.slice(0, 6)}`;
     } finally {
-      this.agentInstance.onSessionUpdate = prevHandler;
+      this.agentInstance.onSessionUpdate = originalHandler;
     }
   }
   /** Fire-and-forget warm-up: primes model cache while user types their first message */
   async warmup() {
-    this.promptRunning = true;
-    const prevHandler = this.agentInstance.onSessionUpdate;
-    this.agentInstance.onSessionUpdate = (event) => {
-      if (event.type === "commands_update") prevHandler(event);
-    };
+    await this.queue.enqueue("\0__warmup__");
+  }
+  async runWarmup() {
+    this.pause((_event, args) => {
+      const agentEvent = args[0];
+      return agentEvent?.type === "commands_update";
+    });
     try {
       const start = Date.now();
       await this.agentInstance.prompt('Reply with only "ready".');
@@ -605,19 +783,15 @@ var Session = class {
     } catch (err) {
       this.log.error({ err }, "Warm-up failed");
     } finally {
-      this.agentInstance.onSessionUpdate = prevHandler;
-      this.promptRunning = false;
-      if (this.promptQueue.length > 0) {
-        const next = this.promptQueue.shift();
-        await this.runPrompt(next);
-      }
+      this.clearBuffer();
+      this.resume();
     }
   }
   async cancel() {
-    this.promptQueue = [];
-    this.status = "cancelled";
+    this.queue.clear();
     this.log.info("Session cancelled");
     await this.agentInstance.cancel();
+    this.status = "active";
   }
   async destroy() {
     this.log.info("Session destroyed");
@@ -763,6 +937,206 @@ var NotificationManager = class {
   }
 };
 
+// src/tunnel/extract-file-info.ts
+function extractFileInfo(name, kind, content, rawInput, meta) {
+  if (kind && !["read", "edit", "write"].includes(kind)) return null;
+  let info = null;
+  if (meta) {
+    const m = meta;
+    const tr = m?.claudeCode?.toolResponse;
+    const file = tr?.file;
+    if (file?.filePath && file?.content) {
+      info = { filePath: file.filePath, content: file.content };
+    }
+    if (!info && tr?.filePath && tr?.content) {
+      info = { filePath: tr.filePath, content: tr.content };
+    }
+  }
+  if (!info && rawInput) {
+    const ri = rawInput;
+    const filePath = ri?.file_path || ri?.filePath || ri?.path;
+    if (typeof filePath === "string") {
+      const parsed = content ? parseContent(content) : null;
+      info = { filePath, content: parsed?.content || ri?.content, oldContent: parsed?.oldContent };
+    }
+  }
+  if (!info && content) {
+    info = parseContent(content);
+  }
+  if (!info) return null;
+  if (!info.filePath) {
+    const pathMatch = name.match(/(?:Read|Edit|Write|View)\s+(.+)/i);
+    if (pathMatch) info.filePath = pathMatch[1].trim();
+  }
+  if (!info.filePath || !info.content) return null;
+  return info;
+}
+function parseContent(content) {
+  if (typeof content === "string") {
+    return { content };
+  }
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      const result = parseContent(block);
+      if (result?.content || result?.filePath) return result;
+    }
+    return null;
+  }
+  if (typeof content === "object" && content !== null) {
+    const c = content;
+    if (c.type === "diff" && typeof c.path === "string") {
+      const newText = c.newText;
+      const oldText = c.oldText;
+      if (newText) {
+        return {
+          filePath: c.path,
+          content: newText,
+          oldContent: oldText ?? void 0
+        };
+      }
+    }
+    if (c.type === "content" && c.content) {
+      return parseContent(c.content);
+    }
+    if (c.type === "text" && typeof c.text === "string") {
+      return { content: c.text, filePath: c.filePath };
+    }
+    if (typeof c.text === "string") {
+      return { content: c.text, filePath: c.filePath };
+    }
+    if (typeof c.file_path === "string" || typeof c.filePath === "string" || typeof c.path === "string") {
+      const filePath = c.file_path || c.filePath || c.path;
+      const fileContent = c.content || c.text || c.output || c.newText;
+      if (typeof fileContent === "string") {
+        return {
+          filePath,
+          content: fileContent,
+          oldContent: c.old_content || c.oldText
+        };
+      }
+    }
+    if (c.input) {
+      const result = parseContent(c.input);
+      if (result) return result;
+    }
+    if (c.output) {
+      const result = parseContent(c.output);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+
+// src/core/message-transformer.ts
+var log2 = createChildLogger({ module: "message-transformer" });
+var MessageTransformer = class {
+  constructor(tunnelService) {
+    this.tunnelService = tunnelService;
+  }
+  transform(event, sessionContext) {
+    switch (event.type) {
+      case "text":
+        return { type: "text", text: event.content };
+      case "thought":
+        return { type: "thought", text: event.content };
+      case "tool_call": {
+        const metadata = {
+          id: event.id,
+          name: event.name,
+          kind: event.kind,
+          status: event.status,
+          content: event.content,
+          locations: event.locations
+        };
+        this.enrichWithViewerLinks(event, metadata, sessionContext);
+        return { type: "tool_call", text: event.name, metadata };
+      }
+      case "tool_update": {
+        const metadata = {
+          id: event.id,
+          name: event.name,
+          kind: event.kind,
+          status: event.status,
+          content: event.content
+        };
+        this.enrichWithViewerLinks(event, metadata, sessionContext);
+        return { type: "tool_update", text: "", metadata };
+      }
+      case "plan":
+        return {
+          type: "plan",
+          text: "",
+          metadata: { entries: event.entries }
+        };
+      case "usage":
+        return {
+          type: "usage",
+          text: "",
+          metadata: {
+            tokensUsed: event.tokensUsed,
+            contextSize: event.contextSize,
+            cost: event.cost
+          }
+        };
+      case "session_end":
+        return { type: "session_end", text: `Done (${event.reason})` };
+      case "error":
+        return { type: "error", text: event.message };
+      default:
+        return { type: "text", text: "" };
+    }
+  }
+  enrichWithViewerLinks(event, metadata, sessionContext) {
+    if (!this.tunnelService || !sessionContext) return;
+    const name = "name" in event ? event.name || "" : "";
+    const kind = "kind" in event ? event.kind : void 0;
+    log2.debug(
+      { name, kind, status: event.status, hasContent: !!event.content },
+      "enrichWithViewerLinks: inspecting event"
+    );
+    const fileInfo = extractFileInfo(
+      name,
+      kind,
+      event.content,
+      event.rawInput,
+      event.meta
+    );
+    if (!fileInfo) return;
+    log2.info(
+      {
+        name,
+        kind,
+        filePath: fileInfo.filePath,
+        hasOldContent: !!fileInfo.oldContent
+      },
+      "enrichWithViewerLinks: extracted file info"
+    );
+    const store = this.tunnelService.getStore();
+    const viewerLinks = {};
+    if (fileInfo.oldContent) {
+      const id2 = store.storeDiff(
+        sessionContext.id,
+        fileInfo.filePath,
+        fileInfo.oldContent,
+        fileInfo.content,
+        sessionContext.workingDirectory
+      );
+      if (id2) viewerLinks.diff = this.tunnelService.diffUrl(id2);
+    }
+    const id = store.storeFile(
+      sessionContext.id,
+      fileInfo.filePath,
+      fileInfo.content,
+      sessionContext.workingDirectory
+    );
+    if (id) viewerLinks.file = this.tunnelService.fileUrl(id);
+    if (Object.keys(viewerLinks).length > 0) {
+      metadata.viewerLinks = viewerLinks;
+      metadata.viewerFilePath = fileInfo.filePath;
+    }
+  }
+};
+
 // src/core/core.ts
 import path3 from "path";
 import os from "os";
@@ -770,7 +1144,7 @@ import os from "os";
 // src/core/session-store.ts
 import fs2 from "fs";
 import path2 from "path";
-var log2 = createChildLogger({ module: "session-store" });
+var log3 = createChildLogger({ module: "session-store" });
 var DEBOUNCE_MS = 2e3;
 var JsonFileSessionStore = class {
   records = /* @__PURE__ */ new Map();
@@ -847,7 +1221,7 @@ var JsonFileSessionStore = class {
         fs2.readFileSync(this.filePath, "utf-8")
       );
       if (raw.version !== 1) {
-        log2.warn(
+        log3.warn(
           { version: raw.version },
           "Unknown session store version, skipping load"
         );
@@ -856,9 +1230,9 @@ var JsonFileSessionStore = class {
       for (const [id, record] of Object.entries(raw.sessions)) {
         this.records.set(id, record);
       }
-      log2.info({ count: this.records.size }, "Loaded session records");
+      log3.info({ count: this.records.size }, "Loaded session records");
     } catch (err) {
-      log2.error({ err }, "Failed to load session store");
+      log3.error({ err }, "Failed to load session store");
     }
   }
   cleanup() {
@@ -874,7 +1248,7 @@ var JsonFileSessionStore = class {
       }
     }
     if (removed > 0) {
-      log2.info({ removed }, "Cleaned up expired session records");
+      log3.info({ removed }, "Cleaned up expired session records");
       this.scheduleDiskWrite();
     }
   }
@@ -886,105 +1260,18 @@ var JsonFileSessionStore = class {
   }
 };
 
-// src/tunnel/extract-file-info.ts
-function extractFileInfo(name, kind, content, rawInput, meta) {
-  if (kind && !["read", "edit", "write"].includes(kind)) return null;
-  let info = null;
-  if (meta) {
-    const m = meta;
-    const tr = m?.claudeCode?.toolResponse;
-    const file = tr?.file;
-    if (file?.filePath && file?.content) {
-      info = { filePath: file.filePath, content: file.content };
-    }
-    if (!info && tr?.filePath && tr?.content) {
-      info = { filePath: tr.filePath, content: tr.content };
-    }
-  }
-  if (!info && rawInput) {
-    const ri = rawInput;
-    const filePath = ri?.file_path || ri?.filePath || ri?.path;
-    if (typeof filePath === "string") {
-      const parsed = content ? parseContent(content) : null;
-      info = { filePath, content: parsed?.content || ri?.content, oldContent: parsed?.oldContent };
-    }
-  }
-  if (!info && content) {
-    info = parseContent(content);
-  }
-  if (!info) return null;
-  if (!info.filePath) {
-    const pathMatch = name.match(/(?:Read|Edit|Write|View)\s+(.+)/i);
-    if (pathMatch) info.filePath = pathMatch[1].trim();
-  }
-  if (!info.filePath || !info.content) return null;
-  return info;
-}
-function parseContent(content) {
-  if (typeof content === "string") {
-    return { content };
-  }
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      const result = parseContent(block);
-      if (result?.content || result?.filePath) return result;
-    }
-    return null;
-  }
-  if (typeof content === "object" && content !== null) {
-    const c = content;
-    if (c.type === "diff" && typeof c.path === "string") {
-      const newText = c.newText;
-      const oldText = c.oldText;
-      if (newText) {
-        return {
-          filePath: c.path,
-          content: newText,
-          oldContent: oldText ?? void 0
-        };
-      }
-    }
-    if (c.type === "content" && c.content) {
-      return parseContent(c.content);
-    }
-    if (c.type === "text" && typeof c.text === "string") {
-      return { content: c.text, filePath: c.filePath };
-    }
-    if (typeof c.text === "string") {
-      return { content: c.text, filePath: c.filePath };
-    }
-    if (typeof c.file_path === "string" || typeof c.filePath === "string" || typeof c.path === "string") {
-      const filePath = c.file_path || c.filePath || c.path;
-      const fileContent = c.content || c.text || c.output || c.newText;
-      if (typeof fileContent === "string") {
-        return {
-          filePath,
-          content: fileContent,
-          oldContent: c.old_content || c.oldText
-        };
-      }
-    }
-    if (c.input) {
-      const result = parseContent(c.input);
-      if (result) return result;
-    }
-    if (c.output) {
-      const result = parseContent(c.output);
-      if (result) return result;
-    }
-  }
-  return null;
-}
-
 // src/core/core.ts
-var log3 = createChildLogger({ module: "core" });
+var log4 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
   agentManager;
   sessionManager;
   notificationManager;
+  messageTransformer;
   adapters = /* @__PURE__ */ new Map();
-  tunnelService;
+  /** Set by main.ts — triggers graceful shutdown with restart exit code */
+  requestRestart = null;
+  _tunnelService;
   sessionStore = null;
   resumeLocks = /* @__PURE__ */ new Map();
   constructor(configManager) {
@@ -998,6 +1285,14 @@ var OpenACPCore = class {
     );
     this.sessionManager = new SessionManager(this.sessionStore);
     this.notificationManager = new NotificationManager(this.adapters);
+    this.messageTransformer = new MessageTransformer();
+  }
+  get tunnelService() {
+    return this._tunnelService;
+  }
+  set tunnelService(service) {
+    this._tunnelService = service;
+    this.messageTransformer = new MessageTransformer(service);
   }
   registerAdapter(name, adapter) {
     this.adapters.set(name, adapter);
@@ -1024,7 +1319,7 @@ var OpenACPCore = class {
   // --- Message Routing ---
   async handleMessage(message) {
     const config = this.configManager.get();
-    log3.debug(
+    log4.debug(
       {
         channelId: message.channelId,
         threadId: message.threadId,
@@ -1034,7 +1329,7 @@ var OpenACPCore = class {
     );
     if (config.security.allowedUserIds.length > 0) {
       if (!config.security.allowedUserIds.includes(message.userId)) {
-        log3.warn(
+        log4.warn(
           { userId: message.userId },
           "Rejected message from unauthorized user"
         );
@@ -1043,7 +1338,7 @@ var OpenACPCore = class {
     }
     const activeSessions = this.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
     if (activeSessions.length >= config.security.maxConcurrentSessions) {
-      log3.warn(
+      log4.warn(
         {
           userId: message.userId,
           currentCount: activeSessions.length,
@@ -1074,7 +1369,7 @@ var OpenACPCore = class {
   async handleNewSession(channelId, agentName, workspacePath) {
     const config = this.configManager.get();
     const resolvedAgent = agentName || config.defaultAgent;
-    log3.info({ channelId, agentName: resolvedAgent }, "New session request");
+    log4.info({ channelId, agentName: resolvedAgent }, "New session request");
     const resolvedWorkspace = this.configManager.resolveWorkspace(
       workspacePath || config.agents[resolvedAgent]?.workingDirectory
     );
@@ -1152,13 +1447,13 @@ var OpenACPCore = class {
           status: "active",
           lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-        log3.info(
+        log4.info(
           { sessionId: session.id, threadId: message.threadId },
           "Lazy resume successful"
         );
         return session;
       } catch (err) {
-        log3.error({ err, record }, "Lazy resume failed");
+        log4.error({ err, record }, "Lazy resume failed");
         return null;
       } finally {
         this.resumeLocks.delete(lockKey);
@@ -1168,98 +1463,27 @@ var OpenACPCore = class {
     return resumePromise;
   }
   // --- Event Wiring ---
-  toOutgoingMessage(event, session) {
-    switch (event.type) {
-      case "text":
-        return { type: "text", text: event.content };
-      case "thought":
-        return { type: "thought", text: event.content };
-      case "tool_call": {
-        const metadata = {
-          id: event.id,
-          name: event.name,
-          kind: event.kind,
-          status: event.status,
-          content: event.content,
-          locations: event.locations
-        };
-        this.enrichWithViewerLinks(event, metadata, session);
-        return { type: "tool_call", text: event.name, metadata };
-      }
-      case "tool_update": {
-        const metadata = {
-          id: event.id,
-          name: event.name,
-          kind: event.kind,
-          status: event.status,
-          content: event.content
-        };
-        this.enrichWithViewerLinks(event, metadata, session);
-        return { type: "tool_update", text: "", metadata };
-      }
-      case "plan":
-        return { type: "plan", text: "", metadata: { entries: event.entries } };
-      case "usage":
-        return {
-          type: "usage",
-          text: "",
-          metadata: {
-            tokensUsed: event.tokensUsed,
-            contextSize: event.contextSize,
-            cost: event.cost
-          }
-        };
-      default:
-        return { type: "text", text: "" };
-    }
-  }
-  enrichWithViewerLinks(event, metadata, session) {
-    if (!this.tunnelService || !session) return;
-    const name = "name" in event ? event.name || "" : "";
-    const kind = "kind" in event ? event.kind : void 0;
-    log3.debug(
-      { name, kind, status: event.status, hasContent: !!event.content },
-      "enrichWithViewerLinks: inspecting event"
-    );
-    const fileInfo = extractFileInfo(name, kind, event.content, event.rawInput, event.meta);
-    if (!fileInfo) return;
-    log3.info(
-      {
-        name,
-        kind,
-        filePath: fileInfo.filePath,
-        hasOldContent: !!fileInfo.oldContent
-      },
-      "enrichWithViewerLinks: extracted file info"
-    );
-    const store = this.tunnelService.getStore();
-    const viewerLinks = {};
-    if (fileInfo.oldContent) {
-      const id2 = store.storeDiff(
-        session.id,
-        fileInfo.filePath,
-        fileInfo.oldContent,
-        fileInfo.content,
-        session.workingDirectory
-      );
-      if (id2) viewerLinks.diff = this.tunnelService.diffUrl(id2);
-    }
-    const id = store.storeFile(
-      session.id,
-      fileInfo.filePath,
-      fileInfo.content,
-      session.workingDirectory
-    );
-    if (id) viewerLinks.file = this.tunnelService.fileUrl(id);
-    if (Object.keys(viewerLinks).length > 0) {
-      metadata.viewerLinks = viewerLinks;
-      metadata.viewerFilePath = fileInfo.filePath;
-    }
-  }
   // Public — adapters call this for assistant session wiring
   wireSessionEvents(session, adapter) {
     session.adapter = adapter;
     session.agentInstance.onSessionUpdate = (event) => {
+      session.emit("agent_event", event);
+    };
+    session.agentInstance.onPermissionRequest = async (request) => {
+      session.emit("permission_request", request);
+      const promise = session.permissionGate.setPending(request);
+      await adapter.sendPermissionRequest(session.id, request);
+      return promise;
+    };
+    const sessionContext = {
+      get id() {
+        return session.id;
+      },
+      get workingDirectory() {
+        return session.workingDirectory;
+      }
+    };
+    session.on("agent_event", (event) => {
       switch (event.type) {
         case "text":
         case "thought":
@@ -1269,17 +1493,17 @@ var OpenACPCore = class {
         case "usage":
           adapter.sendMessage(
             session.id,
-            this.toOutgoingMessage(event, session)
+            this.messageTransformer.transform(event, sessionContext)
           );
           break;
         case "session_end":
           session.status = "finished";
           this.sessionManager.updateSessionStatus(session.id, "finished");
           adapter.cleanupSkillCommands(session.id);
-          adapter.sendMessage(session.id, {
-            type: "session_end",
-            text: `Done (${event.reason})`
-          });
+          adapter.sendMessage(
+            session.id,
+            this.messageTransformer.transform(event)
+          );
           this.notificationManager.notify(session.channelId, {
             sessionId: session.id,
             sessionName: session.name,
@@ -1290,10 +1514,10 @@ var OpenACPCore = class {
         case "error":
           this.sessionManager.updateSessionStatus(session.id, "error");
           adapter.cleanupSkillCommands(session.id);
-          adapter.sendMessage(session.id, {
-            type: "error",
-            text: event.message
-          });
+          adapter.sendMessage(
+            session.id,
+            this.messageTransformer.transform(event)
+          );
           this.notificationManager.notify(session.channelId, {
             sessionId: session.id,
             sessionName: session.name,
@@ -1302,18 +1526,11 @@ var OpenACPCore = class {
           });
           break;
         case "commands_update":
-          log3.debug({ commands: event.commands }, "Commands available");
+          log4.debug({ commands: event.commands }, "Commands available");
           adapter.sendSkillCommands(session.id, event.commands);
           break;
       }
-    };
-    session.agentInstance.onPermissionRequest = async (request) => {
-      const promise = new Promise((resolve) => {
-        session.pendingPermission = { requestId: request.id, resolve };
-      });
-      await adapter.sendPermissionRequest(session.id, request);
-      return promise;
-    };
+    });
   }
 };
 
@@ -1335,7 +1552,7 @@ import * as http from "http";
 import * as fs3 from "fs";
 import * as path4 from "path";
 import * as os2 from "os";
-var log4 = createChildLogger({ module: "api-server" });
+var log5 = createChildLogger({ module: "api-server" });
 var DEFAULT_PORT_FILE = path4.join(os2.homedir(), ".openacp", "api.port");
 var ApiServer = class {
   constructor(core, config, portFilePath) {
@@ -1351,7 +1568,7 @@ var ApiServer = class {
     await new Promise((resolve, reject) => {
       this.server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {
-          log4.warn({ port: this.config.port }, "API port in use, continuing without API server");
+          log5.warn({ port: this.config.port }, "API port in use, continuing without API server");
           this.server = null;
           resolve();
         } else {
@@ -1364,7 +1581,7 @@ var ApiServer = class {
           this.actualPort = addr.port;
         }
         this.writePortFile();
-        log4.info({ host: this.config.host, port: this.actualPort }, "API server listening");
+        log5.info({ host: this.config.host, port: this.actualPort }, "API server listening");
         resolve();
       });
     });
@@ -1409,7 +1626,7 @@ var ApiServer = class {
         this.sendJson(res, 404, { error: "Not found" });
       }
     } catch (err) {
-      log4.error({ err }, "API request error");
+      log5.error({ err }, "API request error");
       this.sendJson(res, 500, { error: "Internal server error" });
     }
   }
@@ -1444,17 +1661,17 @@ var ApiServer = class {
         session.threadId = threadId;
         this.core.wireSessionEvents(session, adapter);
       } catch (err) {
-        log4.warn({ err, sessionId: session.id }, "Failed to create session thread on adapter, running headless");
+        log5.warn({ err, sessionId: session.id }, "Failed to create session thread on adapter, running headless");
       }
     }
     if (!adapter) {
       session.agentInstance.onPermissionRequest = async (request) => {
         const allowOption = request.options.find((o) => o.isAllow);
-        log4.debug({ sessionId: session.id, permissionId: request.id, option: allowOption?.id }, "Auto-approving permission for API session");
+        log5.debug({ sessionId: session.id, permissionId: request.id, option: allowOption?.id }, "Auto-approving permission for API session");
         return allowOption?.id ?? request.options[0]?.id ?? "";
       };
     }
-    session.warmup().catch((err) => log4.warn({ err, sessionId: session.id }, "API session warmup failed"));
+    session.warmup().catch((err) => log5.warn({ err, sessionId: session.id }, "API session warmup failed"));
     this.sendJson(res, 200, {
       sessionId: session.id,
       agent: session.agentName,
@@ -1824,7 +2041,7 @@ function buildDeepLink(chatId, messageId) {
 // src/adapters/telegram/commands.ts
 import { InlineKeyboard } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log6 = createChildLogger({ module: "telegram-commands" });
+var log7 = createChildLogger({ module: "telegram-commands" });
 function setupCommands(bot, core, chatId, assistant) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
   bot.command("new_chat", (ctx) => handleNewChat(ctx, core, chatId));
@@ -1835,9 +2052,11 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("menu", (ctx) => handleMenu(ctx));
   bot.command("enable_dangerous", (ctx) => handleEnableDangerous(ctx, core));
   bot.command("disable_dangerous", (ctx) => handleDisableDangerous(ctx, core));
+  bot.command("restart", (ctx) => handleRestart(ctx, core));
+  bot.command("update", (ctx) => handleUpdate(ctx, core));
 }
 function buildMenuKeyboard() {
-  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:new_chat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F916} Agents", "m:agents").text("\u2753 Help", "m:help");
+  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:new_chat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F916} Agents", "m:agents").text("\u2753 Help", "m:help").row().text("\u{1F504} Restart", "m:restart").text("\u2B06\uFE0F Update", "m:update");
 }
 function setupMenuCallbacks(bot, core, chatId) {
   bot.callbackQuery(/^m:/, async (ctx) => {
@@ -1865,6 +2084,12 @@ function setupMenuCallbacks(bot, core, chatId) {
       case "m:help":
         await handleHelp(ctx);
         break;
+      case "m:restart":
+        await handleRestart(ctx, core);
+        break;
+      case "m:update":
+        await handleUpdate(ctx, core);
+        break;
     }
   });
 }
@@ -1890,7 +2115,7 @@ async function handleNew(ctx, core, chatId, assistant) {
       return;
     }
   }
-  log6.info({ userId: ctx.from?.id, agentName }, "New session command");
+  log7.info({ userId: ctx.from?.id, agentName }, "New session command");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
@@ -1924,9 +2149,9 @@ async function handleNew(ctx, core, chatId, assistant) {
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log7.error({ err }, "Warm-up error"));
   } catch (err) {
-    log6.error({ err }, "Session creation failed");
+    log7.error({ err }, "Session creation failed");
     if (threadId) {
       try {
         await ctx.api.deleteForumTopic(chatId, threadId);
@@ -1946,16 +2171,30 @@ async function handleNewChat(ctx, core, chatId) {
     );
     return;
   }
-  try {
-    const session = await core.handleNewChat("telegram", String(threadId));
-    if (!session) {
+  const currentSession = core.sessionManager.getSessionByThread(
+    "telegram",
+    String(threadId)
+  );
+  let agentName;
+  let workspace;
+  if (currentSession) {
+    agentName = currentSession.agentName;
+    workspace = currentSession.workingDirectory;
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
       await ctx.reply("No active session in this topic.", {
         parse_mode: "HTML"
       });
       return;
     }
-    const topicName = `\u{1F504} ${session.agentName} \u2014 New Chat`;
-    const newThreadId = await createSessionTopic(
+    agentName = record.agentName;
+    workspace = record.workingDir;
+  }
+  let newThreadId;
+  try {
+    const topicName = `\u{1F504} ${agentName} \u2014 New Chat`;
+    newThreadId = await createSessionTopic(
       botFromCtx(ctx),
       chatId,
       topicName
@@ -1964,6 +2203,11 @@ async function handleNewChat(ctx, core, chatId) {
       message_thread_id: newThreadId,
       parse_mode: "HTML"
     });
+    const session = await core.handleNewSession(
+      "telegram",
+      agentName,
+      workspace
+    );
     session.threadId = String(newThreadId);
     await core.sessionManager.updateSessionPlatform(session.id, {
       topicId: newThreadId
@@ -1979,8 +2223,14 @@ async function handleNewChat(ctx, core, chatId) {
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log7.error({ err }, "Warm-up error"));
   } catch (err) {
+    if (newThreadId) {
+      try {
+        await ctx.api.deleteForumTopic(chatId, newThreadId);
+      } catch {
+      }
+    }
     const message = err instanceof Error ? err.message : String(err);
     await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
   }
@@ -2002,14 +2252,14 @@ async function handleCancel(ctx, core, assistant) {
     String(threadId)
   );
   if (session) {
-    log6.info({ sessionId: session.id }, "Cancel session command");
+    log7.info({ sessionId: session.id }, "Cancel session command");
     await session.cancel();
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
     return;
   }
   const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
   if (record && record.status !== "cancelled" && record.status !== "error") {
-    log6.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
+    log7.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
     await core.sessionManager.cancelSession(record.sessionId);
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
@@ -2027,7 +2277,7 @@ async function handleStatus(ctx, core) {
 <b>Agent:</b> ${escapeHtml(session.agentName)}
 <b>Status:</b> ${escapeHtml(session.status)}
 <b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>
-<b>Queue:</b> ${session.promptQueue.length} pending`,
+<b>Queue:</b> ${session.queueDepth} pending`,
         { parse_mode: "HTML" }
       );
     } else {
@@ -2083,6 +2333,8 @@ async function handleHelp(ctx) {
 /status \u2014 Show session/system status
 /agents \u2014 List available agents
 /menu \u2014 Show interactive menu
+/restart \u2014 Restart OpenACP
+/update \u2014 Update to latest version and restart
 /help \u2014 Show this help
 
 Or just chat in the \u{1F916} Assistant topic for help!`,
@@ -2107,7 +2359,7 @@ function setupDangerousModeCallbacks(bot, core) {
       return;
     }
     session.dangerousMode = !session.dangerousMode;
-    log6.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+    log7.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
     const toastText = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
     try {
       await ctx.answerCallbackQuery({ text: toastText });
@@ -2146,6 +2398,52 @@ Use /disable_dangerous to restore normal behaviour.`,
     { parse_mode: "HTML" }
   );
 }
+async function handleUpdate(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply("\u26A0\uFE0F Update is not available (no restart handler registered).", { parse_mode: "HTML" });
+    return;
+  }
+  const { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-VC5CPXBX.js");
+  const current = getCurrentVersion();
+  const statusMsg = await ctx.reply(`\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`, { parse_mode: "HTML" });
+  const latest = await getLatestVersion();
+  if (!latest) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Could not check for updates.", { parse_mode: "HTML" });
+    return;
+  }
+  if (compareVersions(current, latest) >= 0) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, `\u2705 Already up to date (v${escapeHtml(current)}).`, { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2B07\uFE0F Updating v${escapeHtml(current)} \u2192 v${escapeHtml(latest)}...`,
+    { parse_mode: "HTML" }
+  );
+  const ok = await runUpdate();
+  if (!ok) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Update failed. Try manually: <code>npm install -g @openacp/cli@latest</code>", { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2705 Updated to v${escapeHtml(latest)}. Restarting...`,
+    { parse_mode: "HTML" }
+  );
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+async function handleRestart(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply("\u26A0\uFE0F Restart is not available (no restart handler registered).", { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.reply("\u{1F504} <b>Restarting OpenACP...</b>\nRebuilding and restarting. Be back shortly.", { parse_mode: "HTML" });
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
 async function handleDisableDangerous(ctx, core) {
   const threadId = ctx.message?.message_thread_id;
   if (!threadId) {
@@ -2222,7 +2520,7 @@ async function executeNewSession(bot, core, chatId, agentName, workspace) {
     });
     const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
     await renameSessionTopic(bot, chatId, threadId, finalName);
-    session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log7.error({ err }, "Warm-up error"));
     return { session, threadId, firstMsgId };
   } catch (err) {
     try {
@@ -2248,13 +2546,15 @@ var STATIC_COMMANDS = [
   { command: "help", description: "Help" },
   { command: "menu", description: "Show menu" },
   { command: "enable_dangerous", description: "Auto-approve all permission requests (session only)" },
-  { command: "disable_dangerous", description: "Restore normal permission prompts (session only)" }
+  { command: "disable_dangerous", description: "Restore normal permission prompts (session only)" },
+  { command: "restart", description: "Restart OpenACP" },
+  { command: "update", description: "Update to latest version and restart" }
 ];
 
 // src/adapters/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 import { nanoid as nanoid3 } from "nanoid";
-var log7 = createChildLogger({ module: "telegram-permissions" });
+var log8 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -2314,10 +2614,9 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log7.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
-      if (session?.pendingPermission?.requestId === pending.requestId) {
-        session.pendingPermission.resolve(optionId);
-        session.pendingPermission = void 0;
+      log8.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      if (session?.permissionGate.requestId === pending.requestId) {
+        session.permissionGate.resolve(optionId);
       }
       this.pending.delete(callbackKey);
       try {
@@ -2333,10 +2632,10 @@ ${escapeHtml(request.description)}`,
 };
 
 // src/adapters/telegram/assistant.ts
-var log8 = createChildLogger({ module: "telegram-assistant" });
+var log9 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
-  log8.info({ agent: config.defaultAgent }, "Creating assistant session...");
+  log9.info({ agent: config.defaultAgent }, "Creating assistant session...");
   const session = await core.sessionManager.createSession(
     "telegram",
     config.defaultAgent,
@@ -2345,13 +2644,13 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   );
   session.threadId = String(assistantTopicId);
   session.name = "Assistant";
-  log8.info({ sessionId: session.id }, "Assistant agent spawned");
+  log9.info({ sessionId: session.id }, "Assistant agent spawned");
   core.wireSessionEvents(session, adapter);
   const systemPrompt = buildAssistantSystemPrompt(config);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log8.info({ sessionId: session.id }, "Assistant system prompt completed");
+    log9.info({ sessionId: session.id }, "Assistant system prompt completed");
   }).catch((err) => {
-    log8.warn({ err }, "Assistant system prompt failed");
+    log9.warn({ err }, "Assistant system prompt failed");
   });
   return { session, ready };
 }
@@ -2389,7 +2688,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/activity.ts
-var log9 = createChildLogger({ module: "telegram:activity" });
+var log10 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
 var ThinkingIndicator = class {
@@ -2421,7 +2720,7 @@ var ThinkingIndicator = class {
         this.startRefreshTimer();
       }
     } catch (err) {
-      log9.warn({ err }, "ThinkingIndicator.show() failed");
+      log10.warn({ err }, "ThinkingIndicator.show() failed");
     } finally {
       this.sending = false;
     }
@@ -2494,7 +2793,7 @@ var UsageMessage = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log9.warn({ err }, "UsageMessage.send() failed");
+      log10.warn({ err }, "UsageMessage.send() failed");
     }
   }
   getMsgId() {
@@ -2507,7 +2806,7 @@ var UsageMessage = class {
     try {
       await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
     } catch (err) {
-      log9.warn({ err }, "UsageMessage.delete() failed");
+      log10.warn({ err }, "UsageMessage.delete() failed");
     }
   }
 };
@@ -2590,7 +2889,7 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log9.warn({ err }, "PlanCard flush failed");
+      log10.warn({ err }, "PlanCard flush failed");
     }
   }
 };
@@ -2653,7 +2952,7 @@ var ActivityTracker = class {
           })
         );
       } catch (err) {
-        log9.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+        log10.warn({ err }, "ActivityTracker.onComplete() Done send failed");
       }
     }
   }
@@ -2880,7 +3179,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
 }
 
 // src/adapters/telegram/adapter.ts
-var log10 = createChildLogger({ module: "telegram" });
+var log11 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -2931,7 +3230,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.bot = new Bot(this.telegramConfig.botToken, { client: { fetch: patchedFetch } });
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log10.error({ err: rootCause }, "Telegram bot error");
+      log11.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -2945,7 +3244,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log10.warn(
+        log11.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -3015,7 +3314,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log10.info(
+      onStart: () => log11.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -3037,10 +3336,10 @@ Workspace: <code>${workspace}</code>
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log10.warn({ err }, "Failed to send welcome message");
+      log11.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log10.info("Spawning assistant session...");
+      log11.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -3048,13 +3347,13 @@ Workspace: <code>${workspace}</code>
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log10.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
+      log11.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
       ready.then(() => {
         this.assistantInitializing = false;
-        log10.info({ sessionId: session.id }, "Assistant ready for user messages");
+        log11.info({ sessionId: session.id }, "Assistant ready for user messages");
       });
     } catch (err) {
-      log10.error({ err }, "Failed to spawn assistant");
+      log11.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -3070,7 +3369,7 @@ Workspace: <code>${workspace}</code>
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log10.info("Telegram bot stopped");
+    log11.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -3093,7 +3392,7 @@ Workspace: <code>${workspace}</code>
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log10.error({ err }, "Assistant error")
+          (err) => log11.error({ err }, "Assistant error")
         );
         return;
       }
@@ -3110,7 +3409,7 @@ Workspace: <code>${workspace}</code>
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log10.error({ err }, "handleMessage error"));
+      }).catch((err) => log11.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
@@ -3190,7 +3489,7 @@ Workspace: <code>${workspace}</code>
         if (toolState) {
           if (meta.viewerLinks) {
             toolState.viewerLinks = meta.viewerLinks;
-            log10.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
+            log11.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
           }
           const viewerFilePath = content.metadata?.viewerFilePath;
           if (viewerFilePath) toolState.viewerFilePath = viewerFilePath;
@@ -3199,7 +3498,7 @@ Workspace: <code>${workspace}</code>
           const isTerminal = meta.status === "completed" || meta.status === "failed";
           if (!isTerminal && !meta.viewerLinks) break;
           await toolState.ready;
-          log10.debug(
+          log11.debug(
             { toolId: meta.id, status: meta.status, hasViewerLinks: !!toolState.viewerLinks, viewerLinks: toolState.viewerLinks, name: toolState.name, msgId: toolState.msgId },
             "Tool completed, preparing edit"
           );
@@ -3221,7 +3520,7 @@ Workspace: <code>${workspace}</code>
               )
             );
           } catch (err) {
-            log10.warn(
+            log11.warn(
               { err, msgId: toolState.msgId, textLen: formattedText.length, hasViewerLinks: !!merged.viewerLinks },
               "Tool update edit failed"
             );
@@ -3316,17 +3615,16 @@ Task completed.
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log10.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log11.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(
       sessionId
     );
     if (!session) return;
     if (session.dangerousMode) {
       const allowOption = request.options.find((o) => o.isAllow);
-      if (allowOption && session.pendingPermission?.requestId === request.id) {
-        log10.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
-        session.pendingPermission.resolve(allowOption.id);
-        session.pendingPermission = void 0;
+      if (allowOption && session.permissionGate.requestId === request.id) {
+        log11.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
+        session.permissionGate.resolve(allowOption.id);
       }
       return;
     }
@@ -3336,7 +3634,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log10.info(
+    log11.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -3372,7 +3670,7 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log10.info({ sessionId, name }, "Session topic created");
+    log11.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -3457,7 +3755,7 @@ Task completed.
         }
       );
     } catch (err) {
-      log10.error({ err, sessionId }, "Failed to send skill commands");
+      log11.error({ err, sessionId }, "Failed to send skill commands");
     }
     await this.updateCommandAutocomplete(session.agentName, commands);
   }
@@ -3493,12 +3791,12 @@ Task completed.
       await this.bot.api.setMyCommands(all, {
         scope: { type: "chat", chat_id: this.telegramConfig.chatId }
       });
-      log10.info(
+      log11.info(
         { count: all.length, skills: validSkills.length },
         "Updated command autocomplete"
       );
     } catch (err) {
-      log10.error(
+      log11.error(
         { err, commands: all },
         "Failed to update command autocomplete"
       );
@@ -3539,12 +3837,16 @@ export {
   StderrCapture,
   AgentInstance,
   AgentManager,
+  TypedEmitter,
+  PromptQueue,
+  PermissionGate,
   Session,
   SessionManager,
   NotificationManager,
+  MessageTransformer,
   OpenACPCore,
   ChannelAdapter,
   ApiServer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-SWQRUVBW.js.map
+//# sourceMappingURL=chunk-YD7ILGA6.js.map