@coinseeker/opencode-telegram-plugin 1.0.14 → 1.1.1

package/README.md

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

package/dist/telegram-remote.js

@@ -40,9 +40,10 @@ function pendingQuestionText(questions, questionIndex) {
 
 // src/bot.ts
 function createTelegramBot(opts) {
-  const { config, stateStore, logger, polling } = opts;
+  const { config, stateStore, logger } = opts;
   const bot = new Bot(config.botToken);
   let activeChatId = opts.initialChatId;
+  let pollingActive = false;
   let questionDispatcher;
   let permissionDispatcher;
   let startWorkDispatcher;
@@ -51,103 +52,101 @@ function createTelegramBot(opts) {
   let startWorkCommandDispatcher;
   let helpDispatcher;
   let managerObj;
-  if (polling) {
-    bot.use(async (ctx, next) => {
-      const userId = ctx.from?.id;
-      if (!userId || !config.allowedUserIds.includes(userId)) {
-        logger.warn("unauthorized access attempt", { userId });
-        return;
-      }
-      if (ctx.chat?.type !== "private") return;
-      if (ctx.chat?.id) {
-        const newChatId = ctx.chat.id;
-        if (activeChatId !== newChatId) {
-          activeChatId = newChatId;
-          await stateStore.write({ chatId: newChatId, discoveredBy: process.pid });
-          logger.info("chat_id discovered", { chatId: newChatId });
-          await ctx.reply(
-            `\u2705 Chat connected!
+  bot.use(async (ctx, next) => {
+    const userId = ctx.from?.id;
+    if (!userId || !config.allowedUserIds.includes(userId)) {
+      logger.warn("unauthorized access attempt", { userId });
+      return;
+    }
+    if (ctx.chat?.type !== "private") return;
+    if (ctx.chat?.id) {
+      const newChatId = ctx.chat.id;
+      if (activeChatId !== newChatId) {
+        activeChatId = newChatId;
+        await stateStore.write({ chatId: newChatId, discoveredBy: process.pid });
+        logger.info("chat_id discovered", { chatId: newChatId });
+        await ctx.reply(
+          `\u2705 Chat connected!
 
 Your chat_id: ${newChatId}
 
 This chat is now active for OpenCode notifications.`
-          );
-        }
-      }
-      await next();
-    });
-    bot.catch((err) => {
-      const e = err.error;
-      if (e instanceof GrammyError && e.error_code === 409) {
-        logger.info("polling conflict (409) - another process took over", {
-          description: e.description
-        });
-      } else {
-        logger.error("bot error", { error: String(e) });
+        );
       }
-    });
-    bot.callbackQuery(/^q:([^:]+):(\d+):(\d+|c|d)$/, async (ctx) => {
-      await ctx.answerCallbackQuery();
-      const data = ctx.callbackQuery.data;
-      const messageId = ctx.callbackQuery.message?.message_id;
-      const chatId = ctx.chat?.id;
-      const userId = ctx.from?.id;
-      if (!questionDispatcher || messageId === void 0 || chatId === void 0 || userId === void 0)
-        return;
-      await questionDispatcher.handleCallbackQuery(data, messageId, chatId, userId);
-    });
-    bot.callbackQuery(/^p:([^:]+):(o|a|r)$/, async (ctx) => {
-      await ctx.answerCallbackQuery();
-      const data = ctx.callbackQuery.data;
-      const messageId = ctx.callbackQuery.message?.message_id;
-      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.command("sessions", async (ctx) => {
-      if (!sessionsDispatcher) return;
-      const chatId = ctx.chat?.id;
-      const userId = ctx.from?.id;
-      if (chatId === void 0 || userId === void 0) return;
-      await sessionsDispatcher({ chatId, userId, bot: managerObj });
-    });
-    bot.command("status", async (ctx) => {
-      if (!statusDispatcher) return;
-      const chatId = ctx.chat?.id;
-      const userId = ctx.from?.id;
-      if (chatId === void 0 || userId === void 0) return;
-      const args = ctx.match.trim().split(/\s+/).filter(Boolean);
-      await statusDispatcher({ chatId, userId, bot: managerObj, args });
-    });
-    bot.command("start_work", async (ctx) => {
-      if (!startWorkCommandDispatcher) return;
-      const chatId = ctx.chat?.id;
-      const userId = ctx.from?.id;
-      if (chatId === void 0 || userId === void 0) return;
-      const args = ctx.match.trim().split(/\s+/).filter(Boolean);
-      await startWorkCommandDispatcher({ chatId, userId, bot: managerObj, args });
-    });
-    bot.command("help", async (ctx) => {
-      if (!helpDispatcher) return;
-      const chatId = ctx.chat?.id;
-      const userId = ctx.from?.id;
-      if (chatId === void 0 || userId === void 0) return;
-      await helpDispatcher({ chatId, userId, bot: managerObj });
-    });
-    bot.on("message:text", async (ctx) => {
-      const replyToMessageId = ctx.message.reply_to_message?.message_id;
-      const chatId = ctx.chat.id;
-      const userId = ctx.from?.id;
-      if (!questionDispatcher || replyToMessageId === void 0 || userId === void 0) return;
-      await questionDispatcher.handleTextReply(ctx.message.text, chatId, userId, replyToMessageId);
-    });
-  }
+    }
+    await next();
+  });
+  bot.catch((err) => {
+    const e = err.error;
+    if (e instanceof GrammyError && e.error_code === 409) {
+      logger.info("polling conflict (409) - another process took over", {
+        description: e.description
+      });
+    } else {
+      logger.error("bot error", { error: String(e) });
+    }
+  });
+  bot.callbackQuery(/^q:([^:]+):(\d+):(\d+|c|d)$/, async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const data = ctx.callbackQuery.data;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    const chatId = ctx.chat?.id;
+    const userId = ctx.from?.id;
+    if (!questionDispatcher || messageId === void 0 || chatId === void 0 || userId === void 0)
+      return;
+    await questionDispatcher.handleCallbackQuery(data, messageId, chatId, userId);
+  });
+  bot.callbackQuery(/^p:([^:]+):(o|a|r)$/, async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const data = ctx.callbackQuery.data;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    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.command("sessions", async (ctx) => {
+    if (!sessionsDispatcher) return;
+    const chatId = ctx.chat?.id;
+    const userId = ctx.from?.id;
+    if (chatId === void 0 || userId === void 0) return;
+    await sessionsDispatcher({ chatId, userId, bot: managerObj });
+  });
+  bot.command("status", async (ctx) => {
+    if (!statusDispatcher) return;
+    const chatId = ctx.chat?.id;
+    const userId = ctx.from?.id;
+    if (chatId === void 0 || userId === void 0) return;
+    const args = ctx.match.trim().split(/\s+/).filter(Boolean);
+    await statusDispatcher({ chatId, userId, bot: managerObj, args });
+  });
+  bot.command("start_work", async (ctx) => {
+    if (!startWorkCommandDispatcher) return;
+    const chatId = ctx.chat?.id;
+    const userId = ctx.from?.id;
+    if (chatId === void 0 || userId === void 0) return;
+    const args = ctx.match.trim().split(/\s+/).filter(Boolean);
+    await startWorkCommandDispatcher({ chatId, userId, bot: managerObj, args });
+  });
+  bot.command("help", async (ctx) => {
+    if (!helpDispatcher) return;
+    const chatId = ctx.chat?.id;
+    const userId = ctx.from?.id;
+    if (chatId === void 0 || userId === void 0) return;
+    await helpDispatcher({ chatId, userId, bot: managerObj });
+  });
+  bot.on("message:text", async (ctx) => {
+    const replyToMessageId = ctx.message.reply_to_message?.message_id;
+    const chatId = ctx.chat.id;
+    const userId = ctx.from?.id;
+    if (!questionDispatcher || replyToMessageId === void 0 || userId === void 0) return;
+    await questionDispatcher.handleTextReply(ctx.message.text, chatId, userId, replyToMessageId);
+  });
   const requireChatId = async (action) => {
     if (activeChatId) return activeChatId;
     const state = await stateStore.read();
@@ -159,10 +158,8 @@ This chat is now active for OpenCode notifications.`
   };
   managerObj = {
     async start() {
-      if (!polling) {
-        logger.info("pass-through mode - skipping bot.start()");
-        return;
-      }
+      if (pollingActive) return;
+      pollingActive = true;
       try {
         await bot.api.setMyCommands([
           { command: "sessions", description: "\uD65C\uC131 \uC138\uC158 \uBAA9\uB85D (top 20)" },
@@ -173,22 +170,30 @@ This chat is now active for OpenCode notifications.`
       } catch (err) {
         logger.warn("setMyCommands failed", { error: String(err) });
       }
-      await bot.start({
-        drop_pending_updates: true,
-        onStart: () => {
-          logger.info("polling started");
-        }
-      });
+      try {
+        await bot.start({
+          drop_pending_updates: true,
+          onStart: () => {
+            logger.info("polling started");
+          }
+        });
+      } catch (err) {
+        pollingActive = false;
+        throw err;
+      }
     },
     async stop() {
-      if (polling) {
-        try {
-          await bot.stop();
-        } catch (err) {
-          logger.warn("bot.stop() error", { error: String(err) });
-        }
+      if (!pollingActive) return;
+      pollingActive = false;
+      try {
+        await bot.stop();
+      } catch (err) {
+        logger.warn("bot.stop() error", { error: String(err) });
       }
     },
+    isPolling() {
+      return pollingActive;
+    },
     async sendMessage(text, options) {
       const chatId = await requireChatId("sendMessage");
       const result = await bot.api.sendMessage(chatId, text, options);
@@ -364,7 +369,7 @@ async function claimOnce(opts) {
 
 // src/lib/pending-permissions.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir2, readFile, readdir as readdir2, rename, unlink as unlink2, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readdir as readdir2, readFile, rename, unlink as unlink2, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname, join as join2 } from "path";
 function hasCode2(err, code) {
@@ -375,13 +380,17 @@ function pendingFilePath(dir, shortHash) {
 }
 function parsePending(text) {
   const parsed = JSON.parse(text);
-  if (typeof parsed.requestID !== "string") throw new Error("Invalid pending permission: requestID");
-  if (typeof parsed.sessionID !== "string") throw new Error("Invalid pending permission: sessionID");
+  if (typeof parsed.requestID !== "string")
+    throw new Error("Invalid pending permission: requestID");
+  if (typeof parsed.sessionID !== "string")
+    throw new Error("Invalid pending permission: sessionID");
   if (typeof parsed.title !== "string") throw new Error("Invalid pending permission: title");
-  if (typeof parsed.permission !== "string") throw new Error("Invalid pending permission: permission");
+  if (typeof parsed.permission !== "string")
+    throw new Error("Invalid pending permission: permission");
   if (!Array.isArray(parsed.patterns)) throw new Error("Invalid pending permission: patterns");
   if (!Array.isArray(parsed.always)) throw new Error("Invalid pending permission: always");
-  if (parsed.endpoint !== "request" && parsed.endpoint !== "session") throw new Error("Invalid pending permission: endpoint");
+  if (parsed.endpoint !== "request" && parsed.endpoint !== "session")
+    throw new Error("Invalid pending permission: endpoint");
   return parsed;
 }
 async function listPendingFiles(dir) {
@@ -422,11 +431,13 @@ function createPendingPermissionStore(opts) {
         if (!(err instanceof Error) || !hasCode2(err, "ENOENT")) throw err;
       }
     },
-    async findByRequestID(requestID) {
+    async findByRequestID(requestID, sessionID, serverUrl) {
       for (const fileName of await listPendingFiles(dir)) {
         const shortHash = shortHashFromFileName(fileName);
         const data = await this.loadPending(shortHash);
-        if (data?.requestID === requestID) return { shortHash, data };
+        if (data?.requestID === requestID && (sessionID === void 0 || data.sessionID === sessionID) && (serverUrl === void 0 || data.serverUrl === serverUrl)) {
+          return { shortHash, data };
+        }
       }
       return void 0;
     },
@@ -444,8 +455,9 @@ function createPendingPermissionStore(opts) {
     }
   };
 }
-function createPermissionShortHash(requestID) {
-  return createHash2("sha256").update(requestID).digest("base64url").slice(0, 10);
+function createPermissionShortHash(requestID, sessionID, endpoint2, serverUrl) {
+  const source = sessionID === void 0 ? requestID : `${serverUrl ?? ""}:${endpoint2 ?? ""}:${sessionID}:${requestID}`;
+  return createHash2("sha256").update(source).digest("base64url").slice(0, 10);
 }
 
 // src/events/permission-updated.ts
@@ -467,7 +479,8 @@ function isEventPermissionAsked(event) {
 }
 function buildCallbackData(shortHash, reply) {
   const data = `p:${shortHash}:${reply}`;
-  if (Buffer.byteLength(data, "utf8") > 64) throw new Error("Telegram callback_data exceeds 64 bytes");
+  if (Buffer.byteLength(data, "utf8") > 64)
+    throw new Error("Telegram callback_data exceeds 64 bytes");
   return data;
 }
 function normalizeUpdated(permission) {
@@ -479,8 +492,7 @@ function normalizeUpdated(permission) {
     permission: permission.type,
     patterns: pattern,
     always: [],
-    endpoint: "session",
-    claimKey: `permission.updated:${permission.id}`
+    endpoint: "session"
   };
 }
 function normalizeAsked(permission) {
@@ -491,8 +503,7 @@ function normalizeAsked(permission) {
     permission: permission.permission,
     patterns: permission.patterns,
     always: permission.always,
-    endpoint: "request",
-    claimKey: `permission.asked:${permission.id}`
+    endpoint: "request"
   };
 }
 function permissionMessage(permission, sessionTitle) {
@@ -527,9 +538,15 @@ function replyLabel(reply) {
   return "Rejected";
 }
 async function handleNormalizedPermission(permission, ctx) {
-  const claimed = await claimOnce({ claimsDir: ctx.claimsDir, key: permission.claimKey });
+  const permissionKey = `${ctx.serverUrl.href}:${permission.sessionID}:${permission.requestID}`;
+  const claimed = await claimOnce({ claimsDir: ctx.claimsDir, key: `permission:${permissionKey}` });
   if (!claimed) return;
-  const shortHash = createPermissionShortHash(permission.requestID);
+  const shortHash = createPermissionShortHash(
+    permission.requestID,
+    permission.sessionID,
+    permission.endpoint,
+    ctx.serverUrl.href
+  );
   const sentAt = Date.now();
   const rawSessionTitle = ctx.sessionTitleService.getSessionTitle(permission.sessionID);
   const sessionTitle = rawSessionTitle === null ? void 0 : rawSessionTitle;
@@ -555,11 +572,6 @@ async function handleNormalizedPermission(permission, ctx) {
     ctx.logger.error("failed to send permission notification", { error: String(err) });
   }
 }
-async function expirePending(ctx, shortHash, pending, messageId) {
-  await ctx.bot.editMessageRemoveKeyboard(messageId, "\u23F1 Permission request expired");
-  await ctx.pendingPermissions.deletePending(shortHash);
-  ctx.logger.info("pending permission expired", { requestID: pending.requestID });
-}
 async function handlePermissionUpdated(event, ctx) {
   await handleNormalizedPermission(normalizeUpdated(event.properties), ctx);
 }
@@ -583,7 +595,11 @@ function externalReplyLabel(value) {
 async function handlePermissionReplied(event, ctx) {
   const requestID = event.properties.requestID ?? event.properties.permissionID;
   if (!requestID) return;
-  const found = await ctx.pendingPermissions.findByRequestID(requestID);
+  const found = await ctx.pendingPermissions.findByRequestID(
+    requestID,
+    event.properties.sessionID,
+    ctx.serverUrl.href
+  );
   if (!found) return;
   const label = externalReplyLabel(event.properties.reply ?? event.properties.response);
   try {
@@ -619,10 +635,6 @@ function createPermissionDispatcher(ctx) {
         await ctx.bot.editMessageRemoveKeyboard(messageId, "This permission request has expired.");
         return;
       }
-      if (pending.expiresAt < Date.now()) {
-        await expirePending(ctx, shortHash, pending, messageId);
-        return;
-      }
       try {
         await ctx.replyToPermission(
           pending.requestID,
@@ -631,13 +643,26 @@ function createPermissionDispatcher(ctx) {
           pending.endpoint,
           pending.serverUrl
         );
-        await ctx.bot.editMessageRemoveKeyboard(messageId, `\u2705 Permission ${replyLabel(reply)}
+        await ctx.bot.editMessageRemoveKeyboard(
+          messageId,
+          `\u2705 Permission ${replyLabel(reply)}
 
-${pending.permission}: ${pending.title}`);
-        ctx.logger.info("permission reply sent", { requestID: pending.requestID, sessionID: pending.sessionID, reply });
+${pending.permission}: ${pending.title}`
+        );
+        ctx.logger.info("permission reply sent", {
+          requestID: pending.requestID,
+          sessionID: pending.sessionID,
+          reply
+        });
       } catch (err) {
-        await ctx.bot.editMessageRemoveKeyboard(messageId, "\u26A0\uFE0F Failed to send permission reply to opencode");
-        ctx.logger.error("failed to send permission reply", { error: String(err), requestID: pending.requestID });
+        await ctx.bot.editMessageRemoveKeyboard(
+          messageId,
+          "\u26A0\uFE0F Failed to send permission reply to opencode"
+        );
+        ctx.logger.error("failed to send permission reply", {
+          error: String(err),
+          requestID: pending.requestID
+        });
       } finally {
         await ctx.pendingPermissions.deletePending(shortHash);
       }
@@ -647,7 +672,7 @@ ${pending.permission}: ${pending.title}`);
 
 // src/lib/pending-questions.ts
 import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir3, readFile as readFile2, readdir as readdir3, rename as rename2, unlink as unlink3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readdir as readdir3, readFile as readFile2, rename as rename2, unlink as unlink3, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname2, join as join3 } from "path";
 function hasCode3(err, code) {
@@ -661,8 +686,10 @@ function parsePending2(text) {
   if (typeof parsed.requestID !== "string") throw new Error("Invalid pending question: requestID");
   if (typeof parsed.sessionID !== "string") throw new Error("Invalid pending question: sessionID");
   if (!Array.isArray(parsed.questions)) throw new Error("Invalid pending question: questions");
-  if (!Array.isArray(parsed.telegramMessageIds)) throw new Error("Invalid pending question: telegramMessageIds");
-  if (!Array.isArray(parsed.answersInProgress)) throw new Error("Invalid pending question: answersInProgress");
+  if (!Array.isArray(parsed.telegramMessageIds))
+    throw new Error("Invalid pending question: telegramMessageIds");
+  if (!Array.isArray(parsed.answersInProgress))
+    throw new Error("Invalid pending question: answersInProgress");
   parsed.answersInProgress = parsed.answersInProgress.map((answer) => answer ?? null);
   return parsed;
 }
@@ -716,11 +743,13 @@ function createPendingQuestionStore(opts) {
       }
       return expired;
     },
-    async findByRequestID(requestID) {
+    async findByRequestID(requestID, sessionID, serverUrl) {
       for (const fileName of await listPendingFiles2(dir)) {
         const shortHash = shortHashFromFileName2(fileName);
         const data = await this.loadPending(shortHash);
-        if (data?.requestID === requestID) return { shortHash, data };
+        if (data?.requestID === requestID && (sessionID === void 0 || data.sessionID === sessionID) && (serverUrl === void 0 || data.serverUrl === serverUrl)) {
+          return { shortHash, data };
+        }
       }
       return void 0;
     },
@@ -729,14 +758,16 @@ function createPendingQuestionStore(opts) {
         const shortHash = shortHashFromFileName2(fileName);
         const data = await this.loadPending(shortHash);
         const awaiting = data?.awaitingCustomFor;
-        if (awaiting && awaiting.chatId === chatId && awaiting.userId === userId) return { shortHash, data };
+        if (awaiting && awaiting.chatId === chatId && awaiting.userId === userId)
+          return { shortHash, data };
       }
       return void 0;
     }
   };
 }
-function createQuestionShortHash(requestID) {
-  return createHash3("sha256").update(requestID).digest("base64url").slice(0, 10);
+function createQuestionShortHash(requestID, sessionID, serverUrl) {
+  const source = sessionID === void 0 ? requestID : `${serverUrl ?? ""}:${sessionID}:${requestID}`;
+  return createHash3("sha256").update(source).digest("base64url").slice(0, 10);
 }
 
 // src/events/question-asked.ts
@@ -855,21 +886,16 @@ ${answerSummary(pending.questions, answers)}`
     await ctx.pendingQuestions.deletePending(shortHash);
   }
 }
-async function expirePending2(ctx, shortHash, pending, messageId) {
-  await ctx.bot.editMessageRemoveKeyboard(messageId, "\u23F1 Question expired");
-  await ctx.pendingQuestions.deletePending(shortHash);
-  ctx.logger.info("pending question expired", { requestID: pending.requestID });
-}
 async function handleQuestionAsked(event, ctx) {
   const request = event.properties;
   if (request.questions.length === 0) return;
   const claimed = await claimOnce({
     claimsDir: ctx.claimsDir,
-    key: `question.asked:${request.id}`,
+    key: `question:${ctx.serverUrl.href}:${request.sessionID}:${request.id}`,
     ttlMs: 5e3
   });
   if (!claimed) return;
-  const shortHash = createQuestionShortHash(request.id);
+  const shortHash = createQuestionShortHash(request.id, request.sessionID, ctx.serverUrl.href);
   const firstQuestion = request.questions[0];
   const sentAt = Date.now();
   const pending = {
@@ -919,10 +945,7 @@ function createQuestionDispatcher(ctx) {
         await ctx.bot.editMessageRemoveKeyboard(messageId, "This question has expired.");
         return;
       }
-      if (pending.expiresAt < Date.now()) {
-        await expirePending2(ctx, shortHash, pending, messageId);
-        return;
-      }
+      pending.expiresAt = Date.now() + QUESTION_EXPIRY_MS;
       const question = pending.questions[questionIndex];
       if (!question) return;
       if (selection === "c") {
@@ -976,10 +999,7 @@ function createQuestionDispatcher(ctx) {
       if (!match) return;
       const awaiting = match.data.awaitingCustomFor;
       if (!awaiting || awaiting.promptMessageId !== replyToMessageId) return;
-      if (match.data.expiresAt < Date.now()) {
-        await expirePending2(ctx, match.shortHash, match.data, match.data.telegramMessageIds[0]);
-        return;
-      }
+      match.data.expiresAt = Date.now() + QUESTION_EXPIRY_MS;
       const question = match.data.questions[awaiting.questionIndex];
       if (question?.multiple === true) {
         const current = selectedAnswers(match.data, awaiting.questionIndex);
@@ -1002,16 +1022,31 @@ function createQuestionDispatcher(ctx) {
 function isEventQuestionReplied(event) {
   if (event.type !== "question.replied") return false;
   const props = event.properties;
-  return Boolean(props && typeof props.requestID === "string" && typeof props.sessionID === "string");
+  return Boolean(
+    props && typeof props.requestID === "string" && typeof props.sessionID === "string"
+  );
 }
 async function handleQuestionReplied(event, ctx) {
-  const found = await ctx.pendingQuestions.findByRequestID(event.properties.requestID);
-  if (!found) return;
+  const found = await ctx.pendingQuestions.findByRequestID(
+    event.properties.requestID,
+    event.properties.sessionID,
+    ctx.serverUrl.href
+  );
+  if (!found) {
+    ctx.logger.info("question.replied no pending match", {
+      requestID: event.properties.requestID,
+      sessionID: event.properties.sessionID
+    });
+    return;
+  }
   const messageId = found.data.telegramMessageIds[0];
   try {
     await ctx.bot.editMessageRemoveKeyboard(messageId, "\u2705 Already answered in opencode.");
   } catch (err) {
-    ctx.logger.error("failed to edit externally answered question", { error: String(err), requestID: event.properties.requestID });
+    ctx.logger.error("failed to edit externally answered question", {
+      error: String(err),
+      requestID: event.properties.requestID
+    });
   } finally {
     await ctx.pendingQuestions.deletePending(found.shortHash);
   }
@@ -1474,7 +1509,7 @@ function createPendingStartWork(sessionID, title, serverUrl, telegramMessageId)
 function startWorkShortHash(sessionID) {
   return createStartWorkShortHash(sessionID);
 }
-async function expirePending3(ctx, shortHash, pending, messageId) {
+async function expirePending(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 });
@@ -1491,7 +1526,7 @@ function createStartWorkDispatcher(ctx) {
         return;
       }
       if (pending.expiresAt < Date.now()) {
-        await expirePending3(ctx, shortHash, pending, messageId);
+        await expirePending(ctx, shortHash, pending, messageId);
         return;
       }
       try {
@@ -1522,9 +1557,21 @@ Session: ${label}`
 
 // src/events/session-idle.ts
 var ROOT_IDLE_RECHECK_DELAY_MS = 2500;
+var DEFERRED_PARENT_CONFIRM_DELAY_MS = 2500;
+var deferredConfirmTimers = /* @__PURE__ */ new Map();
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function agentFinishedMessage(title, agent) {
+  const base = title ? `Agent has finished: ${title}` : "Agent has finished.";
+  return agent ? `${base} (${agent})` : base;
+}
+function cancelDeferredParentConfirm(sessionId) {
+  const timer = deferredConfirmTimers.get(sessionId);
+  if (timer === void 0) return;
+  clearTimeout(timer);
+  deferredConfirmTimers.delete(sessionId);
+}
 async function resolveParentID(sessionId, ctx) {
   const cachedParentID = ctx.sessionTitleService.getParentID(sessionId);
   if (cachedParentID !== void 0) return cachedParentID;
@@ -1576,8 +1623,9 @@ async function sendIdleNotification(sessionId, ctx) {
   });
   if (!claimed) return;
   const title = ctx.sessionTitleService.getSessionTitle(sessionId);
-  const isPlanSession = ctx.sessionTitleService.getSessionAgent(sessionId) === "plan";
-  const text = isPlanSession ? planCompleteMessage(title) : title ? `Agent has finished: ${title}` : "Agent has finished.";
+  const agent = ctx.sessionTitleService.getSessionAgent(sessionId);
+  const isPlanSession = agent === "plan";
+  const text = isPlanSession ? planCompleteMessage(title) : agentFinishedMessage(title, agent);
   try {
     if (isPlanSession) {
       const shortHash = startWorkShortHash(sessionId);
@@ -1601,18 +1649,49 @@ async function flushDeferredParentIfReady(parentID, ctx) {
   if (!ctx.sessionTitleService.hasDeferredIdleNotification(parentID)) return;
   if (ctx.sessionTitleService.hasUnfinishedDescendants(parentID)) return;
   const parentStatus = ctx.sessionTitleService.getSessionStatus(parentID);
-  if (parentStatus === "idle") {
-    ctx.logger.info("keeping deferred parent idle notification - waiting for parent to resume", {
+  if (parentStatus !== "idle") {
+    if (parentStatus !== void 0) {
+      cancelDeferredParentConfirm(parentID);
+      ctx.sessionTitleService.clearDeferredIdleNotification(parentID);
+      ctx.logger.info("clearing deferred parent idle notification - parent resumed", {
+        sessionId: parentID
+      });
+    }
+    return;
+  }
+  scheduleDeferredParentConfirm(parentID, ctx);
+}
+function scheduleDeferredParentConfirm(parentID, ctx) {
+  if (deferredConfirmTimers.has(parentID)) return;
+  const delay = ctx.deferredConfirmDelayMs ?? DEFERRED_PARENT_CONFIRM_DELAY_MS;
+  const timer = setTimeout(() => {
+    deferredConfirmTimers.delete(parentID);
+    void confirmDeferredParentIdle(parentID, ctx);
+  }, delay);
+  timer.unref?.();
+  deferredConfirmTimers.set(parentID, timer);
+  ctx.logger.info("parent idle and descendants finished - confirming deferred notification", {
+    sessionId: parentID
+  });
+}
+async function confirmDeferredParentIdle(parentID, ctx) {
+  if (!ctx.sessionTitleService.hasDeferredIdleNotification(parentID)) return;
+  if (ctx.sessionTitleService.getSessionStatus(parentID) !== "idle") {
+    ctx.sessionTitleService.clearDeferredIdleNotification(parentID);
+    ctx.logger.info("clearing deferred parent idle notification - parent resumed during confirm", {
       sessionId: parentID
     });
     return;
   }
-  if (parentStatus !== void 0) {
-    ctx.sessionTitleService.clearDeferredIdleNotification(parentID);
-    ctx.logger.info("clearing deferred parent idle notification - parent resumed", {
+  await hydrateDescendants(parentID, ctx);
+  if (ctx.sessionTitleService.hasUnfinishedDescendants(parentID)) {
+    ctx.logger.info("keeping deferred parent idle notification - descendants active again", {
       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);
@@ -1989,7 +2068,7 @@ function createStatusDispatcher(deps) {
   return async ({ chatId, bot, args }) => {
     const rawN = args[0];
     if (rawN === void 0 || rawN === "") {
-      await bot.sendMessage("\uC0AC\uC6A9\uBC95: /status <\uBC88\uD638>. \uBA3C\uC800 /sessions \uB85C \uBAA9\uB85D \uD655\uC778", {
+      await bot.sendMessage("\uC0AC\uC6A9\uBC95: /status &lt;\uBC88\uD638&gt;. \uBA3C\uC800 /sessions \uB85C \uBAA9\uB85D \uD655\uC778", {
         parse_mode: "HTML"
       });
       return;
@@ -2031,7 +2110,11 @@ function createStatusDispatcher(deps) {
     let messages = [];
     if (sourceServerUrl && useRemoteServer) {
       try {
-        const getResult = await getRemoteSession(sourceServerUrl, entry.sessionId, deps.opencodeFetch);
+        const getResult = await getRemoteSession(
+          sourceServerUrl,
+          entry.sessionId,
+          deps.opencodeFetch
+        );
         session = getResult.data;
         responseStatus = getResult.response.status;
         if (!session || responseStatus === 404) {
@@ -2050,7 +2133,11 @@ function createStatusDispatcher(deps) {
         await bot.sendMessage("\uC138\uC158 \uC0C1\uD0DC\uB97C \uBD88\uB7EC\uC624\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. /sessions \uC7AC\uC2E4\uD589 \uD544\uC694", {
           parse_mode: "HTML"
         });
-        deps.logger.error("status remote lookup failed", { chatId, sessionId: entry.sessionId, error: String(err) });
+        deps.logger.error("status remote lookup failed", {
+          chatId,
+          sessionId: entry.sessionId,
+          error: String(err)
+        });
         return;
       }
     } else {
@@ -2285,7 +2372,7 @@ function loadPluginEnv(opts) {
 }
 
 // src/lib/lock.ts
-import { open as open2, readFile as readFile6, stat as stat3, unlink as unlink6 } from "fs/promises";
+import { open as open2, readFile as readFile6, stat as stat3, unlink as unlink6, utimes } from "fs/promises";
 import { hostname } from "os";
 var DEFAULT_TTL_MS2 = 5 * 60 * 1e3;
 function hasCode6(err, code) {
@@ -2331,6 +2418,18 @@ async function createLock(lockPath, pid) {
         await unlink6(lockPath);
       } catch {
       }
+    },
+    async refresh() {
+      if (released) return false;
+      try {
+        const data2 = parseLockData(await readFile6(lockPath, "utf8"));
+        if (!data2 || data2.pid !== pid || data2.hostname !== hostname()) return false;
+        const now = /* @__PURE__ */ new Date();
+        await utimes(lockPath, now, now);
+        return true;
+      } catch {
+        return false;
+      }
     }
   };
 }
@@ -2374,7 +2473,11 @@ async function acquireLock(opts) {
       try {
         await unlink6(opts.lockPath);
       } catch {
-        return { acquired: false, reason: "failed to remove stale lock", ownerPid: existing.ownerPid };
+        return {
+          acquired: false,
+          reason: "failed to remove stale lock",
+          ownerPid: existing.ownerPid
+        };
       }
     }
   }
@@ -2819,11 +2922,14 @@ var TelegramRemote = async (input) => {
     const pendingPermissions = createPendingPermissionStore({ tokenHash });
     const pendingStartWorks = createPendingStartWorkStore({ tokenHash });
     const lockResult = await acquireLock({ lockPath });
-    const isLeader = lockResult.acquired;
-    logger.info(
-      `lock ${isLeader ? "acquired - leader mode" : "held by other - pass-through mode"}`,
-      isLeader ? {} : { reason: lockResult.reason }
-    );
+    const leadership = { isLeader: false };
+    if (lockResult.acquired) {
+      leadership.isLeader = true;
+      leadership.handle = lockResult.handle;
+      logger.info("lock acquired - leader mode");
+    } else {
+      logger.info("lock held by other - pass-through mode", { reason: lockResult.reason });
+    }
     logger.info("server url", {
       url: input.serverUrl.toString(),
       href: input.serverUrl.href,
@@ -2888,21 +2994,57 @@ var TelegramRemote = async (input) => {
       config,
       stateStore,
       logger,
-      initialChatId: initialState.chatId ?? config.chatId,
-      polling: isLeader
+      initialChatId: initialState.chatId ?? config.chatId
     });
-    if (isLeader) {
-      bot.start().catch((err) => {
+    const startLeaderPolling = () => {
+      bot.start().catch(async (err) => {
         logger.error("bot polling stopped", { error: String(err) });
+        leadership.isLeader = false;
+        if (leadership.handle) {
+          await leadership.handle.release();
+          leadership.handle = void 0;
+        }
       });
-    }
+    };
+    let electionRunning = false;
+    const runElection = async () => {
+      if (electionRunning) return;
+      electionRunning = true;
+      try {
+        if (leadership.isLeader && leadership.handle) {
+          if (await leadership.handle.refresh()) return;
+          leadership.isLeader = false;
+          leadership.handle = void 0;
+          await bot.stop();
+          logger.info("leadership lost - demoted to pass-through");
+          return;
+        }
+        if (bot.isPolling()) return;
+        const result = await acquireLock({ lockPath });
+        if (result.acquired) {
+          leadership.isLeader = true;
+          leadership.handle = result.handle;
+          logger.info("leadership acquired - promoting to leader");
+          startLeaderPolling();
+        }
+      } catch (err) {
+        logger.warn("election cycle failed", { error: String(err) });
+      } finally {
+        electionRunning = false;
+      }
+    };
+    const electionTimer = setInterval(() => {
+      void runElection();
+    }, 3e4);
+    if (typeof electionTimer.unref === "function") electionTimer.unref();
     const cleanup = async () => {
+      clearInterval(electionTimer);
       try {
         await bot.stop();
       } catch {
       }
-      if (lockResult.acquired) {
-        await lockResult.handle.release();
+      if (leadership.handle) {
+        await leadership.handle.release();
       }
       await logger.close();
     };
@@ -2934,34 +3076,41 @@ var TelegramRemote = async (input) => {
       replyToPermission,
       runSessionCommand
     };
-    if (isLeader) {
-      bot.setQuestionDispatcher(createQuestionDispatcher(ctx));
-      bot.setPermissionDispatcher(createPermissionDispatcher(ctx));
-      bot.setStartWorkDispatcher(createStartWorkDispatcher(ctx));
-      bot.setSessionsDispatcher(createSessionsDispatcher({
+    bot.setQuestionDispatcher(createQuestionDispatcher(ctx));
+    bot.setPermissionDispatcher(createPermissionDispatcher(ctx));
+    bot.setStartWorkDispatcher(createStartWorkDispatcher(ctx));
+    bot.setSessionsDispatcher(
+      createSessionsDispatcher({
         client: input.client,
         sessionTitleService,
         sessionRegistry,
         snapshotStore,
         serverUrl: input.serverUrl.href,
         logger
-      }));
-      bot.setStatusDispatcher(createStatusDispatcher({
+      })
+    );
+    bot.setStatusDispatcher(
+      createStatusDispatcher({
         snapshotStore,
         sessionTitleService,
         client: input.client,
         logger,
         serverUrl: input.serverUrl.href
-      }));
-      bot.setStartWorkCommandDispatcher(createStartWorkCommandDispatcher({
+      })
+    );
+    bot.setStartWorkCommandDispatcher(
+      createStartWorkCommandDispatcher({
         snapshotStore,
         sessionTitleService,
         client: input.client,
         serverUrl: input.serverUrl.href,
         runSessionCommand,
         logger
-      }));
-      bot.setHelpDispatcher(createHelpDispatcher({ logger }));
+      })
+    );
+    bot.setHelpDispatcher(createHelpDispatcher({ logger }));
+    if (leadership.isLeader) {
+      startLeaderPolling();
     }
     return {
       event: async ({ event }) => {
@@ -3012,14 +3161,12 @@ var TelegramRemote = async (input) => {
               return;
             }
             if (isEventPermissionAsked(extEvent)) {
-              if (!isLeader) return;
               return handlePermissionAsked(extEvent, ctx);
             }
             if (isEventSessionError(extEvent)) {
               return handleSessionError(extEvent, ctx);
             }
             if (isEventQuestionAsked(extEvent)) {
-              if (!isLeader) return;
               return handleQuestionAsked(extEvent, ctx);
             }
             if (isEventQuestionReplied(extEvent)) {

package/package.json

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