@openacp/cli 0.2.16 → 0.2.18

package/dist/{chunk-TKOYKVXH.js → chunk-HTXK4NLG.js}

@@ -1,7 +1,7 @@
 import {
   createChildLogger,
   createSessionLogger
-} from "./chunk-HTUZOMIT.js";
+} from "./chunk-ZATQZUJT.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -55,7 +55,14 @@ import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 var log = createChildLogger({ module: "agent-instance" });
 function resolveAgentCommand(cmd) {
   const packageDirs = [
-    path.resolve(process.cwd(), "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+    path.resolve(
+      process.cwd(),
+      "node_modules",
+      "@zed-industries",
+      cmd,
+      "dist",
+      "index.js"
+    ),
     path.resolve(process.cwd(), "node_modules", cmd, "dist", "index.js")
   ];
   for (const jsPath of packageDirs) {
@@ -103,19 +110,33 @@ var AgentInstance = class _AgentInstance {
   constructor(agentName) {
     this.agentName = agentName;
   }
-  static async spawn(agentDef, workingDirectory) {
+  static async spawnSubprocess(agentDef, workingDirectory) {
     const instance = new _AgentInstance(agentDef.name);
     const resolved = resolveAgentCommand(agentDef.command);
-    log.debug({ agentName: agentDef.name, command: resolved.command, args: resolved.args }, "Spawning agent");
-    const spawnStart = Date.now();
-    instance.child = spawn(resolved.command, [...resolved.args, ...agentDef.args], {
-      stdio: ["pipe", "pipe", "pipe"],
-      cwd: workingDirectory,
-      env: { ...process.env, ...agentDef.env }
-    });
+    log.debug(
+      {
+        agentName: agentDef.name,
+        command: resolved.command,
+        args: resolved.args
+      },
+      "Resolved agent command"
+    );
+    instance.child = spawn(
+      resolved.command,
+      [...resolved.args, ...agentDef.args],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: workingDirectory,
+        env: { ...process.env, ...agentDef.env }
+      }
+    );
     await new Promise((resolve, reject) => {
       instance.child.on("error", (err) => {
-        reject(new Error(`Failed to spawn agent "${agentDef.name}": ${err.message}. Is "${agentDef.command}" installed?`));
+        reject(
+          new Error(
+            `Failed to spawn agent "${agentDef.name}": ${err.message}. Is "${agentDef.command}" installed?`
+          )
+        );
       });
       instance.child.on("spawn", () => resolve());
     });
@@ -125,14 +146,20 @@ var AgentInstance = class _AgentInstance {
     });
     const stdinLogger = new Transform({
       transform(chunk, _enc, cb) {
-        log.debug({ direction: "send", raw: chunk.toString().trimEnd() }, "ACP raw");
+        log.debug(
+          { direction: "send", raw: chunk.toString().trimEnd() },
+          "ACP raw"
+        );
         cb(null, chunk);
       }
     });
     stdinLogger.pipe(instance.child.stdin);
     const stdoutLogger = new Transform({
       transform(chunk, _enc, cb) {
-        log.debug({ direction: "recv", raw: chunk.toString().trimEnd() }, "ACP raw");
+        log.debug(
+          { direction: "recv", raw: chunk.toString().trimEnd() },
+          "ACP raw"
+        );
         cb(null, chunk);
       }
     });
@@ -151,26 +178,82 @@ var AgentInstance = class _AgentInstance {
         terminal: true
       }
     });
-    const response = await instance.connection.newSession({
-      cwd: workingDirectory,
-      mcpServers: []
-    });
-    instance.sessionId = response.sessionId;
-    instance.child.on("exit", (code, signal) => {
-      log.info({ sessionId: instance.sessionId, exitCode: code, signal }, "Agent process exited");
+    return instance;
+  }
+  setupCrashDetection() {
+    this.child.on("exit", (code, signal) => {
+      log.info(
+        { sessionId: this.sessionId, exitCode: code, signal },
+        "Agent process exited"
+      );
       if (code !== 0 && code !== null) {
-        const stderr = instance.stderrCapture.getLastLines();
-        instance.onSessionUpdate({
+        const stderr = this.stderrCapture.getLastLines();
+        this.onSessionUpdate({
           type: "error",
           message: `Agent crashed (exit code ${code})
 ${stderr}`
         });
       }
     });
-    instance.connection.closed.then(() => {
-      log.debug({ sessionId: instance.sessionId }, "ACP connection closed");
+    this.connection.closed.then(() => {
+      log.debug({ sessionId: this.sessionId }, "ACP connection closed");
     });
-    log.info({ sessionId: response.sessionId, durationMs: Date.now() - spawnStart }, "Agent spawn complete");
+  }
+  static async spawn(agentDef, workingDirectory) {
+    log.debug(
+      { agentName: agentDef.name, command: agentDef.command },
+      "Spawning agent"
+    );
+    const spawnStart = Date.now();
+    const instance = await _AgentInstance.spawnSubprocess(
+      agentDef,
+      workingDirectory
+    );
+    const response = await instance.connection.newSession({
+      cwd: workingDirectory,
+      mcpServers: []
+    });
+    instance.sessionId = response.sessionId;
+    instance.setupCrashDetection();
+    log.info(
+      { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
+      "Agent spawn complete"
+    );
+    return instance;
+  }
+  static async resume(agentDef, workingDirectory, agentSessionId) {
+    log.debug({ agentName: agentDef.name, agentSessionId }, "Resuming agent");
+    const spawnStart = Date.now();
+    const instance = await _AgentInstance.spawnSubprocess(
+      agentDef,
+      workingDirectory
+    );
+    try {
+      const response = await instance.connection.unstable_resumeSession({
+        sessionId: agentSessionId,
+        cwd: workingDirectory
+      });
+      instance.sessionId = response.sessionId;
+      log.info(
+        { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
+        "Agent resume complete"
+      );
+    } catch (err) {
+      log.warn(
+        { err, agentSessionId },
+        "Resume failed, falling back to new session"
+      );
+      const response = await instance.connection.newSession({
+        cwd: workingDirectory,
+        mcpServers: []
+      });
+      instance.sessionId = response.sessionId;
+      log.info(
+        { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
+        "Agent fallback spawn complete"
+      );
+    }
+    instance.setupCrashDetection();
     return instance;
   }
   // createClient — implemented in Task 6b
@@ -223,7 +306,10 @@ ${stderr}`
             };
             break;
           case "available_commands_update":
-            event = { type: "commands_update", commands: update.availableCommands };
+            event = {
+              type: "commands_update",
+              commands: update.availableCommands
+            };
             break;
           default:
             return;
@@ -286,8 +372,14 @@ ${stderr}`
             state.output = state.output.slice(excess);
           }
         };
-        childProcess.stdout?.on("data", (chunk) => appendOutput(chunk.toString()));
-        childProcess.stderr?.on("data", (chunk) => appendOutput(chunk.toString()));
+        childProcess.stdout?.on(
+          "data",
+          (chunk) => appendOutput(chunk.toString())
+        );
+        childProcess.stderr?.on(
+          "data",
+          (chunk) => appendOutput(chunk.toString())
+        );
         childProcess.on("exit", (code, signal) => {
           state.exitStatus = { exitCode: code, signal };
         });
@@ -301,7 +393,10 @@ ${stderr}`
         return {
           output: state.output,
           truncated: false,
-          exitStatus: state.exitStatus ? { exitCode: state.exitStatus.exitCode, signal: state.exitStatus.signal } : void 0
+          exitStatus: state.exitStatus ? {
+            exitCode: state.exitStatus.exitCode,
+            signal: state.exitStatus.signal
+          } : void 0
         };
       },
       async waitForTerminalExit(params) {
@@ -310,7 +405,10 @@ ${stderr}`
           throw new Error(`Terminal not found: ${params.terminalId}`);
         }
         if (state.exitStatus !== null) {
-          return { exitCode: state.exitStatus.exitCode, signal: state.exitStatus.signal };
+          return {
+            exitCode: state.exitStatus.exitCode,
+            signal: state.exitStatus.signal
+          };
         }
         return new Promise((resolve) => {
           state.process.on("exit", (code, signal) => {
@@ -381,6 +479,11 @@ var AgentManager = class {
     if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
     return AgentInstance.spawn(agentDef, workingDirectory);
   }
+  async resume(agentName, workingDirectory, agentSessionId) {
+    const agentDef = this.getAgent(agentName);
+    if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
+    return AgentInstance.resume(agentDef, workingDirectory, agentSessionId);
+  }
 };
 
 // src/core/session.ts
@@ -393,6 +496,7 @@ var Session = class {
   agentName;
   workingDirectory;
   agentInstance;
+  agentSessionId = "";
   status = "initializing";
   name;
   promptQueue = [];
@@ -426,7 +530,10 @@ var Session = class {
     this.log.debug("Prompt execution started");
     try {
       await this.agentInstance.prompt(text);
-      this.log.info({ durationMs: Date.now() - promptStart }, "Prompt execution completed");
+      this.log.info(
+        { durationMs: Date.now() - promptStart },
+        "Prompt execution completed"
+      );
       if (!this.name) {
         await this.autoName();
       }
@@ -499,10 +606,34 @@ var Session = class {
 // src/core/session-manager.ts
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
+  store;
+  constructor(store = null) {
+    this.store = store;
+  }
   async createSession(channelId, agentName, workingDirectory, agentManager) {
     const agentInstance = await agentManager.spawn(agentName, workingDirectory);
-    const session = new Session({ channelId, agentName, workingDirectory, agentInstance });
+    const session = new Session({
+      channelId,
+      agentName,
+      workingDirectory,
+      agentInstance
+    });
     this.sessions.set(session.id, session);
+    session.agentSessionId = session.agentInstance.sessionId;
+    if (this.store) {
+      await this.store.save({
+        sessionId: session.id,
+        agentSessionId: session.agentInstance.sessionId,
+        agentName: session.agentName,
+        workingDir: session.workingDirectory,
+        channelId,
+        status: session.status,
+        createdAt: session.createdAt.toISOString(),
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: session.name,
+        platform: {}
+      });
+    }
     return session;
   }
   getSession(sessionId) {
@@ -516,9 +647,44 @@ var SessionManager = class {
     }
     return void 0;
   }
+  registerSession(session) {
+    this.sessions.set(session.id, session);
+  }
+  async updateSessionPlatform(sessionId, platform) {
+    if (!this.store) return;
+    const record = this.store.get(sessionId);
+    if (record) {
+      await this.store.save({ ...record, platform });
+    }
+  }
+  async updateSessionActivity(sessionId) {
+    if (!this.store) return;
+    const record = this.store.get(sessionId);
+    if (record) {
+      await this.store.save({
+        ...record,
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  async updateSessionStatus(sessionId, status) {
+    if (!this.store) return;
+    const record = this.store.get(sessionId);
+    if (record) {
+      await this.store.save({ ...record, status });
+    }
+  }
   async cancelSession(sessionId) {
     const session = this.sessions.get(sessionId);
-    if (session) await session.cancel();
+    if (session) {
+      await session.cancel();
+      if (this.store) {
+        const record = this.store.get(sessionId);
+        if (record) {
+          await this.store.save({ ...record, status: "cancelled" });
+        }
+      }
+    }
   }
   listSessions(channelId) {
     const all = Array.from(this.sessions.values());
@@ -526,6 +692,14 @@ var SessionManager = class {
     return all;
   }
   async destroyAll() {
+    if (this.store) {
+      for (const session of this.sessions.values()) {
+        const record = this.store.get(session.id);
+        if (record) {
+          await this.store.save({ ...record, status: "finished" });
+        }
+      }
+    }
     for (const session of this.sessions.values()) {
       await session.destroy();
     }
@@ -552,18 +726,218 @@ var NotificationManager = class {
 };
 
 // src/core/core.ts
-var log2 = createChildLogger({ module: "core" });
+import path3 from "path";
+import os from "os";
+
+// src/core/session-store.ts
+import fs2 from "fs";
+import path2 from "path";
+var log2 = createChildLogger({ module: "session-store" });
+var DEBOUNCE_MS = 2e3;
+var JsonFileSessionStore = class {
+  records = /* @__PURE__ */ new Map();
+  filePath;
+  ttlDays;
+  debounceTimer = null;
+  cleanupInterval = null;
+  flushHandler = null;
+  constructor(filePath, ttlDays) {
+    this.filePath = filePath;
+    this.ttlDays = ttlDays;
+    this.load();
+    this.cleanup();
+    this.cleanupInterval = setInterval(
+      () => this.cleanup(),
+      24 * 60 * 60 * 1e3
+    );
+    this.flushHandler = () => this.flushSync();
+    process.on("SIGTERM", this.flushHandler);
+    process.on("SIGINT", this.flushHandler);
+    process.on("exit", this.flushHandler);
+  }
+  async save(record) {
+    this.records.set(record.sessionId, { ...record });
+    this.scheduleDiskWrite();
+  }
+  get(sessionId) {
+    return this.records.get(sessionId);
+  }
+  findByPlatform(channelId, predicate) {
+    for (const record of this.records.values()) {
+      if (record.channelId === channelId && predicate(record.platform)) {
+        return record;
+      }
+    }
+    return void 0;
+  }
+  list(channelId) {
+    const all = [...this.records.values()];
+    if (channelId) return all.filter((r) => r.channelId === channelId);
+    return all;
+  }
+  async remove(sessionId) {
+    this.records.delete(sessionId);
+    this.scheduleDiskWrite();
+  }
+  flushSync() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    const data = {
+      version: 1,
+      sessions: Object.fromEntries(this.records)
+    };
+    const dir = path2.dirname(this.filePath);
+    if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+  }
+  destroy() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    if (this.cleanupInterval) clearInterval(this.cleanupInterval);
+    if (this.flushHandler) {
+      process.removeListener("SIGTERM", this.flushHandler);
+      process.removeListener("SIGINT", this.flushHandler);
+      process.removeListener("exit", this.flushHandler);
+      this.flushHandler = null;
+    }
+  }
+  load() {
+    if (!fs2.existsSync(this.filePath)) return;
+    try {
+      const raw = JSON.parse(
+        fs2.readFileSync(this.filePath, "utf-8")
+      );
+      if (raw.version !== 1) {
+        log2.warn(
+          { version: raw.version },
+          "Unknown session store version, skipping load"
+        );
+        return;
+      }
+      for (const [id, record] of Object.entries(raw.sessions)) {
+        this.records.set(id, record);
+      }
+      log2.info({ count: this.records.size }, "Loaded session records");
+    } catch (err) {
+      log2.error({ err }, "Failed to load session store");
+    }
+  }
+  cleanup() {
+    const cutoff = Date.now() - this.ttlDays * 24 * 60 * 60 * 1e3;
+    let removed = 0;
+    for (const [id, record] of this.records) {
+      if (record.status === "active" || record.status === "initializing")
+        continue;
+      const lastActive = new Date(record.lastActiveAt).getTime();
+      if (lastActive < cutoff) {
+        this.records.delete(id);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      log2.info({ removed }, "Cleaned up expired session records");
+      this.scheduleDiskWrite();
+    }
+  }
+  scheduleDiskWrite() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.flushSync();
+    }, DEBOUNCE_MS);
+  }
+};
+
+// src/tunnel/extract-file-info.ts
+function extractFileInfo(name, kind, content) {
+  if (!content) return null;
+  if (kind && !["read", "edit", "write"].includes(kind)) return null;
+  const 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 OpenACPCore = class {
   configManager;
   agentManager;
   sessionManager;
   notificationManager;
   adapters = /* @__PURE__ */ new Map();
+  tunnelService;
+  sessionStore = null;
+  resumeLocks = /* @__PURE__ */ new Map();
   constructor(configManager) {
     this.configManager = configManager;
     const config = configManager.get();
     this.agentManager = new AgentManager(config);
-    this.sessionManager = new SessionManager();
+    const storePath = path3.join(os.homedir(), ".openacp", "sessions.json");
+    this.sessionStore = new JsonFileSessionStore(
+      storePath,
+      config.sessionStore.ttlDays
+    );
+    this.sessionManager = new SessionManager(this.sessionStore);
     this.notificationManager = new NotificationManager(this.adapters);
   }
   registerAdapter(name, adapter) {
@@ -591,16 +965,33 @@ var OpenACPCore = class {
   // --- Message Routing ---
   async handleMessage(message) {
     const config = this.configManager.get();
-    log2.debug({ channelId: message.channelId, threadId: message.threadId, userId: message.userId }, "Incoming message");
+    log3.debug(
+      {
+        channelId: message.channelId,
+        threadId: message.threadId,
+        userId: message.userId
+      },
+      "Incoming message"
+    );
     if (config.security.allowedUserIds.length > 0) {
       if (!config.security.allowedUserIds.includes(message.userId)) {
-        log2.warn({ userId: message.userId }, "Rejected message from unauthorized user");
+        log3.warn(
+          { userId: message.userId },
+          "Rejected message from unauthorized user"
+        );
         return;
       }
     }
     const activeSessions = this.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
     if (activeSessions.length >= config.security.maxConcurrentSessions) {
-      log2.warn({ userId: message.userId, currentCount: activeSessions.length, max: config.security.maxConcurrentSessions }, "Session limit reached");
+      log3.warn(
+        {
+          userId: message.userId,
+          currentCount: activeSessions.length,
+          max: config.security.maxConcurrentSessions
+        },
+        "Session limit reached"
+      );
       const adapter = this.adapters.get(message.channelId);
       if (adapter) {
         await adapter.sendMessage("system", {
@@ -610,14 +1001,21 @@ var OpenACPCore = class {
       }
       return;
     }
-    const session = this.sessionManager.getSessionByThread(message.channelId, message.threadId);
+    let session = this.sessionManager.getSessionByThread(
+      message.channelId,
+      message.threadId
+    );
+    if (!session) {
+      session = await this.lazyResume(message) ?? void 0;
+    }
     if (!session) return;
+    this.sessionManager.updateSessionActivity(session.id);
     await session.enqueuePrompt(message.text);
   }
   async handleNewSession(channelId, agentName, workspacePath) {
     const config = this.configManager.get();
     const resolvedAgent = agentName || config.defaultAgent;
-    log2.info({ channelId, agentName: resolvedAgent }, "New session request");
+    log3.info({ channelId, agentName: resolvedAgent }, "New session request");
     const resolvedWorkspace = this.configManager.resolveWorkspace(
       workspacePath || config.agents[resolvedAgent]?.workingDirectory
     );
@@ -634,7 +1032,10 @@ var OpenACPCore = class {
     return session;
   }
   async handleNewChat(channelId, currentThreadId) {
-    const currentSession = this.sessionManager.getSessionByThread(channelId, currentThreadId);
+    const currentSession = this.sessionManager.getSessionByThread(
+      channelId,
+      currentThreadId
+    );
     if (!currentSession) return null;
     return this.handleNewSession(
       channelId,
@@ -642,25 +1043,148 @@ var OpenACPCore = class {
       currentSession.workingDirectory
     );
   }
+  // --- Lazy Resume ---
+  async lazyResume(message) {
+    const store = this.sessionStore;
+    if (!store) return null;
+    const lockKey = `${message.channelId}:${message.threadId}`;
+    const existing = this.resumeLocks.get(lockKey);
+    if (existing) return existing;
+    const record = store.findByPlatform(
+      message.channelId,
+      (p) => String(p.topicId) === message.threadId
+    );
+    if (!record) return null;
+    if (record.status === "cancelled" || record.status === "error") return null;
+    const resumePromise = (async () => {
+      try {
+        const agentInstance = await this.agentManager.resume(
+          record.agentName,
+          record.workingDir,
+          record.agentSessionId
+        );
+        const session = new Session({
+          id: record.sessionId,
+          channelId: record.channelId,
+          agentName: record.agentName,
+          workingDirectory: record.workingDir,
+          agentInstance
+        });
+        session.threadId = message.threadId;
+        session.agentSessionId = agentInstance.sessionId;
+        session.status = "active";
+        session.name = record.name;
+        this.sessionManager.registerSession(session);
+        const adapter = this.adapters.get(message.channelId);
+        if (adapter) {
+          this.wireSessionEvents(session, adapter);
+        }
+        await store.save({
+          ...record,
+          agentSessionId: agentInstance.sessionId,
+          status: "active",
+          lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        log3.info(
+          { sessionId: session.id, threadId: message.threadId },
+          "Lazy resume successful"
+        );
+        return session;
+      } catch (err) {
+        log3.error({ err, record }, "Lazy resume failed");
+        return null;
+      } finally {
+        this.resumeLocks.delete(lockKey);
+      }
+    })();
+    this.resumeLocks.set(lockKey, resumePromise);
+    return resumePromise;
+  }
   // --- Event Wiring ---
-  toOutgoingMessage(event) {
+  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":
-        return { type: "tool_call", text: event.name, metadata: { id: event.id, kind: event.kind, status: event.status, content: event.content, locations: event.locations } };
-      case "tool_update":
-        return { type: "tool_update", text: "", metadata: { id: event.id, status: event.status, content: event.content } };
+      case "tool_call": {
+        const metadata = {
+          id: event.id,
+          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,
+          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 } };
+        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);
+    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;
+    }
+  }
   // Public — adapters call this for assistant session wiring
   wireSessionEvents(session, adapter) {
     session.adapter = adapter;
@@ -672,12 +1196,19 @@ var OpenACPCore = class {
         case "tool_update":
         case "plan":
         case "usage":
-          adapter.sendMessage(session.id, this.toOutgoingMessage(event));
+          adapter.sendMessage(
+            session.id,
+            this.toOutgoingMessage(event, session)
+          );
           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, {
+            type: "session_end",
+            text: `Done (${event.reason})`
+          });
           this.notificationManager.notify(session.channelId, {
             sessionId: session.id,
             sessionName: session.name,
@@ -686,8 +1217,12 @@ var OpenACPCore = class {
           });
           break;
         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, {
+            type: "error",
+            text: event.message
+          });
           this.notificationManager.notify(session.channelId, {
             sessionId: session.id,
             sessionName: session.name,
@@ -696,7 +1231,7 @@ var OpenACPCore = class {
           });
           break;
         case "commands_update":
-          log2.debug({ commands: event.commands }, "Commands available");
+          log3.debug({ commands: event.commands }, "Commands available");
           adapter.sendSkillCommands(session.id, event.commands);
           break;
       }
@@ -808,6 +1343,7 @@ function formatToolCall(tool) {
     text += `
 <pre>${escapeHtml(truncateContent(details))}</pre>`;
   }
+  text += formatViewerLinks(tool.viewerLinks);
   return text;
 }
 function formatToolUpdate(update) {
@@ -820,6 +1356,16 @@ function formatToolUpdate(update) {
     text += `
 <pre>${escapeHtml(truncateContent(details))}</pre>`;
   }
+  text += formatViewerLinks(update.viewerLinks);
+  return text;
+}
+function formatViewerLinks(links) {
+  if (!links) return "";
+  let text = "";
+  if (links.file) text += `
+\u{1F4C4} <a href="${escapeHtml(links.file)}">View file</a>`;
+  if (links.diff) text += `
+\u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff</a>`;
   return text;
 }
 function formatPlan(plan) {
@@ -999,7 +1545,7 @@ function buildDeepLink(chatId, messageId) {
 // src/adapters/telegram/commands.ts
 import { InlineKeyboard } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log4 = createChildLogger({ module: "telegram-commands" });
+var log5 = createChildLogger({ module: "telegram-commands" });
 function setupCommands(bot, core, chatId) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId));
   bot.command("new_chat", (ctx) => handleNewChat(ctx, core, chatId));
@@ -1054,7 +1600,7 @@ async function handleNew(ctx, core, chatId) {
   const args = matchStr.split(" ").filter(Boolean);
   const agentName = args[0];
   const workspace = args[1];
-  log4.info({ userId: ctx.from?.id, agentName }, "New session command");
+  log5.info({ userId: ctx.from?.id, agentName }, "New session command");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
@@ -1069,6 +1615,9 @@ async function handleNew(ctx, core, chatId) {
       workspace
     );
     session.threadId = String(threadId);
+    await core.sessionManager.updateSessionPlatform(session.id, {
+      topicId: threadId
+    });
     const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
     try {
       await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
@@ -1084,7 +1633,7 @@ async function handleNew(ctx, core, chatId) {
         parse_mode: "HTML"
       }
     );
-    session.warmup().catch((err) => log4.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log5.error({ err }, "Warm-up error"));
   } catch (err) {
     if (threadId) {
       try {
@@ -1124,6 +1673,9 @@ async function handleNewChat(ctx, core, chatId) {
       parse_mode: "HTML"
     });
     session.threadId = String(newThreadId);
+    await core.sessionManager.updateSessionPlatform(session.id, {
+      topicId: newThreadId
+    });
     await ctx.api.sendMessage(
       chatId,
       `\u2705 New chat (same agent &amp; workspace)
@@ -1134,7 +1686,7 @@ async function handleNewChat(ctx, core, chatId) {
         parse_mode: "HTML"
       }
     );
-    session.warmup().catch((err) => log4.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log5.error({ err }, "Warm-up error"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
@@ -1148,7 +1700,7 @@ async function handleCancel(ctx, core) {
     String(threadId)
   );
   if (session) {
-    log4.info({ sessionId: session.id }, "Cancel session command");
+    log5.info({ sessionId: session.id }, "Cancel session command");
     await session.cancel();
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
@@ -1269,7 +1821,7 @@ var STATIC_COMMANDS = [
 // src/adapters/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 import { nanoid as nanoid3 } from "nanoid";
-var log5 = createChildLogger({ module: "telegram-permissions" });
+var log6 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -1329,7 +1881,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log5.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      log6.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.pendingPermission?.requestId === pending.requestId) {
         session.pendingPermission.resolve(optionId);
         session.pendingPermission = void 0;
@@ -1396,7 +1948,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/adapter.ts
-var log6 = createChildLogger({ module: "telegram" });
+var log7 = createChildLogger({ module: "telegram" });
 var TelegramAdapter = class extends ChannelAdapter {
   bot;
   telegramConfig;
@@ -1414,10 +1966,10 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.telegramConfig = config;
   }
   async start() {
-    this.bot = new Bot(this.telegramConfig.botToken);
+    this.bot = new Bot(this.telegramConfig.botToken, { client: { fetch } });
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log6.error({ err: rootCause }, "Telegram bot error");
+      log7.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use((prev, method, payload, signal) => {
       if (method === "getUpdates") {
@@ -1470,7 +2022,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log6.info(
+      onStart: () => log7.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -1482,7 +2034,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         this.assistantTopicId
       );
     } catch (err) {
-      log6.error({ err }, "Failed to spawn assistant");
+      log7.error({ err }, "Failed to spawn assistant");
     }
     try {
       const config = this.core.configManager.get();
@@ -1503,7 +2055,7 @@ Workspace: <code>${workspace}</code>
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log6.warn({ err }, "Failed to send welcome message");
+      log7.warn({ err }, "Failed to send welcome message");
     }
   }
   async stop() {
@@ -1511,7 +2063,7 @@ Workspace: <code>${workspace}</code>
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log6.info("Telegram bot stopped");
+    log7.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -1529,7 +2081,7 @@ Workspace: <code>${workspace}</code>
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log6.error({ err }, "Assistant error")
+          (err) => log7.error({ err }, "Assistant error")
         );
         return;
       }
@@ -1540,7 +2092,7 @@ Workspace: <code>${workspace}</code>
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log6.error({ err }, "handleMessage error"));
+      }).catch((err) => log7.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
@@ -1585,7 +2137,8 @@ Workspace: <code>${workspace}</code>
         this.toolCallMessages.get(sessionId).set(meta.id, {
           msgId: msg.message_id,
           name: meta.name,
-          kind: meta.kind
+          kind: meta.kind,
+          viewerLinks: meta.viewerLinks
         });
         break;
       }
@@ -1593,10 +2146,13 @@ Workspace: <code>${workspace}</code>
         const meta = content.metadata;
         const toolState = this.toolCallMessages.get(sessionId)?.get(meta.id);
         if (toolState) {
+          const viewerLinks = meta.viewerLinks || toolState.viewerLinks;
+          if (meta.viewerLinks) toolState.viewerLinks = meta.viewerLinks;
           const merged = {
             ...meta,
             name: meta.name || toolState.name,
-            kind: meta.kind || toolState.kind
+            kind: meta.kind || toolState.kind,
+            viewerLinks
           };
           try {
             await this.bot.api.editMessageText(
@@ -1614,7 +2170,9 @@ Workspace: <code>${workspace}</code>
         await this.finalizeDraft(sessionId);
         await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
-          formatPlan(content.metadata),
+          formatPlan(
+            content.metadata
+          ),
           {
             message_thread_id: threadId,
             parse_mode: "HTML",
@@ -1626,7 +2184,9 @@ Workspace: <code>${workspace}</code>
       case "usage": {
         await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
-          formatUsage(content.metadata),
+          formatUsage(
+            content.metadata
+          ),
           {
             message_thread_id: threadId,
             parse_mode: "HTML",
@@ -1667,7 +2227,7 @@ Workspace: <code>${workspace}</code>
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log6.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log7.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(
       sessionId
     );
@@ -1675,7 +2235,7 @@ Workspace: <code>${workspace}</code>
     await this.permissionHandler.sendPermissionRequest(session, request);
   }
   async sendNotification(notification) {
-    log6.info(
+    log7.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -1701,7 +2261,7 @@ Workspace: <code>${workspace}</code>
     });
   }
   async createSessionThread(sessionId, name) {
-    log6.info({ sessionId, name }, "Session topic created");
+    log7.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -1719,7 +2279,9 @@ Workspace: <code>${workspace}</code>
     );
   }
   async sendSkillCommands(sessionId, commands) {
-    const session = this.core.sessionManager.getSession(sessionId);
+    const session = this.core.sessionManager.getSession(
+      sessionId
+    );
     if (!session) return;
     const threadId = Number(session.threadId);
     if (!threadId) return;
@@ -1755,11 +2317,15 @@ Workspace: <code>${workspace}</code>
         }
       );
       this.skillMessages.set(sessionId, msg.message_id);
-      await this.bot.api.pinChatMessage(this.telegramConfig.chatId, msg.message_id, {
-        disable_notification: true
-      });
+      await this.bot.api.pinChatMessage(
+        this.telegramConfig.chatId,
+        msg.message_id,
+        {
+          disable_notification: true
+        }
+      );
     } catch (err) {
-      log6.error({ err, sessionId }, "Failed to send skill commands");
+      log7.error({ err, sessionId }, "Failed to send skill commands");
     }
     await this.updateCommandAutocomplete(session.agentName, commands);
   }
@@ -1790,9 +2356,15 @@ Workspace: <code>${workspace}</code>
       await this.bot.api.setMyCommands(all, {
         scope: { type: "chat", chat_id: this.telegramConfig.chatId }
       });
-      log6.info({ count: all.length, skills: validSkills.length }, "Updated command autocomplete");
+      log7.info(
+        { count: all.length, skills: validSkills.length },
+        "Updated command autocomplete"
+      );
     } catch (err) {
-      log6.error({ err, commands: all }, "Failed to update command autocomplete");
+      log7.error(
+        { err, commands: all },
+        "Failed to update command autocomplete"
+      );
     }
   }
   async finalizeDraft(sessionId) {
@@ -1817,4 +2389,4 @@ export {
   ChannelAdapter,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-TKOYKVXH.js.map
+//# sourceMappingURL=chunk-HTXK4NLG.js.map