dorkos 0.14.0 → 0.16.0

package/dist/server/index.js

@@ -11744,7 +11744,7 @@ var require_multipart = __commonJS({
     var BUF_CRLF = Buffer.from("\r\n");
     var BUF_CR = Buffer.from("\r");
     var BUF_DASH = Buffer.from("-");
-    function noop() {
+    function noop2() {
     }
     var MAX_HEADER_PAIRS = 2e3;
     var MAX_HEADER_SIZE = 16 * 1024;
@@ -12097,7 +12097,7 @@ var require_multipart = __commonJS({
                     return;
                   }
                   const writecb = this._writecb;
-                  this._writecb = noop;
+                  this._writecb = noop2;
                   ssCb(false, BUF_DASH, 0, 1, false);
                   this._writecb = writecb;
                 } else if (matchPostBoundary === 3) {
@@ -12112,7 +12112,7 @@ var require_multipart = __commonJS({
                     continue retrydata;
                   } else {
                     const writecb = this._writecb;
-                    this._writecb = noop;
+                    this._writecb = noop2;
                     ssCb(false, BUF_CR, 0, 1, false);
                     this._writecb = writecb;
                   }
@@ -15321,7 +15321,7 @@ var require_end_of_stream = __commonJS({
         callback.apply(this, args);
       };
     }
-    function noop() {
+    function noop2() {
     }
     function isRequest(stream) {
       return stream.setHeader && typeof stream.abort === "function";
@@ -15329,7 +15329,7 @@ var require_end_of_stream = __commonJS({
     function eos(stream, opts, callback) {
       if (typeof opts === "function") return eos(stream, null, opts);
       if (!opts) opts = {};
-      callback = once(callback || noop);
+      callback = once(callback || noop2);
       var readable = opts.readable || opts.readable !== false && stream.readable;
       var writable = opts.writable || opts.writable !== false && stream.writable;
       var onlegacyfinish = function onlegacyfinish2() {
@@ -16565,7 +16565,7 @@ var require_pipeline = __commonJS({
     var _require$codes = require_errors().codes;
     var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
     var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
-    function noop(err) {
+    function noop2(err) {
       if (err) throw err;
     }
     function isRequest(stream) {
@@ -16603,8 +16603,8 @@ var require_pipeline = __commonJS({
       return from.pipe(to);
     }
     function popCallback(streams) {
-      if (!streams.length) return noop;
-      if (typeof streams[streams.length - 1] !== "function") return noop;
+      if (!streams.length) return noop2;
+      if (typeof streams[streams.length - 1] !== "function") return noop2;
       return streams.pop();
     }
     function pipeline() {
@@ -33700,7 +33700,7 @@ var require_follow_redirects = __commonJS({
       "ERR_STREAM_WRITE_AFTER_END",
       "write after end"
     );
-    var destroy = Writable.prototype.destroy || noop;
+    var destroy = Writable.prototype.destroy || noop2;
     function RedirectableRequest(options, responseCallback) {
       Writable.call(this);
       this._sanitizeOptions(options);
@@ -34029,7 +34029,7 @@ var require_follow_redirects = __commonJS({
       });
       return exports2;
     }
-    function noop() {
+    function noop2() {
     }
     function parseUrl(input) {
       var parsed;
@@ -34105,7 +34105,7 @@ var require_follow_redirects = __commonJS({
       for (var event of events) {
         request.removeListener(event, eventHandlers[event]);
       }
-      request.on("error", noop);
+      request.on("error", noop2);
       request.destroy(error);
     }
     function isSubdomain(subdomain, domain2) {
@@ -34471,7 +34471,7 @@ var require_axios = __commonJS({
       isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
       return obj;
     };
-    var noop = () => {
+    var noop2 = () => {
     };
     var toFiniteNumber = (value, defaultValue) => {
       return value != null && Number.isFinite(value = +value) ? value : defaultValue;
@@ -34577,7 +34577,7 @@ var require_axios = __commonJS({
       freezeMethods,
       toObjectSet,
       toCamelCase: toCamelCase2,
-      noop,
+      noop: noop2,
       toFiniteNumber,
       findKey,
       global: _global,
@@ -55755,7 +55755,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash3 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash3 } = __require("crypto");
     var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -56285,7 +56285,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes(16).toString("base64");
+      const key = randomBytes2(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -68835,9 +68835,11 @@ var StreamEventTypeSchema = z.enum([
   "tool_call_delta",
   "tool_call_end",
   "tool_result",
+  "tool_progress",
   "approval_required",
   "question_prompt",
   "error",
+  "rate_limit",
   "done",
   "session_status",
   "task_update",
@@ -68845,7 +68847,18 @@ var StreamEventTypeSchema = z.enum([
   "sync_connected",
   "relay_receipt",
   "message_delivered",
-  "relay_message"
+  "relay_message",
+  "thinking_delta",
+  "subagent_started",
+  "subagent_progress",
+  "subagent_done",
+  "system_status",
+  "compact_boundary",
+  "prompt_suggestion",
+  "hook_started",
+  "hook_progress",
+  "hook_response",
+  "presence_update"
 ]).openapi("StreamEventType");
 var QuestionOptionSchema = z.object({
   label: z.string(),
@@ -68899,6 +68912,9 @@ var CommandsQuerySchema = z.object({
 var TextDeltaSchema = z.object({
   text: z.string()
 }).openapi("TextDelta");
+var ThinkingDeltaSchema = z.object({
+  text: z.string()
+}).openapi("ThinkingDelta");
 var ToolCallStatusSchema = z.enum(["pending", "running", "complete", "error"]);
 var ToolCallEventSchema = z.object({
   toolCallId: z.string(),
@@ -68907,19 +68923,30 @@ var ToolCallEventSchema = z.object({
   result: z.string().optional(),
   status: ToolCallStatusSchema
 }).openapi("ToolCallEvent");
+var ToolProgressEventSchema = z.object({
+  toolCallId: z.string(),
+  content: z.string()
+}).openapi("ToolProgressEvent");
 var ApprovalEventSchema = z.object({
   toolCallId: z.string(),
   toolName: z.string(),
-  input: z.string()
+  input: z.string(),
+  timeoutMs: z.number().describe("Server-side approval timeout in milliseconds")
 }).openapi("ApprovalEvent");
 var QuestionPromptEventSchema = z.object({
   toolCallId: z.string(),
   questions: z.array(QuestionItemSchema)
 }).openapi("QuestionPromptEvent");
+var ErrorCategorySchema = z.enum(["max_turns", "execution_error", "budget_exceeded", "output_format_error"]).openapi("ErrorCategory");
 var ErrorEventSchema = z.object({
   message: z.string(),
-  code: z.string().optional()
+  code: z.string().optional(),
+  category: ErrorCategorySchema.optional(),
+  details: z.string().optional()
 }).openapi("ErrorEvent");
+var RateLimitEventSchema = z.object({
+  retryAfter: z.number().optional()
+}).openapi("RateLimitEvent");
 var DoneEventSchema = z.object({
   sessionId: z.string()
 }).openapi("DoneEvent");
@@ -68928,7 +68955,8 @@ var SessionStatusEventSchema = z.object({
   model: z.string().optional(),
   costUsd: z.number().optional(),
   contextTokens: z.number().int().optional(),
-  contextMaxTokens: z.number().int().optional()
+  contextMaxTokens: z.number().int().optional(),
+  outputTokens: z.number().int().optional()
 }).openapi("SessionStatusEvent");
 var TaskItemSchema = z.object({
   id: z.string(),
@@ -68966,14 +68994,75 @@ var RelayMessageEventSchema = z.object({
   subject: z.string().optional(),
   from: z.string().optional()
 }).openapi("RelayMessageEvent");
+var SubagentStartedEventSchema = z.object({
+  taskId: z.string(),
+  subagentSessionId: z.string(),
+  toolUseId: z.string().optional(),
+  description: z.string()
+}).openapi("SubagentStartedEvent");
+var SubagentProgressEventSchema = z.object({
+  taskId: z.string(),
+  toolUses: z.number().int(),
+  lastToolName: z.string().optional(),
+  durationMs: z.number().int()
+}).openapi("SubagentProgressEvent");
+var SubagentDoneEventSchema = z.object({
+  taskId: z.string(),
+  status: z.enum(["completed", "failed", "stopped"]),
+  summary: z.string().optional(),
+  toolUses: z.number().int().optional(),
+  durationMs: z.number().int().optional()
+}).openapi("SubagentDoneEvent");
+var SystemStatusEventSchema = z.object({
+  message: z.string()
+}).openapi("SystemStatusEvent");
+var CompactBoundaryEventSchema = z.object({}).openapi("CompactBoundaryEvent");
+var PromptSuggestionEventSchema = z.object({
+  suggestions: z.array(z.string())
+}).openapi("PromptSuggestionEvent");
+var HookStartedEventSchema = z.object({
+  hookId: z.string(),
+  hookName: z.string(),
+  hookEvent: z.string(),
+  toolCallId: z.string().nullable()
+}).openapi("HookStartedEvent");
+var HookProgressEventSchema = z.object({
+  hookId: z.string(),
+  stdout: z.string(),
+  stderr: z.string()
+}).openapi("HookProgressEvent");
+var HookResponseEventSchema = z.object({
+  hookId: z.string(),
+  hookName: z.string(),
+  exitCode: z.number().optional(),
+  outcome: z.enum(["success", "error", "cancelled"]),
+  stdout: z.string(),
+  stderr: z.string()
+}).openapi("HookResponseEvent");
+var PresenceClientSchema = z.object({
+  type: z.enum(["web", "obsidian", "mcp", "unknown"]),
+  connectedAt: z.string()
+});
+var PresenceUpdateEventSchema = z.object({
+  sessionId: z.string(),
+  clientCount: z.number().int(),
+  clients: z.array(PresenceClientSchema),
+  lockInfo: z.object({
+    clientId: z.string(),
+    acquiredAt: z.string()
+  }).nullable()
+}).openapi("PresenceUpdateEvent");
 var StreamEventSchema = z.object({
   type: StreamEventTypeSchema,
   data: z.union([
     TextDeltaSchema,
+    ThinkingDeltaSchema,
     ToolCallEventSchema,
+    ToolProgressEventSchema,
     ApprovalEventSchema,
     QuestionPromptEventSchema,
     ErrorEventSchema,
+    RateLimitEventSchema,
     DoneEventSchema,
     SessionStatusEventSchema,
     TaskUpdateEventSchema,
@@ -68981,31 +69070,84 @@ var StreamEventSchema = z.object({
     SyncConnectedEventSchema,
     RelayReceiptEventSchema,
     MessageDeliveredEventSchema,
-    RelayMessageEventSchema
+    RelayMessageEventSchema,
+    SubagentStartedEventSchema,
+    SubagentProgressEventSchema,
+    SubagentDoneEventSchema,
+    SystemStatusEventSchema,
+    CompactBoundaryEventSchema,
+    PromptSuggestionEventSchema,
+    HookStartedEventSchema,
+    HookProgressEventSchema,
+    HookResponseEventSchema,
+    PresenceUpdateEventSchema
   ])
 }).openapi("StreamEvent");
 var TextPartSchema = z.object({
   type: z.literal("text"),
   text: z.string()
 }).openapi("TextPart");
+var HookStatusSchema = z.enum(["running", "success", "error", "cancelled"]);
+var HookPartSchema = z.object({
+  hookId: z.string(),
+  hookName: z.string(),
+  hookEvent: z.string(),
+  status: HookStatusSchema,
+  stdout: z.string(),
+  stderr: z.string(),
+  exitCode: z.number().optional()
+});
 var ToolCallPartSchema = z.object({
   type: z.literal("tool_call"),
   toolCallId: z.string(),
   toolName: z.string(),
   input: z.string().optional(),
   result: z.string().optional(),
+  progressOutput: z.string().optional(),
   status: ToolCallStatusSchema,
   interactiveType: z.enum(["approval", "question"]).optional(),
   questions: z.array(QuestionItemSchema).optional(),
-  answers: z.record(z.string(), z.string()).optional()
+  answers: z.record(z.string(), z.string()).optional(),
+  timeoutMs: z.number().optional().describe("Approval timeout duration in milliseconds"),
+  hooks: z.array(HookPartSchema).optional()
 }).openapi("ToolCallPart");
-var MessagePartSchema = z.discriminatedUnion("type", [TextPartSchema, ToolCallPartSchema]);
+var SubagentStatusSchema = z.enum(["running", "complete", "error"]);
+var SubagentPartSchema = z.object({
+  type: z.literal("subagent"),
+  taskId: z.string(),
+  description: z.string(),
+  status: SubagentStatusSchema,
+  toolUses: z.number().int().optional(),
+  lastToolName: z.string().optional(),
+  durationMs: z.number().int().optional(),
+  summary: z.string().optional()
+}).openapi("SubagentPart");
+var ThinkingPartSchema = z.object({
+  type: z.literal("thinking"),
+  text: z.string(),
+  isStreaming: z.boolean().optional(),
+  elapsedMs: z.number().int().optional()
+}).openapi("ThinkingPart");
+var ErrorPartSchema = z.object({
+  type: z.literal("error"),
+  message: z.string(),
+  category: ErrorCategorySchema.optional(),
+  details: z.string().optional()
+}).openapi("ErrorPart");
+var MessagePartSchema = z.discriminatedUnion("type", [
+  TextPartSchema,
+  ToolCallPartSchema,
+  SubagentPartSchema,
+  ThinkingPartSchema,
+  ErrorPartSchema
+]);
 var MessageTypeSchema = z.enum(["command", "compaction"]).openapi("MessageType");
 var HistoryToolCallSchema = z.object({
   toolCallId: z.string(),
   toolName: z.string(),
   input: z.string().optional(),
   result: z.string().optional(),
+  progressOutput: z.string().optional(),
   status: z.literal("complete"),
   questions: z.array(QuestionItemSchema).optional(),
   answers: z.record(z.string(), z.string()).optional()
@@ -70918,7 +71060,7 @@ var SERVER_VERSION = resolveVersion();
 var IS_DEV_BUILD = checkDevBuild(SERVER_VERSION);
 function resolveVersion() {
   if (env.DORKOS_VERSION_OVERRIDE) return env.DORKOS_VERSION_OVERRIDE;
-  if (true) return "0.14.0";
+  if (true) return "0.16.0";
   const pkgPath = path4.join(path4.dirname(fileURLToPath2(import.meta.url)), "../../package.json");
   return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
 }
@@ -72128,7 +72270,8 @@ var TelegramAdapterConfigSchema = z11.object({
   mode: z11.enum(["polling", "webhook"]).default("polling"),
   webhookUrl: z11.string().url().optional(),
   webhookPort: z11.number().int().positive().optional(),
-  webhookSecret: z11.string().min(1).optional()
+  webhookSecret: z11.string().min(1).optional(),
+  streaming: z11.boolean().default(true)
 }).openapi("TelegramAdapterConfig");
 var WebhookInboundConfigSchema = z11.object({
   subject: z11.string().min(1),
@@ -72149,6 +72292,7 @@ var SlackAdapterConfigSchema = z11.object({
   appToken: z11.string().min(1),
   signingSecret: z11.string().min(1),
   streaming: z11.boolean().default(true),
+  nativeStreaming: z11.boolean().default(true),
   typingIndicator: z11.enum(["none", "reaction"]).default("none")
 }).openapi("SlackAdapterConfig");
 var AdapterConfigSchema = z11.object({
@@ -74206,7 +74350,9 @@ function parseTranscript(lines) {
       const parts = [];
       const toolCalls = [];
       for (const block of contentBlocks) {
-        if (block.type === "text" && block.text) {
+        if (block.type === "thinking" && block.thinking) {
+          parts.push({ type: "thinking", text: block.thinking, isStreaming: false });
+        } else if (block.type === "text" && block.text) {
           const lastPart = parts[parts.length - 1];
           if (lastPart && lastPart.type === "text") {
             lastPart.text += "\n" + block.text;
@@ -76292,9 +76438,16 @@ var esm_default = { watch, FSWatcher };
 
 // ../../apps/server/src/services/runtimes/claude-code/session-broadcaster.ts
 import { join as join3 } from "path";
+function inferClientType(clientId) {
+  if (clientId.startsWith("web-")) return "web";
+  if (clientId.startsWith("obsidian-")) return "obsidian";
+  if (clientId.startsWith("mcp-")) return "mcp";
+  return "unknown";
+}
 var SessionBroadcaster = class {
-  constructor(transcriptReader) {
+  constructor(transcriptReader, lockManager) {
     this.transcriptReader = transcriptReader;
+    this.lockManager = lockManager;
   }
   clients = /* @__PURE__ */ new Map();
   callbacks = /* @__PURE__ */ new Map();
@@ -76317,18 +76470,19 @@ var SessionBroadcaster = class {
   /**
    * Register an SSE client for a session.
    *
-   * - Adds the response to the set of connected clients
+   * - Adds the response to the client metadata map
    * - Starts a file watcher if none exists for this session
    * - Initializes offset to current file size (only broadcast new content)
    * - Sends sync_connected event to the client
    * - Auto-deregisters on response close
+   * - Broadcasts presence update to all clients for this session
    *
    * @param sessionId - Session UUID
    * @param vaultRoot - Vault root path for resolving transcript directory
    * @param res - Express Response object configured for SSE
-   * @param clientId - Optional client identifier
+   * @param clientId - Optional client identifier (used for type inference via prefix convention)
    */
-  registerClient(sessionId, vaultRoot2, res, _clientId) {
+  registerClient(sessionId, vaultRoot2, res, clientId) {
     if (this.totalClientCount >= SSE.MAX_TOTAL_CLIENTS) {
       res.status(503).json({ error: "SSE connection limit reached", code: "SSE_LIMIT" });
       return;
@@ -76338,10 +76492,17 @@ var SessionBroadcaster = class {
       res.status(503).json({ error: "Too many connections for this session", code: "SSE_SESSION_LIMIT" });
       return;
     }
+    const resolvedClientId = clientId ?? `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     if (!this.clients.has(sessionId)) {
-      this.clients.set(sessionId, /* @__PURE__ */ new Set());
+      this.clients.set(sessionId, /* @__PURE__ */ new Map());
     }
-    this.clients.get(sessionId).add(res);
+    const client = {
+      res,
+      clientId: resolvedClientId,
+      clientType: inferClientType(resolvedClientId),
+      connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.clients.get(sessionId).set(resolvedClientId, client);
     this.totalClientCount++;
     if (!this.watchers.has(sessionId)) {
       this.startWatcher(sessionId, vaultRoot2);
@@ -76353,6 +76514,7 @@ data: ${JSON.stringify({ sessionId })}
     res.on("close", () => {
       this.deregisterClient(sessionId, res);
     });
+    this.broadcastPresence(sessionId);
   }
   /**
    * Register a callback-based listener for session changes.
@@ -76396,7 +76558,8 @@ data: ${JSON.stringify({ sessionId })}
   /**
    * Deregister an SSE client from a session.
    *
-   * - Removes the response from the client set
+   * - Finds and removes the client by response reference
+   * - Broadcasts updated presence to remaining clients
    * - Stops the file watcher if no clients remain for this session
    * - Cleans up offsets and timers
    *
@@ -76404,13 +76567,22 @@ data: ${JSON.stringify({ sessionId })}
    * @param res - Express Response object to remove
    */
   deregisterClient(sessionId, res) {
-    const clientSet = this.clients.get(sessionId);
-    if (!clientSet) return;
-    if (clientSet.has(res)) {
-      this.totalClientCount--;
+    const clientMap = this.clients.get(sessionId);
+    if (!clientMap) return;
+    let removed = false;
+    for (const [id, client] of clientMap) {
+      if (client.res === res) {
+        clientMap.delete(id);
+        this.totalClientCount--;
+        removed = true;
+        break;
+      }
+    }
+    if (!removed) return;
+    if (clientMap.size > 0) {
+      this.broadcastPresence(sessionId);
     }
-    clientSet.delete(res);
-    if (clientSet.size === 0) {
+    if (clientMap.size === 0) {
       this.clients.delete(sessionId);
       const hasCallbacks = Array.from(this.callbacks.values()).some(
         (entry) => entry.sessionId === sessionId
@@ -76431,6 +76603,31 @@ data: ${JSON.stringify({ sessionId })}
       }
     }
   }
+  /**
+   * Get current presence info for a session.
+   *
+   * @param sessionId - Session UUID
+   * @returns Presence info with client count, client metadata, and lock state, or null if no clients
+   */
+  getPresenceInfo(sessionId) {
+    const clientMap = this.clients.get(sessionId);
+    if (!clientMap || clientMap.size === 0) return null;
+    const clients = Array.from(clientMap.values()).map((c3) => ({
+      type: c3.clientType,
+      connectedAt: c3.connectedAt
+    }));
+    let lockInfo = null;
+    if (this.lockManager) {
+      const lock = this.lockManager.getLockInfo(sessionId);
+      if (lock) {
+        lockInfo = {
+          clientId: lock.clientId,
+          acquiredAt: new Date(lock.acquiredAt).toISOString()
+        };
+      }
+    }
+    return { clientCount: clientMap.size, clients, lockInfo };
+  }
   /**
    * Start a chokidar file watcher for a session's JSONL transcript.
    *
@@ -76511,11 +76708,11 @@ data: ${JSON.stringify({ sessionId })}
       if (content3.length === 0) {
         return;
       }
-      const clientSet = this.clients.get(sessionId);
+      const clientMap = this.clients.get(sessionId);
       const hasCallbacks = Array.from(this.callbacks.values()).some(
         (entry) => entry.sessionId === sessionId
       );
-      if ((!clientSet || clientSet.size === 0) && !hasCallbacks) {
+      if ((!clientMap || clientMap.size === 0) && !hasCallbacks) {
         return;
       }
       const event = {
@@ -76526,12 +76723,12 @@ data: ${JSON.stringify({ sessionId })}
 data: ${JSON.stringify(event)}
 
 `;
-      if (clientSet) {
-        for (const client of Array.from(clientSet)) {
+      if (clientMap) {
+        for (const connectedClient of Array.from(clientMap.values())) {
           try {
-            const ok3 = client.write(eventData);
+            const ok3 = connectedClient.res.write(eventData);
             if (!ok3) {
-              await new Promise((resolve4) => client.once("drain", resolve4));
+              await new Promise((resolve4) => connectedClient.res.once("drain", resolve4));
             }
           } catch (err) {
             logger.error(
@@ -76560,6 +76757,60 @@ data: ${JSON.stringify(event)}
       logger.error(`[SessionBroadcaster] Failed to read offset for session ${sessionId}:`, err);
     }
   }
+  /** Broadcast a presence_update SSE event to all connected clients for a session. */
+  broadcastPresence(sessionId) {
+    const clientMap = this.clients.get(sessionId);
+    if (!clientMap || clientMap.size === 0) return;
+    const clients = Array.from(clientMap.values()).map((c3) => ({
+      type: c3.clientType,
+      connectedAt: c3.connectedAt
+    }));
+    let lockInfo = null;
+    if (this.lockManager) {
+      const lock = this.lockManager.getLockInfo(sessionId);
+      if (lock) {
+        lockInfo = {
+          clientId: lock.clientId,
+          acquiredAt: new Date(lock.acquiredAt).toISOString()
+        };
+      }
+    }
+    const presenceData = {
+      sessionId,
+      clientCount: clientMap.size,
+      clients,
+      lockInfo
+    };
+    const eventData = `event: presence_update
+data: ${JSON.stringify(presenceData)}
+
+`;
+    for (const client of clientMap.values()) {
+      try {
+        client.res.write(eventData);
+      } catch (err) {
+        logger.error(
+          `[SessionBroadcaster] Failed to write presence to client ${client.clientId}:`,
+          err
+        );
+      }
+    }
+    for (const [, entry] of this.callbacks) {
+      if (entry.sessionId === sessionId) {
+        try {
+          entry.callback({
+            type: "presence_update",
+            data: presenceData
+          });
+        } catch (err) {
+          logger.error(
+            `[SessionBroadcaster] Presence callback error for session ${sessionId}:`,
+            err
+          );
+        }
+      }
+    }
+  }
   /**
    * Shutdown the broadcaster, closing all watchers and client connections.
    * Should be called on server shutdown.
@@ -76574,10 +76825,10 @@ data: ${JSON.stringify(event)}
     });
     this.watchers.clear();
     this.callbacks.clear();
-    Array.from(this.clients.values()).forEach((clientSet) => {
-      Array.from(clientSet).forEach((client) => {
+    Array.from(this.clients.values()).forEach((clientMap) => {
+      Array.from(clientMap.values()).forEach((client) => {
         try {
-          client.end();
+          client.res.end();
         } catch {
         }
       });
@@ -76708,6 +76959,9 @@ function createToolState() {
   let currentToolName = "";
   let currentToolId = "";
   let taskToolInput = "";
+  let inThinking = false;
+  let thinkingStartMs = 0;
+  const toolNameById = /* @__PURE__ */ new Map();
   return {
     get inTool() {
       return inTool;
@@ -76721,6 +76975,19 @@ function createToolState() {
     get taskToolInput() {
       return taskToolInput;
     },
+    get inThinking() {
+      return inThinking;
+    },
+    set inThinking(v3) {
+      inThinking = v3;
+    },
+    get thinkingStartMs() {
+      return thinkingStartMs;
+    },
+    set thinkingStartMs(v3) {
+      thinkingStartMs = v3;
+    },
+    toolNameById,
     appendTaskInput: (chunk) => {
       taskToolInput += chunk;
     },
@@ -76816,7 +77083,8 @@ function handleToolApproval(session, toolUseId, toolName, input) {
     data: {
       toolCallId: toolUseId,
       toolName,
-      input: JSON.stringify(input)
+      input: JSON.stringify(input),
+      timeoutMs: SESSIONS.INTERACTION_TIMEOUT_MS
     }
   });
   session.eventQueueNotify?.();
@@ -76879,6 +77147,25 @@ function buildTaskEvent(toolName, input) {
 }
 
 // ../../apps/server/src/services/runtimes/claude-code/sdk-event-mapper.ts
+var TOOL_CONTEXTUAL_HOOK_EVENTS = /* @__PURE__ */ new Set([
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure"
+]);
+function mapErrorCategory(subtype) {
+  switch (subtype) {
+    case "error_max_turns":
+      return "max_turns";
+    case "error_during_execution":
+      return "execution_error";
+    case "error_max_budget_usd":
+      return "budget_exceeded";
+    case "error_max_structured_output_retries":
+      return "output_format_error";
+    default:
+      return "execution_error";
+  }
+}
 async function* mapSdkMessage(message, session, sessionId, toolState) {
   if (message.type === "system" && "subtype" in message && message.subtype === "init") {
     session.sdkSessionId = message.session_id;
@@ -76892,14 +77179,147 @@ async function* mapSdkMessage(message, session, sessionId, toolState) {
     }
     return;
   }
+  if (message.type === "system" && "subtype" in message) {
+    if (message.subtype === "task_started") {
+      const msg = message;
+      yield {
+        type: "subagent_started",
+        data: {
+          taskId: msg.task_id,
+          subagentSessionId: message.session_id,
+          toolUseId: msg.tool_use_id,
+          description: msg.description
+        }
+      };
+      return;
+    }
+    if (message.subtype === "task_progress") {
+      const msg = message;
+      const usage = msg.usage;
+      yield {
+        type: "subagent_progress",
+        data: {
+          taskId: msg.task_id,
+          toolUses: usage.tool_uses,
+          lastToolName: msg.last_tool_name,
+          durationMs: usage.duration_ms
+        }
+      };
+      return;
+    }
+    if (message.subtype === "task_notification") {
+      const msg = message;
+      const usage = msg.usage;
+      yield {
+        type: "subagent_done",
+        data: {
+          taskId: msg.task_id,
+          status: msg.status,
+          summary: msg.summary,
+          toolUses: usage?.tool_uses,
+          durationMs: usage?.duration_ms
+        }
+      };
+      return;
+    }
+    if (message.subtype === "status") {
+      const msg = message;
+      const text6 = msg.body ?? msg.message ?? "";
+      if (text6) {
+        yield {
+          type: "system_status",
+          data: { message: text6 }
+        };
+      }
+      return;
+    }
+    if (message.subtype === "compact_boundary") {
+      yield {
+        type: "compact_boundary",
+        data: {}
+      };
+      return;
+    }
+    if (message.subtype === "hook_started") {
+      const msg = message;
+      const hookEvent = msg.hook_event;
+      const isToolContextual = TOOL_CONTEXTUAL_HOOK_EVENTS.has(hookEvent);
+      if (isToolContextual) {
+        yield {
+          type: "hook_started",
+          data: {
+            hookId: msg.hook_id,
+            hookName: msg.hook_name,
+            hookEvent,
+            toolCallId: toolState.currentToolId || null
+          }
+        };
+      } else {
+        yield {
+          type: "system_status",
+          data: { message: `Running hook "${msg.hook_name}"...` }
+        };
+      }
+      return;
+    }
+    if (message.subtype === "hook_progress") {
+      const msg = message;
+      const hookEvent = msg.hook_event;
+      const isToolContextual = TOOL_CONTEXTUAL_HOOK_EVENTS.has(hookEvent);
+      if (isToolContextual) {
+        yield {
+          type: "hook_progress",
+          data: {
+            hookId: msg.hook_id,
+            stdout: msg.stdout,
+            stderr: msg.stderr
+          }
+        };
+      }
+      return;
+    }
+    if (message.subtype === "hook_response") {
+      const msg = message;
+      const hookEvent = msg.hook_event;
+      const isToolContextual = TOOL_CONTEXTUAL_HOOK_EVENTS.has(hookEvent);
+      if (isToolContextual) {
+        yield {
+          type: "hook_response",
+          data: {
+            hookId: msg.hook_id,
+            hookName: msg.hook_name,
+            exitCode: msg.exit_code,
+            outcome: msg.outcome,
+            stdout: msg.stdout,
+            stderr: msg.stderr
+          }
+        };
+      } else if (msg.outcome === "error") {
+        yield {
+          type: "error",
+          data: {
+            message: `Hook "${msg.hook_name}" failed (${hookEvent})`,
+            code: "hook_failure",
+            category: "execution_error",
+            details: msg.stderr || msg.stdout
+          }
+        };
+      }
+      return;
+    }
+  }
   if (message.type === "stream_event") {
     const event = message.event;
     const eventType = event.type;
     if (eventType === "content_block_start") {
       const contentBlock = event.content_block;
-      if (contentBlock?.type === "tool_use") {
+      if (contentBlock?.type === "thinking") {
+        toolState.inThinking = true;
+        toolState.thinkingStartMs = Date.now();
+      } else if (contentBlock?.type === "tool_use") {
         toolState.resetTaskInput();
         toolState.setToolState(true, contentBlock.name, contentBlock.id);
+        toolState.toolNameById.set(contentBlock.id, contentBlock.name);
         yield {
           type: "tool_call_start",
           data: {
@@ -76911,7 +77331,9 @@ async function* mapSdkMessage(message, session, sessionId, toolState) {
       }
     } else if (eventType === "content_block_delta") {
       const delta = event.delta;
-      if (delta?.type === "text_delta" && !toolState.inTool) {
+      if (delta?.type === "thinking_delta" && toolState.inThinking) {
+        yield { type: "thinking_delta", data: { text: delta.thinking } };
+      } else if (delta?.type === "text_delta" && !toolState.inTool) {
         yield { type: "text_delta", data: { text: delta.text } };
       } else if (delta?.type === "input_json_delta" && toolState.inTool) {
         if (TASK_TOOL_NAMES.has(toolState.currentToolName)) {
@@ -76927,8 +77349,27 @@ async function* mapSdkMessage(message, session, sessionId, toolState) {
           }
         };
       }
+    } else if (eventType === "message_delta") {
+      const delta = event.delta;
+      const usage = event.usage;
+      const stopReason = delta?.stop_reason;
+      const outputTokens = usage?.output_tokens;
+      if (outputTokens !== void 0) {
+        yield {
+          type: "session_status",
+          data: { sessionId, outputTokens }
+        };
+      }
+      if (stopReason === "max_tokens") {
+        yield {
+          type: "system_status",
+          data: { message: "Response truncated \u2014 reached max output tokens." }
+        };
+      }
     } else if (eventType === "content_block_stop") {
-      if (toolState.inTool) {
+      if (toolState.inThinking) {
+        toolState.inThinking = false;
+      } else if (toolState.inTool) {
         const wasTaskTool = TASK_TOOL_NAMES.has(toolState.currentToolName);
         const taskToolName = toolState.currentToolName;
         yield {
@@ -76962,7 +77403,7 @@ async function* mapSdkMessage(message, session, sessionId, toolState) {
         type: "tool_result",
         data: {
           toolCallId: toolUseId,
-          toolName: "",
+          toolName: toolState.toolNameById.get(toolUseId) ?? "",
           result: summary.summary,
           status: "complete"
         }
@@ -76970,6 +77411,35 @@ async function* mapSdkMessage(message, session, sessionId, toolState) {
     }
     return;
   }
+  if (message.type === "tool_progress") {
+    const progress = message;
+    yield {
+      type: "tool_progress",
+      data: {
+        toolCallId: progress.tool_use_id,
+        content: progress.content
+      }
+    };
+    return;
+  }
+  if (message.type === "prompt_suggestion") {
+    const suggestions = message.suggestions;
+    if (Array.isArray(suggestions) && suggestions.length > 0) {
+      yield {
+        type: "prompt_suggestion",
+        data: { suggestions }
+      };
+    }
+    return;
+  }
+  if (message.type === "rate_limit_event") {
+    const retryAfter = message.retry_after;
+    yield {
+      type: "rate_limit",
+      data: { retryAfter }
+    };
+    return;
+  }
   if (message.type === "result") {
     const result2 = message;
     const usage = result2.usage;
@@ -76985,11 +77455,31 @@ async function* mapSdkMessage(message, session, sessionId, toolState) {
         contextMaxTokens: firstModelUsage?.contextWindow
       }
     };
+    const subtype = result2.subtype;
+    if (subtype && subtype !== "success") {
+      const errors = result2.errors;
+      const category = mapErrorCategory(subtype);
+      yield {
+        type: "error",
+        data: {
+          message: errors?.[0] ?? "An unexpected error occurred.",
+          code: subtype,
+          category,
+          details: errors?.join("\n")
+        }
+      };
+    }
     yield {
       type: "done",
       data: { sessionId }
     };
+    return;
   }
+  logger.debug(
+    "Unhandled SDK message type: %s (subtype: %s)",
+    message.type,
+    "subtype" in message ? message.subtype : "none"
+  );
 }
 
 // ../../apps/server/src/services/runtimes/claude-code/context-builder.ts
@@ -77333,15 +77823,15 @@ var RESUME_FAILURE_PATTERNS = [
   "query closed before response",
   "session not found",
   "no such file",
-  "enoent",
-  "process exited with code"
+  "enoent"
 ];
+var MAX_RESUME_RETRIES = 1;
 function isResumeFailure(err) {
   if (!(err instanceof Error)) return false;
   const msg = err.message.toLowerCase();
   return RESUME_FAILURE_PATTERNS.some((p2) => msg.includes(p2));
 }
-async function* executeSdkQuery(sessionId, content3, session, opts, messageOpts) {
+async function* executeSdkQuery(sessionId, content3, session, opts, messageOpts, retryDepth = 0) {
   session.lastActivity = Date.now();
   session.eventQueue = [];
   const effectiveCwd = messageOpts?.cwd || opts.sessionCwd || opts.cwd;
@@ -77383,6 +77873,7 @@ ${messageOpts.systemPromptAppend}` : baseAppend;
   const sdkOptions = {
     cwd: effectiveCwd,
     includePartialMessages: true,
+    promptSuggestions: true,
     settingSources: ["project", "user"],
     systemPrompt: {
       type: "preset",
@@ -77469,7 +77960,10 @@ ${messageOpts.systemPromptAppend}` : baseAppend;
     effectiveCwd
   });
   let emittedDone = false;
+  let emittedError = false;
   let eventCount = 0;
+  let contentEventCount = 0;
+  let wasInteractive = false;
   const streamStart = Date.now();
   const toolState = createToolState();
   try {
@@ -77503,6 +77997,12 @@ ${messageOpts.systemPromptAppend}` : baseAppend;
             opts.meshCore.updateLastSeen(meshAgentId, "response_complete");
           }
         }
+        if (["text_delta", "tool_call_start", "tool_result", "thinking_delta"].includes(event.type)) {
+          contentEventCount++;
+        }
+        if (["approval_required", "question_prompt"].includes(event.type)) {
+          wasInteractive = true;
+        }
         eventCount++;
         yield event;
       }
@@ -77512,34 +78012,57 @@ ${messageOpts.systemPromptAppend}` : baseAppend;
       }
     }
   } catch (err) {
-    if (session.hasStarted && isResumeFailure(err)) {
+    if (session.hasStarted && isResumeFailure(err) && retryDepth < MAX_RESUME_RETRIES) {
       logger.warn("[sendMessage] resume failed for stale session, retrying as new", {
         session: sessionId,
+        retryDepth,
         error: err instanceof Error ? err.message : String(err)
       });
       session.hasStarted = false;
-      yield* executeSdkQuery(sessionId, content3, session, opts, messageOpts);
+      yield* executeSdkQuery(sessionId, content3, session, opts, messageOpts, retryDepth + 1);
       return;
     }
+    const errMsg = err instanceof Error ? err.message : String(err);
     logger.warn("[sendMessage] stream error", {
       session: sessionId,
-      error: err instanceof Error ? err.message : String(err),
+      error: errMsg,
       durationMs: Date.now() - streamStart,
-      eventCount
+      eventCount,
+      contentEventCount,
+      retryDepth
     });
     yield {
       type: "error",
       data: {
-        message: err instanceof Error ? err.message : "SDK error"
+        message: "The agent stopped unexpectedly. The service may be temporarily overloaded \u2014 try again in a moment.",
+        category: "execution_error",
+        details: errMsg
       }
     };
+    emittedError = true;
   } finally {
     session.activeQuery = void 0;
   }
+  if (contentEventCount === 0 && !emittedError && !wasInteractive) {
+    logger.warn("[sendMessage] stream completed with zero content events", {
+      session: sessionId,
+      eventCount,
+      durationMs: Date.now() - streamStart
+    });
+    yield {
+      type: "error",
+      data: {
+        message: "The agent did not respond. The service may be temporarily unavailable.",
+        category: "execution_error"
+      }
+    };
+    emittedError = true;
+  }
   logger.info("[sendMessage] stream done", {
     session: sessionId,
     durationMs: Date.now() - streamStart,
-    eventCount
+    eventCount,
+    contentEventCount
   });
   if (!emittedDone) {
     yield {
@@ -77601,7 +78124,7 @@ var ClaudeCodeRuntime = class _ClaudeCodeRuntime {
     this.cwd = cwd ?? DEFAULT_CWD;
     this.claudeCliPath = resolveClaudeCliPath();
     this.transcriptReader = new TranscriptReader();
-    this.broadcaster = new SessionBroadcaster(this.transcriptReader);
+    this.broadcaster = new SessionBroadcaster(this.transcriptReader, this.lockManager);
   }
   // ---------------------------------------------------------------------------
   // Capabilities
@@ -87076,7 +87599,10 @@ var SignalEmitter = class {
 var DEFAULT_RATE_LIMIT_CONFIG = {
   enabled: true,
   windowSecs: 60,
-  maxPerWindow: 100
+  maxPerWindow: 100,
+  perSenderOverrides: {
+    "agent:": 2e3
+  }
 };
 function checkRateLimit(sender, countInWindow, config = DEFAULT_RATE_LIMIT_CONFIG) {
   if (!config.enabled) {
@@ -87641,6 +88167,9 @@ var WatcherManager = class {
 };
 
 // ../relay/dist/types.js
+var noop = () => {
+};
+var noopLogger = { debug: noop, info: noop, warn: noop, error: noop };
 function inferEndpointType2(subject) {
   if (subject.startsWith("relay.inbox.dispatch."))
     return "dispatch";
@@ -88198,6 +88727,8 @@ var BaseRelayAdapter = class {
   displayName;
   /** Reference to the relay publisher, set on start, cleared on stop. */
   relay = null;
+  /** Logger for debug/info/warn/error output. Silent until injected via {@link setLogger}. */
+  logger = noopLogger;
   _status = {
     state: "disconnected",
     messageCount: { inbound: 0, outbound: 0 },
@@ -88208,6 +88739,17 @@ var BaseRelayAdapter = class {
     this.subjectPrefix = subjectPrefix;
     this.displayName = displayName;
   }
+  /**
+   * Inject a logger for structured debug output.
+   *
+   * Call after construction (typically from the adapter factory).
+   * Until called, the adapter uses a silent no-op logger.
+   *
+   * @param logger - A logger compatible with consola's tagged logger
+   */
+  setLogger(logger3) {
+    this.logger = logger3;
+  }
   /**
    * Start the adapter with idempotency guard and status tracking.
    *
@@ -88220,6 +88762,7 @@ var BaseRelayAdapter = class {
       return;
     this._status = { ...this._status, state: "starting" };
     this.relay = relay;
+    this.logger.info("starting");
     try {
       await this._start(relay);
       this._status = {
@@ -88227,6 +88770,7 @@ var BaseRelayAdapter = class {
         state: "connected",
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
+      this.logger.info("connected");
     } catch (err) {
       this.recordError(err);
       this.relay = null;
@@ -88242,6 +88786,7 @@ var BaseRelayAdapter = class {
     if (this._status.state === "disconnected")
       return;
     this._status = { ...this._status, state: "stopping" };
+    this.logger.info("stopping");
     try {
       await this._stop();
     } finally {
@@ -88251,6 +88796,7 @@ var BaseRelayAdapter = class {
         messageCount: this._status.messageCount,
         errorCount: this._status.errorCount
       };
+      this.logger.info("stopped");
     }
   }
   /**
@@ -88299,6 +88845,7 @@ var BaseRelayAdapter = class {
    */
   recordError(err) {
     const message = err instanceof Error ? err.message : String(err);
+    this.logger.warn("error:", message);
     this._status = {
       ...this._status,
       state: "error",
@@ -88316,6 +88863,7 @@ var BaseRelayAdapter = class {
   setReconnecting() {
     if (this._status.state !== "error")
       return;
+    this.logger.info("reconnecting");
     this._status = { ...this._status, state: "reconnecting" };
   }
   /**
@@ -88501,17 +89049,23 @@ function extractChannelName(chat) {
   }
   return void 0;
 }
-async function handleInboundMessage(ctx, relay, callbacks) {
-  if (!ctx.message)
+async function handleInboundMessage(ctx, relay, callbacks, logger3 = noopLogger) {
+  if (!ctx.message) {
+    logger3.debug("inbound skipped: no message in context");
     return;
+  }
   const { chat, from, message } = ctx;
-  if (!chat || !message)
+  if (!chat || !message) {
+    logger3.debug("inbound skipped: missing chat or message");
     return;
+  }
   const isGroup = isGroupChat(chat.type);
   const subject = buildSubject(chat.id, isGroup);
   const rawText = message.text ?? message.caption ?? "";
-  if (!rawText)
+  if (!rawText) {
+    logger3.debug(`inbound skipped: no text content in chat ${chat.id}`);
     return;
+  }
   const text6 = rawText.slice(0, MAX_CONTENT_LENGTH);
   const senderName = from ? [from.first_name, from.last_name].filter(Boolean).join(" ") || from.username || UNKNOWN_SENDER : UNKNOWN_SENDER;
   const payload = {
@@ -88539,11 +89093,16 @@ async function handleInboundMessage(ctx, relay, callbacks) {
       replyTo: subject
     });
     callbacks.trackInbound();
+    logger3.debug(`inbound from ${senderName} in chat ${chat.id}: "${text6.slice(0, 80)}${text6.length > 80 ? "\u2026" : ""}" (${text6.length} chars) \u2192 ${subject}`);
   } catch (err) {
     callbacks.recordError(err);
+    logger3.warn(`inbound publish failed for chat ${chat.id}:`, err instanceof Error ? err.message : String(err));
   }
 }
 
+// ../relay/dist/adapters/telegram/outbound.js
+import { randomBytes } from "node:crypto";
+
 // ../../node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js
 function bail(error) {
   if (error) {
@@ -100906,19 +101465,6 @@ function truncateText(text6, maxLen) {
     return text6;
   return `${text6.slice(0, maxLen - 3)}...`;
 }
-var SILENT_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "session_status",
-  "tool_call_start",
-  "tool_call_delta",
-  "tool_call_end",
-  "tool_result",
-  "approval_required",
-  "question_prompt",
-  "task_update",
-  "relay_receipt",
-  "message_delivered",
-  "relay_message"
-]);
 function detectStreamEventType(payload) {
   if (payload === null || typeof payload !== "object")
     return null;
@@ -100947,6 +101493,40 @@ function extractErrorMessage(payload) {
   const data = obj.data;
   return typeof data?.message === "string" ? data.message : null;
 }
+function extractApprovalData(payload) {
+  if (payload === null || typeof payload !== "object")
+    return null;
+  const obj = payload;
+  if (obj.type !== "approval_required")
+    return null;
+  const data = obj.data;
+  if (!data?.toolCallId || !data?.toolName)
+    return null;
+  return {
+    toolCallId: data.toolCallId,
+    toolName: data.toolName,
+    input: data.input ?? "",
+    timeoutMs: data.timeoutMs ?? 6e5
+  };
+}
+function formatToolDescription(toolName, input) {
+  try {
+    const parsed = JSON.parse(input);
+    if (toolName === "Write" && typeof parsed.path === "string") {
+      return `wants to write to \`${parsed.path}\``;
+    }
+    if (toolName === "Edit" && typeof parsed.file_path === "string") {
+      return `wants to edit \`${parsed.file_path}\``;
+    }
+    if (toolName === "Bash" && typeof parsed.command === "string") {
+      const cmd = parsed.command;
+      const preview = cmd.length > 60 ? `${cmd.slice(0, 57)}...` : cmd;
+      return `wants to run \`${preview}\``;
+    }
+  } catch {
+  }
+  return `wants to use tool \`${toolName}\``;
+}
 function formatForPlatform(content3, platform2) {
   switch (platform2) {
     case "slack":
@@ -100962,6 +101542,19 @@ function formatForPlatform(content3, platform2) {
 var TELEGRAM_TYPING_ACTION = "typing";
 var typingIntervals = /* @__PURE__ */ new Map();
 var TYPING_REFRESH_MS = 4e3;
+var DRAFT_UPDATE_INTERVAL_MS = 200;
+var BUFFER_TTL_MS = 5 * 60 * 1e3;
+var lastDraftUpdate = /* @__PURE__ */ new Map();
+var callbackIdMap = /* @__PURE__ */ new Map();
+var CALLBACK_ID_TTL_MS = 15 * 60 * 1e3;
+var pendingApprovalTimeouts = /* @__PURE__ */ new Map();
+function clearApprovalTimeout(shortKey) {
+  const timer = pendingApprovalTimeouts.get(shortKey);
+  if (timer) {
+    clearTimeout(timer);
+    pendingApprovalTimeouts.delete(shortKey);
+  }
+}
 async function sendAndTrack(bot, chatId, text6, startTime, callbacks) {
   try {
     await bot.api.sendMessage(chatId, text6);
@@ -100977,9 +101570,10 @@ async function sendAndTrack(bot, chatId, text6, startTime, callbacks) {
   }
 }
 async function deliverMessage(opts) {
-  const { adapterId, subject, envelope, bot, responseBuffers, callbacks } = opts;
+  const { adapterId, subject, envelope, bot, responseBuffers, callbacks, streaming, logger: logger3 = noopLogger } = opts;
   const startTime = Date.now();
   if (envelope.from.startsWith(SUBJECT_PREFIX)) {
+    logger3.debug("deliver: echo prevention \u2014 skipping self-originated message");
     return { success: true, durationMs: Date.now() - startTime };
   }
   if (!bot) {
@@ -100997,18 +101591,43 @@ async function deliverMessage(opts) {
       durationMs: Date.now() - startTime
     };
   }
+  const now = Date.now();
+  for (const [id, buf] of responseBuffers) {
+    if (now - buf.startedAt > BUFFER_TTL_MS) {
+      responseBuffers.delete(id);
+      lastDraftUpdate.delete(id);
+      logger3.warn(`buffer: reaped stale buffer for chat ${id} (age: ${Math.round((now - buf.startedAt) / 1e3)}s)`);
+    }
+  }
   const eventType = detectStreamEventType(envelope.payload);
   if (eventType) {
     const textChunk = extractTextDelta(envelope.payload);
     if (textChunk) {
-      const existing = responseBuffers.get(chatId) ?? "";
-      responseBuffers.set(chatId, existing + textChunk);
+      logger3.debug(`deliver: text_delta to chat ${chatId} (${textChunk.length} chars)`);
+      const existing = responseBuffers.get(chatId);
+      responseBuffers.set(chatId, {
+        text: (existing?.text ?? "") + textChunk,
+        startedAt: existing?.startedAt ?? Date.now()
+      });
+      if (streaming && chatId > 0) {
+        const lastUpdate = lastDraftUpdate.get(chatId) ?? 0;
+        if (Date.now() - lastUpdate >= DRAFT_UPDATE_INTERVAL_MS) {
+          lastDraftUpdate.set(chatId, Date.now());
+          logger3.debug(`stream: sendMessageDraft to chat ${chatId} (${responseBuffers.get(chatId).text.length} chars)`);
+          try {
+            await bot.api.sendMessageDraft(chatId, responseBuffers.get(chatId).text);
+          } catch {
+          }
+        }
+      }
       return { success: true, durationMs: Date.now() - startTime };
     }
     const errorMsg = extractErrorMessage(envelope.payload);
     if (errorMsg) {
-      const buffered = responseBuffers.get(chatId) ?? "";
+      logger3.debug(`deliver: error to chat ${chatId}: "${errorMsg.slice(0, 100)}"`);
+      const buffered = responseBuffers.get(chatId)?.text ?? "";
       responseBuffers.delete(chatId);
+      lastDraftUpdate.delete(chatId);
       const text7 = buffered ? truncateText(`${buffered}
 
 [Error: ${errorMsg}]`, MAX_MESSAGE_LENGTH) : truncateText(`[Error: ${errorMsg}]`, MAX_MESSAGE_LENGTH);
@@ -101016,18 +101635,33 @@ async function deliverMessage(opts) {
     }
     if (eventType === "done") {
       const buffered = responseBuffers.get(chatId);
+      logger3.debug(`deliver: done for chat ${chatId} (buffered: ${buffered ? `${buffered.text.length} chars` : "empty"})`);
       responseBuffers.delete(chatId);
+      lastDraftUpdate.delete(chatId);
       if (buffered) {
-        return sendAndTrack(bot, chatId, truncateText(buffered, MAX_MESSAGE_LENGTH), startTime, callbacks);
+        return sendAndTrack(bot, chatId, truncateText(buffered.text, MAX_MESSAGE_LENGTH), startTime, callbacks);
       }
       return { success: true, durationMs: Date.now() - startTime };
     }
-    if (SILENT_EVENT_TYPES.has(eventType)) {
-      return { success: true, durationMs: Date.now() - startTime };
+    if (eventType === "approval_required") {
+      const data = extractApprovalData(envelope.payload);
+      if (data) {
+        logger3.debug(`deliver: approval_required for tool '${data.toolName}' to chat ${chatId}`);
+        const buffered = responseBuffers.get(chatId);
+        if (buffered?.text) {
+          responseBuffers.delete(chatId);
+          lastDraftUpdate.delete(chatId);
+          await sendAndTrack(bot, chatId, truncateText(buffered.text, MAX_MESSAGE_LENGTH), startTime, callbacks);
+        }
+        return handleApprovalRequired(bot, chatId, data, envelope, callbacks, startTime);
+      }
     }
+    logger3.debug(`deliver: dropping stream event '${eventType}' (whitelist)`);
+    return { success: true, durationMs: Date.now() - startTime };
   }
   const content3 = extractPayloadContent(envelope.payload);
   const text6 = truncateText(content3, MAX_MESSAGE_LENGTH);
+  logger3.debug(`deliver: standard payload to chat ${chatId} (${text6.length} chars)`);
   return sendAndTrack(bot, chatId, text6, startTime, callbacks);
 }
 async function handleTypingSignal(bot, subject, state) {
@@ -101065,6 +101699,66 @@ function clearAllTypingIntervals() {
   for (const interval of typingIntervals.values())
     clearInterval(interval);
   typingIntervals.clear();
+  lastDraftUpdate.clear();
+}
+function extractAgentIdFromEnvelope(envelope) {
+  const payload = envelope.payload;
+  const data = payload?.data;
+  return data?.agentId ?? "unknown";
+}
+function extractSessionIdFromEnvelope(envelope) {
+  const payload = envelope.payload;
+  const data = payload?.data;
+  return data?.ccaSessionKey ?? "unknown";
+}
+async function handleApprovalRequired(bot, chatId, data, envelope, callbacks, startTime) {
+  const agentId = extractAgentIdFromEnvelope(envelope);
+  const sessionId = extractSessionIdFromEnvelope(envelope);
+  const shortKey = randomBytes(6).toString("hex");
+  callbackIdMap.set(shortKey, { toolCallId: data.toolCallId, sessionId, agentId });
+  setTimeout(() => callbackIdMap.delete(shortKey), CALLBACK_ID_TTL_MS);
+  const toolDescription = formatToolDescription(data.toolName, data.input);
+  const inputPreview = truncateText(data.input, 400);
+  const messageText = `*Tool Approval Required*
+\`${data.toolName}\` ${toolDescription}
+
+\`\`\`
+${inputPreview}
+\`\`\``;
+  try {
+    const sent = await bot.api.sendMessage(chatId, messageText, {
+      parse_mode: "Markdown",
+      reply_markup: {
+        inline_keyboard: [
+          [
+            { text: "Approve", callback_data: JSON.stringify({ k: shortKey, a: 1 }) },
+            { text: "Deny", callback_data: JSON.stringify({ k: shortKey, a: 0 }) }
+          ]
+        ]
+      }
+    });
+    if (data.timeoutMs && data.timeoutMs > 0) {
+      const timer = setTimeout(async () => {
+        pendingApprovalTimeouts.delete(shortKey);
+        callbackIdMap.delete(shortKey);
+        try {
+          await bot.api.editMessageText(chatId, sent.message_id, `\u23F0 *Tool Approval Timed Out*
+~~\`${data.toolName}\`~~ ${toolDescription}`, { parse_mode: "Markdown" });
+        } catch {
+        }
+      }, data.timeoutMs);
+      pendingApprovalTimeouts.set(shortKey, timer);
+    }
+    callbacks.trackOutbound();
+    return { success: true, durationMs: Date.now() - startTime };
+  } catch (err) {
+    callbacks.recordError(err);
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      durationMs: Date.now() - startTime
+    };
+  }
 }
 
 // ../relay/dist/adapters/telegram/webhook.js
@@ -101196,6 +101890,15 @@ For local development, use a tunnel service (e.g., ngrok, Cloudflare Tunnel).`
       placeholder: "Auto-generated if empty",
       description: "Secret token for validating incoming webhook requests from Telegram.",
       showWhen: { field: "mode", equals: "webhook" }
+    },
+    {
+      key: "streaming",
+      label: "Streaming",
+      type: "boolean",
+      required: false,
+      description: "Stream responses in real-time using Telegram's sendMessageDraft API (DMs only). Groups always use buffer-and-flush.",
+      visibleByDefault: true,
+      helpMarkdown: "When enabled, recipients in DMs see text appearing in real-time (ChatGPT-style). Group chats always use buffer-and-flush regardless of this setting. Requires Telegram Bot API 9.5+."
     }
   ],
   setupInstructions: "Open Telegram and search for @BotFather. Send /newbot, choose a name and username. Copy the token provided."
@@ -101228,7 +101931,39 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
   async _start(relay) {
     const bot = new import_grammy2.Bot(this.config.token);
     bot.api.config.use((0, import_auto_retry.autoRetry)());
-    bot.on("message", (ctx) => handleInboundMessage(ctx, relay, this.makeInboundCallbacks()));
+    bot.on("message", (ctx) => handleInboundMessage(ctx, relay, this.makeInboundCallbacks(), this.logger));
+    bot.on("callback_query:data", async (ctx) => {
+      try {
+        const data = JSON.parse(ctx.callbackQuery.data);
+        const entry = callbackIdMap.get(data.k);
+        if (!entry) {
+          await ctx.answerCallbackQuery({ text: "This approval has expired." });
+          return;
+        }
+        const approved = data.a === 1;
+        callbackIdMap.delete(data.k);
+        clearApprovalTimeout(data.k);
+        const opts = { from: `telegram:${ctx.from.id}` };
+        await relay.publish(`relay.system.approval.${entry.agentId}`, {
+          type: "approval_response",
+          toolCallId: entry.toolCallId,
+          sessionId: entry.sessionId,
+          approved,
+          respondedBy: String(ctx.from.id),
+          platform: "telegram"
+        }, opts);
+        const decision = approved ? "Approved" : "Denied";
+        const emoji = approved ? "\u2705" : "\u274C";
+        await ctx.editMessageText(`${emoji} *Tool ${decision}*`, { parse_mode: "Markdown" });
+        await ctx.answerCallbackQuery({ text: `Tool ${decision}` });
+        this.logger.debug?.(`[Telegram] tool ${approved ? "approved" : "denied"}: toolCallId=${entry.toolCallId}`);
+      } catch (err) {
+        this.logger.error("[Telegram] callback query handler error:", err);
+        this.recordError(err);
+        await ctx.answerCallbackQuery({ text: "Error processing approval." }).catch(() => {
+        });
+      }
+    });
     bot.catch((err) => this.recordError(err));
     this.bot = bot;
     this.signalUnsub = relay.onSignal(`${SUBJECT_PREFIX}.>`, (subject, signal) => {
@@ -101280,7 +102015,9 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
       envelope,
       bot: this.bot,
       responseBuffers: this.responseBuffers,
-      callbacks: this.makeOutboundCallbacks()
+      callbacks: this.makeOutboundCallbacks(),
+      streaming: this.config.streaming ?? true,
+      logger: this.logger
     });
   }
   // --- Private helpers ---
@@ -101328,7 +102065,7 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
       }
       const newBot = new import_grammy2.Bot(this.config.token);
       newBot.api.config.use((0, import_auto_retry.autoRetry)());
-      newBot.on("message", (ctx) => handleInboundMessage(ctx, this.relay, this.makeInboundCallbacks()));
+      newBot.on("message", (ctx) => handleInboundMessage(ctx, this.relay, this.makeInboundCallbacks(), this.logger));
       newBot.catch((e2) => this.recordError(e2));
       this.bot = newBot;
       this.startPollingMode(newBot).catch((e2) => this.handlePollingError(e2));
@@ -101746,15 +102483,23 @@ function clearCaches() {
   userNameCache.clear();
   channelNameCache.clear();
 }
-async function handleInboundMessage2(event, client, relay, botUserId, callbacks) {
-  if (event.user === botUserId)
+async function handleInboundMessage2(event, client, relay, botUserId, callbacks, logger3 = noopLogger) {
+  if (event.user === botUserId) {
+    logger3.debug(`inbound skipped: echo (own user ${botUserId})`);
     return;
-  if (event.bot_id)
+  }
+  if (event.bot_id) {
+    logger3.debug(`inbound skipped: bot message (bot_id=${event.bot_id})`);
     return;
-  if (event.subtype && SKIP_SUBTYPES.has(event.subtype))
+  }
+  if (event.subtype && SKIP_SUBTYPES.has(event.subtype)) {
+    logger3.debug(`inbound skipped: subtype '${event.subtype}'`);
     return;
-  if (!event.text)
+  }
+  if (!event.text) {
+    logger3.debug(`inbound skipped: no text content in ${event.channel}`);
     return;
+  }
   const isGroup = isGroupChannel(event.channel);
   const subject = buildSubject2(event.channel, isGroup);
   const content3 = event.text.slice(0, MAX_CONTENT_LENGTH2);
@@ -101785,8 +102530,10 @@ async function handleInboundMessage2(event, client, relay, botUserId, callbacks)
       replyTo: subject
     });
     callbacks.trackInbound();
+    logger3.debug(`inbound from ${senderName} in ${event.channel}: "${content3.slice(0, 80)}${content3.length > 80 ? "\u2026" : ""}" (${content3.length} chars) \u2192 ${subject}`);
   } catch (err) {
     callbacks.recordError(err);
+    logger3.warn(`inbound publish failed for ${event.channel}:`, err instanceof Error ? err.message : String(err));
   }
 }
 
@@ -101794,6 +102541,14 @@ async function handleInboundMessage2(event, client, relay, botUserId, callbacks)
 import { randomUUID as randomUUID4 } from "node:crypto";
 var STREAM_UPDATE_INTERVAL_MS = 1e3;
 var STREAM_TTL_MS = 5 * 60 * 1e3;
+var pendingApprovalTimeouts2 = /* @__PURE__ */ new Map();
+function clearApprovalTimeout2(toolCallId) {
+  const entry = pendingApprovalTimeouts2.get(toolCallId);
+  if (entry) {
+    clearTimeout(entry.timer);
+    pendingApprovalTimeouts2.delete(toolCallId);
+  }
+}
 function streamKey(channelId, threadTs) {
   return threadTs ? `${channelId}:${threadTs}` : channelId;
 }
@@ -101846,7 +102601,7 @@ function removeTypingReaction(client, channelId, threadTs, typingIndicator) {
   }).catch(() => {
   });
 }
-async function handleTextDelta(channelId, textChunk, threadTs, client, streamState, callbacks, startTime, streaming, typingIndicator, streamKeyTs) {
+async function handleTextDelta(channelId, textChunk, threadTs, client, streamState, callbacks, startTime, streaming, nativeStreaming, typingIndicator, streamKeyTs) {
   const key = streamKey(channelId, streamKeyTs);
   const existing = streamState.get(key);
   if (!streaming) {
@@ -101869,6 +102624,12 @@ async function handleTextDelta(channelId, textChunk, threadTs, client, streamSta
   }
   if (existing) {
     existing.accumulatedText += textChunk;
+    if (existing.nativeStreamId) {
+      return wrapSlackCall(() => client.chat.appendStream({
+        stream_id: existing.nativeStreamId,
+        text: formatForPlatform(textChunk, "slack")
+      }), callbacks, startTime);
+    }
     const now = Date.now();
     if (now - existing.lastUpdateAt < STREAM_UPDATE_INTERVAL_MS) {
       return { success: true, durationMs: now - startTime };
@@ -101882,6 +102643,36 @@ async function handleTextDelta(channelId, textChunk, threadTs, client, streamSta
       text: truncateText(streamText, MAX_MESSAGE_LENGTH2)
     }), callbacks, startTime);
   }
+  if (nativeStreaming && threadTs) {
+    try {
+      const slackClient = client;
+      const result2 = await slackClient.chat.startStream({
+        channel: channelId,
+        thread_ts: threadTs
+      });
+      const nativeStreamId = result2.stream_id ?? "";
+      const now = Date.now();
+      streamState.set(key, {
+        channelId,
+        threadTs: threadTs ?? "",
+        messageTs: "",
+        // Not used in native streaming
+        accumulatedText: textChunk,
+        lastUpdateAt: now,
+        startedAt: now,
+        streamId: randomUUID4(),
+        nativeStreamId
+      });
+      await slackClient.chat.appendStream({
+        stream_id: nativeStreamId,
+        text: formatForPlatform(textChunk, "slack")
+      });
+      addTypingReaction(client, channelId, threadTs, typingIndicator);
+      return { success: true, durationMs: Date.now() - startTime };
+    } catch (err) {
+      callbacks.recordError(err);
+    }
+  }
   try {
     const mrkdwn = formatForPlatform(textChunk, "slack");
     const now = Date.now();
@@ -101910,6 +102701,45 @@ async function handleTextDelta(channelId, textChunk, threadTs, client, streamSta
     };
   }
 }
+async function flushStreamBuffer(channelId, threadTs, client, streamState, callbacks, streamKeyTs) {
+  const key = streamKey(channelId, streamKeyTs);
+  const existing = streamState.get(key);
+  if (!existing || !existing.accumulatedText)
+    return;
+  if (existing.nativeStreamId) {
+    const slackClient = client;
+    try {
+      await slackClient.chat.stopStream({ stream_id: existing.nativeStreamId });
+    } catch {
+    }
+    existing.nativeStreamId = void 0;
+    return;
+  }
+  if (!existing.messageTs) {
+    try {
+      const result2 = await client.chat.postMessage({
+        channel: channelId,
+        text: truncateText(formatForPlatform(existing.accumulatedText, "slack"), MAX_MESSAGE_LENGTH2),
+        ...threadTs ? { thread_ts: threadTs } : {}
+      });
+      existing.messageTs = result2.ts ?? "";
+      existing.lastUpdateAt = Date.now();
+    } catch (err) {
+      callbacks.recordError(err);
+    }
+    return;
+  }
+  try {
+    await client.chat.update({
+      channel: channelId,
+      ts: existing.messageTs,
+      text: truncateText(formatForPlatform(existing.accumulatedText, "slack"), MAX_MESSAGE_LENGTH2)
+    });
+    existing.lastUpdateAt = Date.now();
+  } catch (err) {
+    callbacks.recordError(err);
+  }
+}
 async function handleDone(channelId, threadTs, client, streamState, callbacks, startTime, typingIndicator, streamKeyTs) {
   const key = streamKey(channelId, streamKeyTs);
   const existing = streamState.get(key);
@@ -101920,6 +102750,10 @@ async function handleDone(channelId, threadTs, client, streamState, callbacks, s
   if (!existing) {
     return { success: true, durationMs: Date.now() - startTime };
   }
+  if (existing.nativeStreamId) {
+    const slackClient = client;
+    return wrapSlackCall(() => slackClient.chat.stopStream({ stream_id: existing.nativeStreamId }), callbacks, startTime, true);
+  }
   if (!existing.messageTs) {
     return wrapSlackCall(() => client.chat.postMessage({
       channel: channelId,
@@ -101941,6 +102775,20 @@ async function handleError(channelId, errorMsg, threadTs, client, streamState, c
     removeTypingReaction(client, channelId, existing.threadTs, typingIndicator);
   }
   if (existing) {
+    if (existing.nativeStreamId) {
+      const slackClient = client;
+      const errorSuffix = formatForPlatform(`
+
+[Error: ${errorMsg}]`, "slack");
+      try {
+        await slackClient.chat.appendStream({
+          stream_id: existing.nativeStreamId,
+          text: errorSuffix
+        });
+      } catch {
+      }
+      return wrapSlackCall(() => slackClient.chat.stopStream({ stream_id: existing.nativeStreamId }), callbacks, startTime, true);
+    }
     const finalText = truncateText(`${formatForPlatform(existing.accumulatedText, "slack")}
 
 [Error: ${errorMsg}]`, MAX_MESSAGE_LENGTH2);
@@ -101965,14 +102813,16 @@ async function handleError(channelId, errorMsg, threadTs, client, streamState, c
   }), callbacks, startTime, true);
 }
 async function deliverMessage2(opts) {
-  const { adapterId, subject, envelope, client, streamState, callbacks } = opts;
+  const { adapterId, subject, envelope, client, streamState, callbacks, logger: logger3 = noopLogger } = opts;
   const startTime = Date.now();
   for (const [key, stream] of streamState) {
     if (startTime - stream.startedAt > STREAM_TTL_MS) {
       streamState.delete(key);
+      logger3.warn(`stream: reaped orphaned stream for ${key} (age: ${Math.round((startTime - stream.startedAt) / 1e3)}s)`);
     }
   }
   if (envelope.from.startsWith(SUBJECT_PREFIX2)) {
+    logger3.debug("deliver: echo prevention \u2014 skipping self-originated message");
     return { success: true, durationMs: Date.now() - startTime };
   }
   if (!client) {
@@ -101998,28 +102848,135 @@ async function deliverMessage2(opts) {
   if (eventType) {
     const textChunk = extractTextDelta(envelope.payload);
     if (textChunk) {
-      return handleTextDelta(channelId, textChunk, threadTs, client, streamState, callbacks, startTime, opts.streaming, opts.typingIndicator, streamKeyTs);
+      logger3.debug(`deliver: text_delta to ${channelId} (${textChunk.length} chars, streaming=${opts.streaming ? opts.nativeStreaming ? "native" : "legacy" : "buffered"})`);
+      return handleTextDelta(channelId, textChunk, threadTs, client, streamState, callbacks, startTime, opts.streaming, opts.nativeStreaming, opts.typingIndicator, streamKeyTs);
     }
     const errorMsg = extractErrorMessage(envelope.payload);
     if (errorMsg) {
+      logger3.debug(`deliver: error to ${channelId}: "${errorMsg.slice(0, 100)}"`);
       return handleError(channelId, errorMsg, threadTs, client, streamState, callbacks, startTime, opts.typingIndicator, streamKeyTs);
     }
     if (eventType === "done") {
+      logger3.debug(`deliver: done for ${channelId}`);
       return handleDone(channelId, threadTs, client, streamState, callbacks, startTime, opts.typingIndicator, streamKeyTs);
     }
-    if (SILENT_EVENT_TYPES.has(eventType)) {
-      return { success: true, durationMs: Date.now() - startTime };
+    if (eventType === "approval_required") {
+      const approvalData = extractApprovalData(envelope.payload);
+      if (approvalData) {
+        logger3.debug(`deliver: approval_required for tool '${approvalData.toolName}' to ${channelId}`);
+        await flushStreamBuffer(channelId, threadTs, client, streamState, callbacks, streamKeyTs);
+        return handleApprovalRequired2(channelId, threadTs, approvalData, envelope, client, callbacks, startTime);
+      }
     }
+    logger3.debug(`deliver: dropping stream event '${eventType}' (whitelist)`);
+    return { success: true, durationMs: Date.now() - startTime };
   }
   const content3 = extractPayloadContent(envelope.payload);
   const mrkdwn = formatForPlatform(content3, "slack");
   const text6 = truncateText(mrkdwn, MAX_MESSAGE_LENGTH2);
+  logger3.debug(`deliver: standard payload to ${channelId} (${text6.length} chars)`);
   return wrapSlackCall(() => client.chat.postMessage({
     channel: channelId,
     text: text6,
     ...threadTs ? { thread_ts: threadTs } : {}
   }), callbacks, startTime, true);
 }
+function extractAgentIdFromEnvelope2(envelope) {
+  const payload = envelope.payload;
+  const data = payload?.data;
+  return data?.agentId ?? "unknown";
+}
+function extractSessionIdFromEnvelope2(envelope) {
+  const payload = envelope.payload;
+  const data = payload?.data;
+  return data?.ccaSessionKey ?? "unknown";
+}
+async function handleApprovalRequired2(channelId, threadTs, data, envelope, client, callbacks, startTime) {
+  const agentId = extractAgentIdFromEnvelope2(envelope);
+  const sessionId = extractSessionIdFromEnvelope2(envelope);
+  const inputPreview = truncateText(data.input, 500);
+  const toolDescription = formatToolDescription(data.toolName, data.input);
+  const buttonValue = JSON.stringify({
+    toolCallId: data.toolCallId,
+    sessionId,
+    agentId
+  });
+  let postedTs;
+  const result2 = await wrapSlackCall(async () => {
+    const res = await client.chat.postMessage({
+      channel: channelId,
+      ...threadTs ? { thread_ts: threadTs } : {},
+      text: `Tool approval required: ${data.toolName} (fallback)`,
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `*Tool Approval Required*
+\`${data.toolName}\` ${toolDescription}`
+          }
+        },
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `\`\`\`
+${inputPreview}
+\`\`\``
+          }
+        },
+        {
+          type: "actions",
+          block_id: "tool_approval",
+          elements: [
+            {
+              type: "button",
+              text: { type: "plain_text", text: "Approve" },
+              style: "primary",
+              action_id: "tool_approve",
+              value: buttonValue
+            },
+            {
+              type: "button",
+              text: { type: "plain_text", text: "Deny" },
+              style: "danger",
+              action_id: "tool_deny",
+              value: buttonValue
+            }
+          ]
+        }
+      ]
+    });
+    postedTs = res.ts;
+  }, callbacks, startTime, true);
+  if (result2.success && postedTs && data.timeoutMs > 0) {
+    const msgTs = postedTs;
+    const timer = setTimeout(async () => {
+      pendingApprovalTimeouts2.delete(data.toolCallId);
+      try {
+        await client.chat.update({
+          channel: channelId,
+          ts: msgTs,
+          text: ":hourglass: Tool approval timed out",
+          blocks: [
+            {
+              type: "section",
+              text: { type: "mrkdwn", text: ":hourglass: *Tool Approval Timed Out*\n~`" + data.toolName + "`~" }
+            }
+          ]
+        });
+      } catch {
+      }
+    }, data.timeoutMs);
+    pendingApprovalTimeouts2.set(data.toolCallId, {
+      timer,
+      channelId,
+      messageTs: msgTs,
+      client
+    });
+  }
+  return result2;
+}
 
 // ../relay/dist/adapters/slack/slack-adapter.js
 var SLACK_APP_MANIFEST_YAML = `display_information:
@@ -102070,7 +103027,7 @@ var SLACK_MANIFEST = {
       stepId: "create-app",
       title: "Create & Configure a Slack App",
       description: 'Go to api.slack.com/apps \u2192 Create New App \u2192 From Scratch.\n\n1. **Socket Mode** \u2014 Enable it (Settings \u2192 Socket Mode).\n2. **Event Subscriptions** \u2014 Turn on Enable Events, then subscribe to bot events: message.channels, message.groups, message.im, app_mention.\n3. **OAuth & Permissions** \u2014 Add bot token scopes: channels:history, channels:read, chat:write, groups:history, groups:read, im:history, im:read, im:write, mpim:history, app_mentions:read, users:read, reactions:write. Then install the app to your workspace.\n4. **App-Level Token** \u2014 In Basic Information \u2192 App-Level Tokens, generate a token with the connections:write scope.\n\n\u26A0\uFE0F Do NOT enable "Agents & AI Apps" \u2014 it adds user scopes that cause install failures on most workspaces.',
-      fields: ["botToken", "appToken", "signingSecret", "streaming", "typingIndicator"]
+      fields: ["botToken", "appToken", "signingSecret", "streaming", "nativeStreaming", "typingIndicator"]
     }
   ],
   configFields: [
@@ -102129,6 +103086,15 @@ var SLACK_MANIFEST = {
       visibleByDefault: true,
       helpMarkdown: "When enabled, agent responses appear token-by-token in Slack via message editing. When disabled, the full response is sent as a single message after the agent finishes."
     },
+    {
+      key: "nativeStreaming",
+      label: "Native Streaming",
+      type: "boolean",
+      required: false,
+      description: "Use Slack's native streaming API (chat.startStream/appendStream/stopStream). Requires messages in threads.",
+      visibleByDefault: true,
+      helpMarkdown: "When enabled, uses Slack's purpose-built streaming API for smoother, flicker-free responses. When disabled, uses the legacy chat.update approach. Only applies when Stream Responses is enabled."
+    },
     {
       key: "typingIndicator",
       label: "Typing Indicator",
@@ -102183,10 +103149,18 @@ var SlackAdapter = class extends BaseRelayAdapter {
     const authResult = await app.client.auth.test();
     this.botUserId = authResult.user_id ?? "";
     app.message(async ({ event, client }) => {
-      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks());
+      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks(), this.logger);
     });
     app.event("app_mention", async ({ event, client }) => {
-      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks());
+      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks(), this.logger);
+    });
+    app.action("tool_approve", async ({ ack, action, body, client }) => {
+      await ack();
+      await this.handleToolAction(true, action, body, client, relay);
+    });
+    app.action("tool_deny", async ({ ack, action, body, client }) => {
+      await ack();
+      await this.handleToolAction(false, action, body, client, relay);
     });
     app.error(async (error) => {
       this.recordError(error);
@@ -102226,7 +103200,9 @@ var SlackAdapter = class extends BaseRelayAdapter {
       botUserId: this.botUserId,
       callbacks: this.makeOutboundCallbacks(),
       streaming: this.config.streaming ?? true,
-      typingIndicator: this.config.typingIndicator ?? "none"
+      nativeStreaming: this.config.nativeStreaming ?? true,
+      typingIndicator: this.config.typingIndicator ?? "none",
+      logger: this.logger
     });
   }
   /** Build callbacks for inbound message handling. */
@@ -102243,6 +103219,63 @@ var SlackAdapter = class extends BaseRelayAdapter {
       recordError: (err) => this.recordError(err)
     };
   }
+  /**
+   * Handle a tool approval or denial action from Slack interactive buttons.
+   *
+   * Parses the button value JSON, publishes an `approval_response` to the
+   * relay bus, and updates the original Slack message to reflect the decision.
+   *
+   * @param approved - Whether the user clicked Approve (true) or Deny (false)
+   * @param action - The Bolt action payload
+   * @param body - The Bolt body payload containing message context
+   * @param client - The Slack WebClient for updating messages
+   * @param relay - The relay publisher for publishing approval responses
+   */
+  async handleToolAction(approved, action, body, client, relay) {
+    try {
+      const btnAction = action;
+      const btnBody = body;
+      if (!btnAction.value) {
+        this.logger.warn("[Slack] tool action missing button value");
+        return;
+      }
+      const { toolCallId, sessionId, agentId } = JSON.parse(btnAction.value);
+      clearApprovalTimeout2(toolCallId);
+      const opts = { from: `slack:${btnBody.user?.id ?? "unknown"}` };
+      await relay.publish(`relay.system.approval.${agentId}`, {
+        type: "approval_response",
+        toolCallId,
+        sessionId,
+        approved,
+        respondedBy: btnBody.user?.id,
+        platform: "slack"
+      }, opts);
+      const channelId = btnBody.channel?.id;
+      const messageTs = btnBody.message?.ts;
+      if (channelId && messageTs) {
+        const decision = approved ? "Approved" : "Denied";
+        const emoji = approved ? ":white_check_mark:" : ":x:";
+        await client.chat.update({
+          channel: channelId,
+          ts: messageTs,
+          text: `${emoji} Tool ${decision} by <@${btnBody.user?.id ?? "unknown"}>`,
+          blocks: [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: `${emoji} *Tool ${decision}* by <@${btnBody.user?.id ?? "unknown"}>`
+              }
+            }
+          ]
+        });
+      }
+      this.logger.debug?.(`[Slack] tool ${approved ? "approved" : "denied"}: toolCallId=${toolCallId}`);
+    } catch (err) {
+      this.logger.error("[Slack] tool action handler error:", err);
+      this.recordError(err);
+    }
+  }
 };
 
 // ../relay/dist/adapters/claude-code/agent-handler.js
@@ -102269,7 +103302,7 @@ async function publishDispatchProgress(originalEnvelope, step, step_type, text6,
   };
   await relay.publish(originalEnvelope.replyTo, { type: "progress", step, step_type, text: text6, done: false }, opts);
 }
-async function publishResponseWithCorrelation(originalEnvelope, event, fromId, relay, log, correlationId) {
+async function publishResponseWithCorrelation(originalEnvelope, event, fromId, relay, log, correlationId, enrichment) {
   if (!originalEnvelope.replyTo)
     return;
   const opts = {
@@ -102278,7 +103311,20 @@ async function publishResponseWithCorrelation(originalEnvelope, event, fromId, r
       hopCount: originalEnvelope.budget.hopCount + 1
     }
   };
-  const payload = correlationId ? { ...event, correlationId } : event;
+  let payload;
+  if (event.type === "approval_required" && enrichment?.agentId) {
+    payload = {
+      ...event,
+      ...correlationId ? { correlationId } : {},
+      data: {
+        ...event.data,
+        agentId: enrichment.agentId,
+        ccaSessionKey: fromId
+      }
+    };
+  } else {
+    payload = correlationId ? { ...event, correlationId } : event;
+  }
   const result2 = await relay.publish(originalEnvelope.replyTo, payload, opts);
   if (result2.deliveredTo === 0 && event.type !== "done") {
     log.warn(`[CCA] publishResponse delivered to 0 subscribers: subject=${originalEnvelope.replyTo}, eventType=${event.type}`);
@@ -102331,7 +103377,7 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
   log.debug?.(`[CCA] handleAgentMessage agentId=${agentId} ccaSessionKey=${ccaSessionKey}, payloadCwd=${payloadCwd ?? "(none)"}, context.agent.directory=${context?.agent?.directory ?? "(none)"}, resolvedCwd=${effectiveCwd ?? "(deferred to session)"}`);
   deps.agentManager.ensureSession(ccaSessionKey, {
     permissionMode: "default",
-    hasStarted: true,
+    hasStarted: !!persistedSdkSessionId,
     ...effectiveCwd ? { cwd: effectiveCwd } : {}
   });
   deps.traceStore.updateSpan(envelope.id, { status: "delivered", deliveredAt: Date.now() });
@@ -102380,7 +103426,7 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
             await publishDispatchProgress(envelope, stepCounter, "tool_result", typeof data.content === "string" ? data.content : JSON.stringify(data), ccaSessionKey, relay);
           }
         } else {
-          await publishResponseWithCorrelation(envelope, event, ccaSessionKey, relay, log, correlationId);
+          await publishResponseWithCorrelation(envelope, event, ccaSessionKey, relay, log, correlationId, { agentId });
         }
       }
     }
@@ -102410,6 +103456,8 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
     if (actualSdkId && actualSdkId !== agentId) {
       deps.agentSessionStore.set(agentId, actualSdkId);
       log.debug?.(`[CCA] persisted session mapping: ${agentId} \u2192 ${actualSdkId}`);
+    } else {
+      log.debug?.(`[CCA] no session mapping to persist: agentId=${agentId}, ccaSessionKey=${ccaSessionKey}, actualSdkId=${actualSdkId ?? "(none)"}`);
     }
   }
   log.info(`ClaudeCodeAdapter: published ${eventCount} event(s) to ${envelope.replyTo ?? "(no replyTo)"}`);
@@ -102435,6 +103483,22 @@ function extractAgentId(subject) {
     return null;
   return segments[2] || null;
 }
+var PLATFORM_FORMATTING = {
+  slack: [
+    "Platform: Slack (mrkdwn format)",
+    "Formatting rules:",
+    "- Use *bold* (single asterisk), _italic_, ~strikethrough~, `code`",
+    "- Do NOT use Markdown tables (| col | col |) \u2014 Slack cannot render them",
+    "- For structured data, use bullet lists with bold labels instead",
+    "- Keep responses under 4000 characters"
+  ].join("\n"),
+  telegram: [
+    "Platform: Telegram",
+    "Formatting rules:",
+    "- Use standard Markdown: **bold**, _italic_, `code`",
+    "- Keep responses under 4096 characters"
+  ].join("\n")
+};
 function formatPromptWithContext(content3, envelope, agentId, sdkSessionId) {
   const lines = [
     `Agent-ID: ${agentId}`,
@@ -102452,6 +103516,12 @@ function formatPromptWithContext(content3, envelope, agentId, sdkSessionId) {
   if (envelope.replyTo) {
     lines.push("", `Reply to: ${envelope.replyTo}`, "If you cannot complete the task within the budget, summarize what you've done and stop.");
   }
+  const payloadObj = typeof envelope.payload === "object" && envelope.payload !== null ? envelope.payload : null;
+  const responseContext = payloadObj?.responseContext;
+  const platform2 = responseContext?.platform;
+  if (platform2 && PLATFORM_FORMATTING[platform2]) {
+    lines.push("", PLATFORM_FORMATTING[platform2]);
+  }
   return `<relay_context>
 ${lines.join("\n")}
 </relay_context>
@@ -102649,6 +103719,48 @@ var AgentQueue = class {
   }
 };
 
+// ../relay/dist/adapters/claude-code/approval-handler.js
+var APPROVAL_SUBJECT_PATTERN = "relay.system.approval.>";
+function parseApprovalPayload(payload) {
+  if (payload === null || typeof payload !== "object")
+    return null;
+  const obj = payload;
+  if (obj.type !== "approval_response")
+    return null;
+  if (typeof obj.toolCallId !== "string" || !obj.toolCallId)
+    return null;
+  if (typeof obj.sessionId !== "string" || !obj.sessionId)
+    return null;
+  if (typeof obj.approved !== "boolean")
+    return null;
+  return {
+    type: "approval_response",
+    toolCallId: obj.toolCallId,
+    sessionId: obj.sessionId,
+    approved: obj.approved,
+    respondedBy: typeof obj.respondedBy === "string" ? obj.respondedBy : void 0,
+    platform: typeof obj.platform === "string" ? obj.platform : void 0
+  };
+}
+function handleApprovalResponse(envelope, agentManager, log) {
+  const approval = parseApprovalPayload(envelope.payload);
+  if (!approval) {
+    log.warn(`[CCA] approval-handler: received malformed payload on ${envelope.subject} \u2014 expected type='approval_response' with toolCallId, sessionId, approved`);
+    return;
+  }
+  const { toolCallId, sessionId, approved, platform: platform2 = "unknown" } = approval;
+  log.debug?.(`[CCA] approval-handler: ${approved ? "approve" : "deny"} toolCallId=${toolCallId} sessionId=${sessionId} platform=${platform2}`);
+  const resolved = agentManager.approveTool(sessionId, toolCallId, approved);
+  if (!resolved) {
+    log.warn(`[CCA] approval-handler: approveTool returned false \u2014 interaction not found (already timed out?) toolCallId=${toolCallId} sessionId=${sessionId}`);
+  }
+}
+function subscribeApprovalHandler(relay, agentManager, log) {
+  return relay.subscribe(APPROVAL_SUBJECT_PATTERN, (envelope) => {
+    handleApprovalResponse(envelope, agentManager, log);
+  });
+}
+
 // ../relay/dist/adapters/claude-code/claude-code-adapter.js
 var CLAUDE_CODE_MANIFEST = {
   type: "claude-code",
@@ -102688,6 +103800,8 @@ var ClaudeCodeAdapter = class {
   relay = null;
   activeCount = 0;
   agentQueue = new AgentQueue();
+  /** Unsubscribe function for the `relay.system.approval.>` subscription. */
+  approvalUnsub = null;
   status = {
     state: "disconnected",
     messageCount: { inbound: 0, outbound: 0 },
@@ -102716,6 +103830,7 @@ var ClaudeCodeAdapter = class {
    */
   async start(relay) {
     this.relay = relay;
+    this.approvalUnsub = subscribeApprovalHandler(relay, this.deps.agentManager, this.deps.logger ?? console);
     this.status = {
       state: "connected",
       messageCount: { inbound: 0, outbound: 0 },
@@ -102727,6 +103842,8 @@ var ClaudeCodeAdapter = class {
    * Stop the adapter — clear relay reference, drain in-flight queue entries, and mark as disconnected.
    */
   async stop() {
+    this.approvalUnsub?.();
+    this.approvalUnsub = null;
     this.relay = null;
     this.agentQueue.clear();
     this.status = { ...this.status, state: "disconnected" };
@@ -103637,21 +104754,27 @@ function defaultAdapterStatus() {
 }
 async function createAdapter(config, deps, configPath, onPluginManifest) {
   switch (config.type) {
-    case "telegram":
-      return new TelegramAdapter(
+    case "telegram": {
+      const adapter = new TelegramAdapter(
         config.id,
         config.config
       );
+      adapter.setLogger(createTaggedLogger(`telegram:${config.id}`));
+      return adapter;
+    }
     case "webhook":
       return new WebhookAdapter(
         config.id,
         config.config
       );
-    case "slack":
-      return new SlackAdapter(
+    case "slack": {
+      const adapter = new SlackAdapter(
         config.id,
         config.config
       );
+      adapter.setLogger(createTaggedLogger(`slack:${config.id}`));
+      return adapter;
+    }
     case "claude-code":
       return new ClaudeCodeAdapter(
         config.id,
@@ -103693,6 +104816,8 @@ async function testAdapterConnection(adapter) {
     const noopRelay = {
       publish: async () => ({ messageId: "", deliveredTo: 0 }),
       onSignal: () => () => {
+      },
+      subscribe: () => () => {
       }
     };
     let fallbackTimer;