@coinseeker/opencode-telegram-plugin 1.0.9 → 1.0.11

package/README.md

@@ -15,11 +15,11 @@ Configure the npm package in `~/.config/opencode/opencode.json`:
 
 ```json
 {
-  "plugin": ["@coinseeker/opencode-telegram-plugin@1.0.9"]
+  "plugin": ["@coinseeker/opencode-telegram-plugin@1.0.11"]
 }
 ```
 
-Current stable version: `@coinseeker/opencode-telegram-plugin@1.0.9`.
+Current stable version: `@coinseeker/opencode-telegram-plugin@1.0.11`.
 
 Restart OpenCode after editing the config. OpenCode resolves npm package plugins on startup.
 

package/dist/telegram-remote.js

@@ -4,9 +4,9 @@
  */
 
 // src/telegram-remote.ts
-import { createHash as createHash4 } from "crypto";
-import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname4, join as join6 } from "path";
+import { createHash as createHash5 } from "crypto";
+import { tmpdir as tmpdir5 } from "os";
+import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath } from "url";
 
 // src/bot.ts
@@ -45,6 +45,7 @@ function createTelegramBot(opts) {
   let activeChatId = opts.initialChatId;
   let questionDispatcher;
   let permissionDispatcher;
+  let startWorkDispatcher;
   if (polling) {
     bot.use(async (ctx, next) => {
       const userId = ctx.from?.id;
@@ -97,6 +98,13 @@ This chat is now active for OpenCode notifications.`
       if (!permissionDispatcher || messageId === void 0) return;
       await permissionDispatcher.handleCallbackQuery(data, messageId);
     });
+    bot.callbackQuery(/^sw:([^:]+)$/, async (ctx) => {
+      await ctx.answerCallbackQuery();
+      const data = ctx.callbackQuery.data;
+      const messageId = ctx.callbackQuery.message?.message_id;
+      if (!startWorkDispatcher || messageId === void 0) return;
+      await startWorkDispatcher.handleCallbackQuery(data, messageId);
+    });
     bot.on("message:text", async (ctx) => {
       const replyToMessageId = ctx.message.reply_to_message?.message_id;
       const chatId = ctx.chat.id;
@@ -190,6 +198,9 @@ This chat is now active for OpenCode notifications.`
     },
     setPermissionDispatcher(dispatcher) {
       permissionDispatcher = dispatcher;
+    },
+    setStartWorkDispatcher(dispatcher) {
+      startWorkDispatcher = dispatcher;
     }
   };
 }
@@ -471,6 +482,7 @@ async function handleNormalizedPermission(permission, ctx) {
     const pending = {
       requestID: permission.requestID,
       sessionID: permission.sessionID,
+      serverUrl: ctx.serverUrl.href,
       title: permission.title,
       permission: permission.permission,
       patterns: permission.patterns,
@@ -514,7 +526,13 @@ function createPermissionDispatcher(ctx) {
         return;
       }
       try {
-        await ctx.replyToPermission(pending.requestID, pending.sessionID, reply, pending.endpoint);
+        await ctx.replyToPermission(
+          pending.requestID,
+          pending.sessionID,
+          reply,
+          pending.endpoint,
+          pending.serverUrl
+        );
         await ctx.bot.editMessageRemoveKeyboard(messageId, `\u2705 Permission ${replyLabel(reply)}
 
 ${pending.permission}: ${pending.title}`);
@@ -719,7 +737,7 @@ async function completeIfReady(ctx, pending, shortHash) {
   const answers = pending.answersInProgress.map((answer) => answer ?? []);
   const messageId = pending.telegramMessageIds[0];
   try {
-    await ctx.replyToQuestion(pending.requestID, answers);
+    await ctx.replyToQuestion(pending.requestID, answers, pending.serverUrl);
     await ctx.bot.editMessageRemoveKeyboard(
       messageId,
       `\u2705 Answered:
@@ -759,6 +777,7 @@ async function handleQuestionAsked(event, ctx) {
   const pending = {
     requestID: request.id,
     sessionID: request.sessionID,
+    serverUrl: ctx.serverUrl.href,
     questions: request.questions,
     sentAt,
     expiresAt: sentAt + QUESTION_EXPIRY_MS,
@@ -942,6 +961,163 @@ async function handleSessionError(event, ctx) {
   ctx.logger.info("session abort recorded", { sessionId: event.properties.sessionID ?? "global" });
 }
 
+// src/lib/pending-start-work.ts
+import { createHash as createHash4 } from "crypto";
+import { mkdir as mkdir4, readdir as readdir4, readFile as readFile3, rename as rename3, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+function hasCode4(err, code) {
+  return "code" in err && err.code === code;
+}
+function pendingFilePath3(dir, shortHash) {
+  return join4(dir, `${shortHash}.json`);
+}
+function parsePending3(text) {
+  const parsed = JSON.parse(text);
+  if (typeof parsed.sessionID !== "string")
+    throw new Error("Invalid pending start-work: sessionID");
+  if (parsed.serverUrl !== void 0 && typeof parsed.serverUrl !== "string")
+    throw new Error("Invalid pending start-work: serverUrl");
+  if (parsed.title !== void 0 && typeof parsed.title !== "string")
+    throw new Error("Invalid pending start-work: title");
+  if (typeof parsed.sentAt !== "number") throw new Error("Invalid pending start-work: sentAt");
+  if (typeof parsed.expiresAt !== "number")
+    throw new Error("Invalid pending start-work: expiresAt");
+  if (typeof parsed.telegramMessageId !== "number")
+    throw new Error("Invalid pending start-work: telegramMessageId");
+  return parsed;
+}
+async function listPendingFiles3(dir) {
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name);
+  } catch (err) {
+    if (err instanceof Error && hasCode4(err, "ENOENT")) return [];
+    throw err;
+  }
+}
+function shortHashFromFileName3(fileName) {
+  return fileName.slice(0, -".json".length);
+}
+function createPendingStartWorkStore(opts) {
+  const dir = opts.baseDir ?? join4(tmpdir3(), `opencoder-telegram-pending-start-work-${opts.tokenHash}`);
+  return {
+    dir,
+    async savePending(shortHash, data) {
+      const filePath = pendingFilePath3(dir, shortHash);
+      await mkdir4(dirname3(filePath), { recursive: true });
+      const tmpPath = `${filePath}.tmp.${process.pid}`;
+      await writeFile3(tmpPath, JSON.stringify(data, null, 2), "utf8");
+      await rename3(tmpPath, filePath);
+    },
+    async loadPending(shortHash) {
+      try {
+        return parsePending3(await readFile3(pendingFilePath3(dir, shortHash), "utf8"));
+      } catch (err) {
+        if (err instanceof Error && hasCode4(err, "ENOENT")) return void 0;
+        throw err;
+      }
+    },
+    async deletePending(shortHash) {
+      try {
+        await unlink4(pendingFilePath3(dir, shortHash));
+      } catch (err) {
+        if (!(err instanceof Error) || !hasCode4(err, "ENOENT")) throw err;
+      }
+    },
+    async sweepExpired() {
+      const expired = [];
+      for (const fileName of await listPendingFiles3(dir)) {
+        const shortHash = shortHashFromFileName3(fileName);
+        const data = await this.loadPending(shortHash);
+        if (data && data.expiresAt < Date.now()) {
+          expired.push(data);
+          await this.deletePending(shortHash);
+        }
+      }
+      return expired;
+    }
+  };
+}
+function createStartWorkShortHash(sessionID) {
+  return createHash4("sha256").update(sessionID).digest("base64url").slice(0, 10);
+}
+
+// src/events/start-work.ts
+var CALLBACK_RE3 = /^sw:([^:]+)$/;
+var START_WORK_COMMAND = "start-work";
+var START_WORK_EXPIRY_MS = 24 * 60 * 6e4;
+function startWorkKeyboard(shortHash) {
+  const callbackData = `sw:${shortHash}`;
+  if (Buffer.byteLength(callbackData, "utf8") > 64)
+    throw new Error("Telegram callback_data exceeds 64 bytes");
+  return [[{ text: "\u25B6\uFE0F Run /start-work", callback_data: callbackData }]];
+}
+function planCompleteMessage(title) {
+  return title ? `plan \uC791\uC131\uC774 \uB05D\uB0AC\uC5B4\uC694.
+
+${title}` : "plan \uC791\uC131\uC774 \uB05D\uB0AC\uC5B4\uC694.";
+}
+function createPendingStartWork(sessionID, title, serverUrl, telegramMessageId) {
+  const sentAt = Date.now();
+  return {
+    sessionID,
+    serverUrl,
+    title: title ?? void 0,
+    sentAt,
+    expiresAt: sentAt + START_WORK_EXPIRY_MS,
+    telegramMessageId
+  };
+}
+function startWorkShortHash(sessionID) {
+  return createStartWorkShortHash(sessionID);
+}
+async function expirePending3(ctx, shortHash, pending, messageId) {
+  await ctx.bot.editMessageRemoveKeyboard(messageId, "\u23F1 /start-work request expired");
+  await ctx.pendingStartWorks.deletePending(shortHash);
+  ctx.logger.info("pending start-work expired", { sessionID: pending.sessionID });
+}
+function createStartWorkDispatcher(ctx) {
+  return {
+    async handleCallbackQuery(data, messageId) {
+      const match = CALLBACK_RE3.exec(data);
+      if (!match) return;
+      const shortHash = match[1];
+      const pending = await ctx.pendingStartWorks.loadPending(shortHash);
+      if (!pending) {
+        await ctx.bot.editMessageRemoveKeyboard(messageId, "This /start-work request has expired.");
+        return;
+      }
+      if (pending.expiresAt < Date.now()) {
+        await expirePending3(ctx, shortHash, pending, messageId);
+        return;
+      }
+      try {
+        await ctx.runSessionCommand(pending.sessionID, START_WORK_COMMAND, pending.serverUrl);
+        const label = pending.title ?? pending.sessionID;
+        await ctx.bot.editMessageRemoveKeyboard(
+          messageId,
+          `\u25B6\uFE0F Sent /start-work to opencode.
+
+Session: ${label}`
+        );
+        ctx.logger.info("start-work command sent", { sessionID: pending.sessionID });
+      } catch (err) {
+        await ctx.bot.editMessageRemoveKeyboard(
+          messageId,
+          "\u26A0\uFE0F Failed to send /start-work to opencode"
+        );
+        ctx.logger.error("failed to send start-work command", {
+          sessionID: pending.sessionID,
+          error: String(err)
+        });
+      } finally {
+        await ctx.pendingStartWorks.deletePending(shortHash);
+      }
+    }
+  };
+}
+
 // src/events/session-idle.ts
 var ROOT_IDLE_RECHECK_DELAY_MS = 2500;
 function sleep(ms) {
@@ -988,9 +1164,21 @@ async function sendIdleNotification(sessionId, ctx) {
   });
   if (!claimed) return;
   const title = ctx.sessionTitleService.getSessionTitle(sessionId);
-  const text = title ? `Agent has finished: ${title}` : "Agent has finished.";
+  const isPlanSession = ctx.sessionTitleService.getSessionAgent(sessionId) === "plan";
+  const text = isPlanSession ? planCompleteMessage(title) : title ? `Agent has finished: ${title}` : "Agent has finished.";
   try {
-    await ctx.bot.sendMessage(text);
+    if (isPlanSession) {
+      const shortHash = startWorkShortHash(sessionId);
+      const message = await ctx.bot.sendMessage(text, {
+        reply_markup: { inline_keyboard: startWorkKeyboard(shortHash) }
+      });
+      await ctx.pendingStartWorks.savePending(
+        shortHash,
+        createPendingStartWork(sessionId, title, ctx.serverUrl.href, message.message_id)
+      );
+    } else {
+      await ctx.bot.sendMessage(text);
+    }
     ctx.sessionTitleService.clearDeferredIdleNotification(sessionId);
     ctx.logger.info("idle notification sent", { sessionId, title });
   } catch (err) {
@@ -1000,15 +1188,19 @@ async function sendIdleNotification(sessionId, ctx) {
 async function flushDeferredParentIfReady(parentID, ctx) {
   if (!ctx.sessionTitleService.hasDeferredIdleNotification(parentID)) return;
   if (ctx.sessionTitleService.hasUnfinishedDescendants(parentID)) return;
-  if (ctx.sessionTitleService.getSessionStatus(parentID) !== "idle") {
+  const parentStatus = ctx.sessionTitleService.getSessionStatus(parentID);
+  if (parentStatus === "idle") {
+    ctx.logger.info("keeping deferred parent idle notification - waiting for parent to resume", {
+      sessionId: parentID
+    });
+    return;
+  }
+  if (parentStatus !== void 0) {
     ctx.sessionTitleService.clearDeferredIdleNotification(parentID);
     ctx.logger.info("clearing deferred parent idle notification - parent resumed", {
       sessionId: parentID
     });
-    return;
   }
-  ctx.logger.info("sending deferred parent idle notification", { sessionId: parentID });
-  await sendIdleNotification(parentID, ctx);
 }
 async function deferParentIdleIfDescendantsRunning(sessionId, ctx) {
   await hydrateDescendants(sessionId, ctx);
@@ -1021,8 +1213,8 @@ async function deferParentIdleIfDescendantsRunning(sessionId, ctx) {
 }
 async function handleSessionIdle(event, ctx) {
   const sessionId = event.properties.sessionID;
-  ctx.sessionTitleService.setSessionStatus(sessionId, "idle");
   const parentID = await resolveParentID(sessionId, ctx);
+  ctx.sessionTitleService.setSessionStatus(sessionId, "idle");
   if (typeof parentID === "string") {
     ctx.logger.info("suppressing child session idle notification", { sessionId, parentID });
     await flushDeferredParentIfReady(parentID, ctx);
@@ -1064,14 +1256,14 @@ async function handleSessionUpdated(event, ctx) {
 // src/lib/env-loader.ts
 import { existsSync } from "fs";
 import { homedir } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import dotenv from "dotenv";
 function loadPluginEnv(opts) {
   const paths = [
-    join4(opts.pluginDir, "../../.env"),
-    join4(opts.pluginDir, "..", ".env"),
-    join4(opts.pluginDir, ".env"),
-    join4(opts.homeDir ?? homedir(), ".config/opencode/telegram-remote/.env")
+    join5(opts.pluginDir, "../../.env"),
+    join5(opts.pluginDir, "..", ".env"),
+    join5(opts.pluginDir, ".env"),
+    join5(opts.homeDir ?? homedir(), ".config/opencode/telegram-remote/.env")
   ];
   const loadedFrom = [];
   const values = {};
@@ -1089,10 +1281,10 @@ function loadPluginEnv(opts) {
 }
 
 // src/lib/lock.ts
-import { open as open2, readFile as readFile3, stat as stat2, unlink as unlink4 } from "fs/promises";
+import { open as open2, readFile as readFile4, stat as stat2, unlink as unlink5 } from "fs/promises";
 import { hostname } from "os";
 var DEFAULT_TTL_MS2 = 5 * 60 * 1e3;
-function hasCode4(err, code) {
+function hasCode5(err, code) {
   return "code" in err && err.code === code;
 }
 function parseLockData(text) {
@@ -1111,7 +1303,7 @@ function isPidAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    if (err instanceof Error && hasCode4(err, "ESRCH")) return false;
+    if (err instanceof Error && hasCode5(err, "ESRCH")) return false;
     return true;
   }
 }
@@ -1132,7 +1324,7 @@ async function createLock(lockPath, pid) {
       if (released) return;
       released = true;
       try {
-        await unlink4(lockPath);
+        await unlink5(lockPath);
       } catch {
       }
     }
@@ -1142,7 +1334,7 @@ async function inspectExisting(lockPath, ttlMs) {
   let ownerPid;
   let dead = false;
   try {
-    const text = await readFile3(lockPath, "utf8");
+    const text = await readFile4(lockPath, "utf8");
     const data = parseLockData(text);
     if (data) {
       ownerPid = data.pid;
@@ -1168,7 +1360,7 @@ async function acquireLock(opts) {
     try {
       return { acquired: true, handle: await createLock(opts.lockPath, pid) };
     } catch (err) {
-      if (!(err instanceof Error) || !hasCode4(err, "EEXIST")) {
+      if (!(err instanceof Error) || !hasCode5(err, "EEXIST")) {
         return { acquired: false, reason: err instanceof Error ? err.message : String(err) };
       }
       const existing = await inspectExisting(opts.lockPath, ttlMs);
@@ -1176,7 +1368,7 @@ async function acquireLock(opts) {
         return { acquired: false, reason: existing.reason, ownerPid: existing.ownerPid };
       }
       try {
-        await unlink4(opts.lockPath);
+        await unlink5(opts.lockPath);
       } catch {
         return { acquired: false, reason: "failed to remove stale lock", ownerPid: existing.ownerPid };
       }
@@ -1187,7 +1379,7 @@ async function acquireLock(opts) {
 
 // src/lib/logger.ts
 import { appendFile } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
+import { tmpdir as tmpdir4 } from "os";
 var DEFAULT_BUFFER_LIMIT = 4096;
 var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
 function safeJson(data) {
@@ -1198,7 +1390,7 @@ function safeJson(data) {
   }
 }
 function createLogger(opts = {}) {
-  const filePath = opts.filePath ?? `${tmpdir3()}/opencoder-telegram.log`;
+  const filePath = opts.filePath ?? `${tmpdir4()}/opencoder-telegram.log`;
   const namespace = opts.namespace ?? "default";
   const bufferLimit = opts.bufferLimit ?? DEFAULT_BUFFER_LIMIT;
   const flushIntervalMs = opts.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
@@ -1256,10 +1448,10 @@ function createLogger(opts = {}) {
 }
 
 // src/lib/state-store.ts
-import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join5 } from "path";
-function hasCode5(err, code) {
+import { dirname as dirname4, join as join6 } from "path";
+function hasCode6(err, code) {
   return "code" in err && err.code === code;
 }
 function parseState(text) {
@@ -1271,28 +1463,28 @@ function parseState(text) {
   return state;
 }
 function createStateStore(opts = {}) {
-  const filePath = opts.filePath ?? join5(homedir2(), ".config/opencode/telegram-remote/state.json");
+  const filePath = opts.filePath ?? join6(homedir2(), ".config/opencode/telegram-remote/state.json");
   return {
     async read() {
       try {
-        return parseState(await readFile4(filePath, "utf8"));
+        return parseState(await readFile5(filePath, "utf8"));
       } catch (err) {
-        if (err instanceof Error && hasCode5(err, "ENOENT")) return {};
+        if (err instanceof Error && hasCode6(err, "ENOENT")) return {};
         throw err;
       }
     },
     async write(patch) {
       const existing = await this.read();
       const next = { ...existing, ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      await mkdir4(dirname3(filePath), { recursive: true });
+      await mkdir5(dirname4(filePath), { recursive: true });
       const tmpPath = `${filePath}.tmp.${process.pid}`;
-      await writeFile3(tmpPath, JSON.stringify(next, null, 2), "utf8");
+      await writeFile4(tmpPath, JSON.stringify(next, null, 2), "utf8");
       try {
-        await rename3(tmpPath, filePath);
+        await rename4(tmpPath, filePath);
       } catch (err) {
-        if (!(err instanceof Error) || !hasCode5(err, "ENOENT")) throw err;
-        await writeFile3(tmpPath, JSON.stringify(next, null, 2), "utf8");
-        await rename3(tmpPath, filePath);
+        if (!(err instanceof Error) || !hasCode6(err, "ENOENT")) throw err;
+        await writeFile4(tmpPath, JSON.stringify(next, null, 2), "utf8");
+        await rename4(tmpPath, filePath);
       }
       return next;
     }
@@ -1300,6 +1492,10 @@ function createStateStore(opts = {}) {
 }
 
 // src/services/session-title-service.ts
+function agentFromSession(info) {
+  const candidate = info;
+  return typeof candidate.agent === "string" ? candidate.agent : void 0;
+}
 var SessionTitleService = class {
   sessions = /* @__PURE__ */ new Map();
   setSessionInfo(info) {
@@ -1307,6 +1503,7 @@ var SessionTitleService = class {
     this.sessions.set(info.id, {
       title: info.title || null,
       parentID: info.parentID ?? null,
+      agent: agentFromSession(info) ?? existing?.agent,
       status: existing?.status,
       idleNotificationPending: existing?.idleNotificationPending ?? false
     });
@@ -1315,7 +1512,18 @@ var SessionTitleService = class {
     const existing = this.sessions.get(sessionId);
     this.sessions.set(sessionId, {
       title,
-      parentID: existing?.parentID ?? null,
+      parentID: existing?.parentID,
+      agent: existing?.agent,
+      status: existing?.status,
+      idleNotificationPending: existing?.idleNotificationPending ?? false
+    });
+  }
+  setSessionAgent(sessionId, agent) {
+    const existing = this.sessions.get(sessionId);
+    this.sessions.set(sessionId, {
+      title: existing?.title ?? null,
+      parentID: existing?.parentID,
+      agent,
       status: existing?.status,
       idleNotificationPending: existing?.idleNotificationPending ?? false
     });
@@ -1324,7 +1532,8 @@ var SessionTitleService = class {
     const existing = this.sessions.get(sessionId);
     this.sessions.set(sessionId, {
       title: existing?.title ?? null,
-      parentID: existing?.parentID ?? null,
+      parentID: existing?.parentID,
+      agent: existing?.agent,
       status,
       idleNotificationPending: status === "idle" ? existing?.idleNotificationPending ?? false : false
     });
@@ -1335,6 +1544,9 @@ var SessionTitleService = class {
   getParentID(sessionId) {
     return this.sessions.get(sessionId)?.parentID;
   }
+  getSessionAgent(sessionId) {
+    return this.sessions.get(sessionId)?.agent;
+  }
   getSessionStatus(sessionId) {
     return this.sessions.get(sessionId)?.status;
   }
@@ -1350,7 +1562,8 @@ var SessionTitleService = class {
     const existing = this.sessions.get(sessionId);
     this.sessions.set(sessionId, {
       title: existing?.title ?? null,
-      parentID: existing?.parentID ?? null,
+      parentID: existing?.parentID,
+      agent: existing?.agent,
       status: existing?.status ?? "idle",
       idleNotificationPending: true
     });
@@ -1369,7 +1582,33 @@ var SessionTitleService = class {
 };
 
 // src/telegram-remote.ts
-var pluginDir = dirname4(fileURLToPath(import.meta.url));
+var pluginDir = dirname5(fileURLToPath(import.meta.url));
+async function postToServer(serverUrl, path, body) {
+  const url = new URL(path, serverUrl);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (response.ok) return;
+  const text = await response.text();
+  throw new Error(
+    `OpenCode request failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+  );
+}
+function getSessionAgentFromMessage(event) {
+  const info = event.properties.info;
+  if (info.role !== "user") return void 0;
+  return { sessionID: info.sessionID, agent: info.agent };
+}
+function getSessionAgentFromNextStep(event) {
+  if (event.type !== "session.next.step.started") return void 0;
+  const props = event.properties;
+  if (!props) return void 0;
+  if (typeof props.sessionID !== "string") return void 0;
+  if (typeof props.agent !== "string") return void 0;
+  return { sessionID: props.sessionID, agent: props.agent };
+}
 var TelegramRemote = async (input) => {
   const logger = createLogger({ namespace: "telegram" });
   try {
@@ -1378,11 +1617,12 @@ var TelegramRemote = async (input) => {
     const config = loadConfig({ logger, env: process.env });
     const stateStore = createStateStore();
     const initialState = await stateStore.read();
-    const tokenHash = createHash4("sha256").update(config.botToken).digest("hex").slice(0, 16);
-    const lockPath = join6(tmpdir4(), `opencoder-telegram-${tokenHash}.lock`);
-    const claimsDir = join6(tmpdir4(), `opencoder-telegram-claims-${tokenHash}`);
+    const tokenHash = createHash5("sha256").update(config.botToken).digest("hex").slice(0, 16);
+    const lockPath = join7(tmpdir5(), `opencoder-telegram-${tokenHash}.lock`);
+    const claimsDir = join7(tmpdir5(), `opencoder-telegram-claims-${tokenHash}`);
     const pendingQuestions = createPendingQuestionStore({ tokenHash });
     const pendingPermissions = createPendingPermissionStore({ tokenHash });
+    const pendingStartWorks = createPendingStartWorkStore({ tokenHash });
     const lockResult = await acquireLock({ lockPath });
     const isLeader = lockResult.acquired;
     logger.info(
@@ -1396,31 +1636,59 @@ var TelegramRemote = async (input) => {
     });
     const sessionTitleService = new SessionTitleService();
     const client = input.client;
-    const replyToQuestion = async (requestID, answers) => {
+    const replyToQuestion = async (requestID, answers, serverUrl = input.serverUrl.href) => {
+      const path = `/question/${encodeURIComponent(requestID)}/reply`;
+      if (serverUrl !== input.serverUrl.href) {
+        await postToServer(serverUrl, path, { answers });
+        return;
+      }
       await client._client.post({
-        url: `/question/${encodeURIComponent(requestID)}/reply`,
+        url: path,
         headers: { "Content-Type": "application/json" },
         body: { answers },
         throwOnError: true
       });
     };
-    const replyToPermission = async (requestID, sessionID, reply, endpoint) => {
+    const replyToPermission = async (requestID, sessionID, reply, endpoint, serverUrl = input.serverUrl.href) => {
       if (endpoint === "request") {
+        const path2 = `/permission/${encodeURIComponent(requestID)}/reply`;
+        if (serverUrl !== input.serverUrl.href) {
+          await postToServer(serverUrl, path2, { reply });
+          return;
+        }
         await client._client.post({
-          url: `/permission/${encodeURIComponent(requestID)}/reply`,
+          url: path2,
           headers: { "Content-Type": "application/json" },
           body: { reply },
           throwOnError: true
         });
         return;
       }
+      const path = `/session/${encodeURIComponent(sessionID)}/permissions/${encodeURIComponent(requestID)}`;
+      if (serverUrl !== input.serverUrl.href) {
+        await postToServer(serverUrl, path, { response: reply });
+        return;
+      }
       await client._client.post({
-        url: `/session/${encodeURIComponent(sessionID)}/permissions/${encodeURIComponent(requestID)}`,
+        url: path,
         headers: { "Content-Type": "application/json" },
         body: { response: reply },
         throwOnError: true
       });
     };
+    const runSessionCommand = async (sessionID, command, serverUrl = input.serverUrl.href) => {
+      const path = `/session/${encodeURIComponent(sessionID)}/command`;
+      const body = { command, arguments: "" };
+      if (serverUrl !== input.serverUrl.href) {
+        await postToServer(serverUrl, path, body);
+        return;
+      }
+      await input.client.session.command({
+        path: { id: sessionID },
+        body,
+        throwOnError: true
+      });
+    };
     const bot = createTelegramBot({
       config,
       stateStore,
@@ -1465,12 +1733,15 @@ var TelegramRemote = async (input) => {
       tokenHash,
       pendingQuestions,
       pendingPermissions,
+      pendingStartWorks,
       replyToQuestion,
-      replyToPermission
+      replyToPermission,
+      runSessionCommand
     };
     if (isLeader) {
       bot.setQuestionDispatcher(createQuestionDispatcher(ctx));
       bot.setPermissionDispatcher(createPermissionDispatcher(ctx));
+      bot.setStartWorkDispatcher(createStartWorkDispatcher(ctx));
     }
     return {
       event: async ({ event }) => {
@@ -1485,9 +1756,20 @@ var TelegramRemote = async (input) => {
             return handleSessionCreated(event, ctx);
           case "session.updated":
             return handleSessionUpdated(event, ctx);
+          case "message.updated": {
+            const messageAgent = getSessionAgentFromMessage(event);
+            if (messageAgent)
+              ctx.sessionTitleService.setSessionAgent(messageAgent.sessionID, messageAgent.agent);
+            return;
+          }
           case "permission.updated":
             return handlePermissionUpdated(event, ctx);
           default: {
+            const stepAgent = getSessionAgentFromNextStep(extEvent);
+            if (stepAgent) {
+              ctx.sessionTitleService.setSessionAgent(stepAgent.sessionID, stepAgent.agent);
+              return;
+            }
             if (isEventPermissionAsked(extEvent)) {
               if (!isLeader) return;
               return handlePermissionAsked(extEvent, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinseeker/opencode-telegram-plugin",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Control and monitor OpenCode from Telegram with notifications, question replies, and subagent-aware completion.",
   "type": "module",
   "main": "dist/telegram-remote.js",