@coinseeker/opencode-telegram-plugin 1.1.0 → 1.1.2

package/README.md

@@ -15,14 +15,16 @@ Configure the npm package in `~/.config/opencode/opencode.json`:
 
 ```json
 {
-  "plugin": ["@coinseeker/opencode-telegram-plugin@1.1.0"]
+  "plugin": ["@coinseeker/opencode-telegram-plugin@1.1.2"]
 }
 ```
 
-Current stable version: `@coinseeker/opencode-telegram-plugin@1.1.0`.
+Current stable version: `@coinseeker/opencode-telegram-plugin@1.1.2`.
 
 Restart OpenCode after editing the config. OpenCode resolves npm package plugins on startup.
 
+To update an existing install, replace the previous pinned package entry with `@coinseeker/opencode-telegram-plugin@1.1.2`, keep the rest of the `plugin` array unchanged, and restart OpenCode.
+
 ## Configure Telegram
 
 Create `~/.config/opencode/telegram-remote/.env`:

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,6 @@ 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;
@@ -977,10 +999,6 @@ 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) {
@@ -1004,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);
   }
@@ -1476,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 });
@@ -1493,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 {
@@ -1527,7 +1560,7 @@ 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));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function agentFinishedMessage(title, agent) {
   const base = title ? `Agent has finished: ${title}` : "Agent has finished.";
@@ -1880,48 +1913,170 @@ ${body}
 
 // src/lib/plan-readiness.ts
 import { access, readFile as readFile5, readdir as readdir6, stat as stat2 } from "fs/promises";
-import { join as join6 } from "path";
-async function checkPlanReadiness(args) {
-  const { projectRoot } = args;
-  const omoDir = join6(projectRoot, ".omo");
-  const plansDir = join6(omoDir, "plans");
-  const boulderPath = join6(omoDir, "boulder.json");
+import { basename, isAbsolute, join as join6, relative, resolve } from "path";
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeBoulderWork(value) {
+  const record = asRecord2(value);
+  if (!record || typeof record.active_plan !== "string") return void 0;
+  const work = {
+    activePlan: record.active_plan,
+    sessionIds: stringArray(record.session_ids)
+  };
+  const planName = optionalString(record.plan_name);
+  if (planName !== void 0) work.planName = planName;
+  const status = optionalString(record.status);
+  if (status !== void 0) work.status = status;
+  const startedAt = optionalString(record.started_at);
+  if (startedAt !== void 0) work.startedAt = startedAt;
+  const updatedAt = optionalString(record.updated_at);
+  if (updatedAt !== void 0) work.updatedAt = updatedAt;
+  const worktreePath = optionalString(record.worktree_path);
+  if (worktreePath !== void 0) work.worktreePath = worktreePath;
+  return work;
+}
+function normalizeBoulderState(value) {
+  const record = asRecord2(value);
+  if (!record) return void 0;
+  const state = { sessionIds: stringArray(record.session_ids) };
+  const activePlan = optionalString(record.active_plan);
+  if (activePlan !== void 0) state.activePlan = activePlan;
+  const planName = optionalString(record.plan_name);
+  if (planName !== void 0) state.planName = planName;
+  const status = optionalString(record.status);
+  if (status !== void 0) state.status = status;
+  const startedAt = optionalString(record.started_at);
+  if (startedAt !== void 0) state.startedAt = startedAt;
+  const updatedAt = optionalString(record.updated_at);
+  if (updatedAt !== void 0) state.updatedAt = updatedAt;
+  const worktreePath = optionalString(record.worktree_path);
+  if (worktreePath !== void 0) state.worktreePath = worktreePath;
+  const activeWorkId = optionalString(record.active_work_id);
+  if (activeWorkId !== void 0) state.activeWorkId = activeWorkId;
+  const worksRecord = asRecord2(record.works);
+  if (worksRecord) {
+    const works = {};
+    for (const [workId, rawWork] of Object.entries(worksRecord)) {
+      const work = normalizeBoulderWork(rawWork);
+      if (work) works[workId] = work;
+    }
+    if (Object.keys(works).length > 0) state.works = works;
+  }
+  return state;
+}
+async function readBoulderState(boulderPath) {
+  let text;
   try {
-    await access(omoDir);
+    text = await readFile5(boulderPath, "utf8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return { exists: false };
+    }
+    return { exists: true };
+  }
+  try {
+    return { exists: true, state: normalizeBoulderState(JSON.parse(text)) };
   } catch {
-    return {
-      ready: false,
-      reason: "no-omo-dir",
-      detail: `${omoDir} does not exist`
-    };
+    return { exists: true };
+  }
+}
+function mirrorWorkFromState(state) {
+  if (!state.activePlan) return void 0;
+  const work = {
+    activePlan: state.activePlan,
+    sessionIds: state.sessionIds
+  };
+  if (state.planName !== void 0) work.planName = state.planName;
+  if (state.status !== void 0) work.status = state.status;
+  if (state.startedAt !== void 0) work.startedAt = state.startedAt;
+  if (state.updatedAt !== void 0) work.updatedAt = state.updatedAt;
+  if (state.worktreePath !== void 0) work.worktreePath = state.worktreePath;
+  return work;
+}
+function boulderWorks(state) {
+  if (state.works) return Object.values(state.works);
+  const mirrorWork = mirrorWorkFromState(state);
+  return mirrorWork ? [mirrorWork] : [];
+}
+function parseIsoToMs(value) {
+  if (!value) return 0;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? 0 : ms;
+}
+function findBoulderWorkForSession(state, sessionId) {
+  const works = boulderWorks(state).filter((work) => work.sessionIds.includes(sessionId)).sort(
+    (left, right) => parseIsoToMs(right.updatedAt ?? right.startedAt) - parseIsoToMs(left.updatedAt ?? left.startedAt)
+  );
+  if (works[0]) return works[0];
+  const mirrorWork = mirrorWorkFromState(state);
+  if (mirrorWork && state.sessionIds.includes(sessionId)) return mirrorWork;
+  return void 0;
+}
+function isActiveBoulderWork(work) {
+  return work.status !== "completed" && work.status !== "abandoned";
+}
+function resolveTrackedPath(baseDirectory, trackedPath) {
+  return isAbsolute(trackedPath) ? resolve(trackedPath) : resolve(baseDirectory, trackedPath);
+}
+async function resolveBoulderPlanPath(projectRoot, work) {
+  const absolutePlanPath = resolveTrackedPath(projectRoot, work.activePlan);
+  const worktreePath = work.worktreePath?.trim();
+  if (!worktreePath) return absolutePlanPath;
+  const relativePlanPath = relative(resolve(projectRoot), absolutePlanPath);
+  if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute(relativePlanPath)) {
+    return absolutePlanPath;
   }
+  const worktreePlanPath = resolve(resolveTrackedPath(projectRoot, worktreePath), relativePlanPath);
   try {
-    await access(boulderPath);
-    return {
-      ready: false,
-      reason: "boulder-active",
-      detail: `${boulderPath} exists`
-    };
+    await access(worktreePlanPath);
+    return worktreePlanPath;
   } catch {
+    return absolutePlanPath;
+  }
+}
+function planNameFromPath(planPath) {
+  return basename(planPath, ".md");
+}
+function normalizePlanToken(value) {
+  return value.normalize("NFKD").toLowerCase().replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9가-힣]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function selectPlanByHint(candidates, planHint) {
+  if (!planHint) return void 0;
+  const normalizedHint = normalizePlanToken(planHint);
+  if (!normalizedHint) return void 0;
+  return candidates.find((candidate) => {
+    const planName = candidate.name.replace(/\.md$/, "");
+    return normalizePlanToken(planName) === normalizedHint;
+  });
+}
+function resolvePlanPathHint(projectRoot, planPath) {
+  if (!planPath) return void 0;
+  const resolvedPath = isAbsolute(planPath) ? resolve(planPath) : resolve(projectRoot, planPath);
+  const plansRoot = resolve(projectRoot, ".omo", "plans");
+  const relativePlanPath = relative(plansRoot, resolvedPath);
+  if (!resolvedPath.endsWith(".md") || relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute(relativePlanPath)) {
+    return void 0;
   }
+  return resolvedPath;
+}
+async function getPlanFiles(plansDir) {
   let planFiles = [];
   try {
     const entries = await readdir6(plansDir);
     planFiles = entries.filter((e) => e.endsWith(".md"));
   } catch {
-    return {
-      ready: false,
-      reason: "no-plans",
-      detail: `${plansDir} not found or empty`
-    };
-  }
-  if (planFiles.length === 0) {
-    return {
-      ready: false,
-      reason: "no-plans",
-      detail: `No .md files in ${plansDir}`
-    };
+    return void 0;
   }
+  if (planFiles.length === 0) return [];
   const stats = await Promise.all(
     planFiles.map(async (f) => {
       const full = join6(plansDir, f);
@@ -1929,9 +2084,20 @@ async function checkPlanReadiness(args) {
       return { path: full, name: f, mtime: s.mtime.getTime() };
     })
   );
-  stats.sort((a, b) => b.mtime - a.mtime);
-  const latest = stats[0];
-  const content = await readFile5(latest.path, "utf8");
+  return stats.sort((a, b) => b.mtime - a.mtime);
+}
+async function readPlanProgress(planPath, planName, boulderActive = false) {
+  let content;
+  try {
+    content = await readFile5(planPath, "utf8");
+  } catch {
+    return {
+      ready: false,
+      reason: "no-plans",
+      detail: `${planPath} not found`,
+      ...boulderActive ? { boulderActive } : {}
+    };
+  }
   const totalMatches = content.match(/^- \[[ xX]\]/gm) ?? [];
   const completedMatches = content.match(/^- \[[xX]\]/gm) ?? [];
   const total = totalMatches.length;
@@ -1940,24 +2106,99 @@ async function checkPlanReadiness(args) {
     return {
       ready: false,
       reason: "plan-empty",
-      detail: `${latest.name}: no checkboxes found`
+      detail: `${planName}: no checkboxes found`,
+      ...boulderActive ? { boulderActive } : {}
     };
   }
   if (completed >= total) {
     return {
       ready: false,
       reason: "all-plans-complete",
-      detail: `${latest.name}: ${completed}/${total} complete`
+      detail: `${planName}: ${completed}/${total} complete`,
+      ...boulderActive ? { boulderActive } : {}
     };
   }
   return {
     ready: true,
-    planPath: latest.path,
-    planName: latest.name.replace(/\.md$/, ""),
+    planPath,
+    planName,
     total,
-    completed
+    completed,
+    ...boulderActive ? { boulderActive } : {}
   };
 }
+async function checkPlanReadiness(args) {
+  const { projectRoot, sessionId } = args;
+  const allowLatestFallback = args.allowLatestFallback ?? sessionId === void 0;
+  const omoDir = join6(projectRoot, ".omo");
+  const plansDir = join6(omoDir, "plans");
+  const boulderPath = join6(omoDir, "boulder.json");
+  try {
+    await access(omoDir);
+  } catch {
+    return {
+      ready: false,
+      reason: "no-omo-dir",
+      detail: `${omoDir} does not exist`
+    };
+  }
+  const boulder = await readBoulderState(boulderPath);
+  const projectBoulderActive = boulder.exists;
+  if (boulder.exists && sessionId === void 0) {
+    return {
+      ready: false,
+      reason: "boulder-active",
+      detail: `${boulderPath} exists`,
+      boulderActive: true
+    };
+  }
+  if (boulder.state && sessionId !== void 0) {
+    const work = findBoulderWorkForSession(boulder.state, sessionId);
+    if (work) {
+      const planPath = await resolveBoulderPlanPath(projectRoot, work);
+      return readPlanProgress(
+        planPath,
+        work.planName ?? planNameFromPath(planPath),
+        isActiveBoulderWork(work)
+      );
+    }
+  }
+  const explicitPlanPath = resolvePlanPathHint(projectRoot, args.planPath);
+  if (explicitPlanPath) {
+    return readPlanProgress(explicitPlanPath, planNameFromPath(explicitPlanPath), projectBoulderActive);
+  }
+  const stats = await getPlanFiles(plansDir);
+  if (stats === void 0) {
+    return {
+      ready: false,
+      reason: "no-plans",
+      detail: `${plansDir} not found or empty`,
+      ...projectBoulderActive ? { boulderActive: true } : {}
+    };
+  }
+  if (stats.length === 0) {
+    return {
+      ready: false,
+      reason: "no-plans",
+      detail: `No .md files in ${plansDir}`,
+      ...projectBoulderActive ? { boulderActive: true } : {}
+    };
+  }
+  const hinted = selectPlanByHint(stats, args.planHint);
+  if (hinted) {
+    return readPlanProgress(hinted.path, hinted.name.replace(/\.md$/, ""), projectBoulderActive);
+  }
+  if (!allowLatestFallback) {
+    return {
+      ready: false,
+      reason: "no-session-plan",
+      detail: `No plan associated with session ${sessionId ?? "missing"}`,
+      ...projectBoulderActive ? { boulderActive: true } : {}
+    };
+  }
+  const latest = stats[0];
+  return readPlanProgress(latest.path, latest.name.replace(/\.md$/, ""), projectBoulderActive);
+}
 async function recheckSessionIdle(client, sessionId) {
   const result = await client.session.status();
   const statuses = result.data ?? {};
@@ -2019,6 +2260,8 @@ function planReadinessKorean(result) {
     }
     case "boulder-active":
       return "boulder \uD65C\uC131";
+    case "no-session-plan":
+      return "\uC138\uC158 \uC5F0\uACB0 plan \uC5C6\uC74C";
   }
 }
 function planLine(result) {
@@ -2028,14 +2271,14 @@ function planLine(result) {
   return `<b>\uD50C\uB79C \uC0C1\uD0DC</b>: ${planReadinessKorean(result)}`;
 }
 function boulderLine(result) {
-  const active = !result.ready && result.reason === "boulder-active";
+  const active = result.boulderActive === true || !result.ready && result.reason === "boulder-active";
   return active ? "<b>Boulder</b>: \uD65C\uC131" : "<b>Boulder</b>: \uC5C6\uC74C";
 }
 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;
@@ -2077,7 +2320,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) {
@@ -2096,7 +2343,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 {
@@ -2121,11 +2372,18 @@ function createStatusDispatcher(deps) {
       return;
     }
     const projectRoot = resolveProjectRoot(session);
-    const planReady = await checkPlanReadiness({ projectRoot });
+    const rawTitle = session.title ?? entry.title;
+    const rawAgent = entry.agent ?? session.agent;
+    const planReady = await checkPlanReadiness({
+      projectRoot,
+      sessionId: entry.sessionId,
+      planHint: rawTitle,
+      allowLatestFallback: rawAgent === "plan"
+    });
     const userSnippet = buildSnippet(findLastByRole(messages, "user"));
     const assistantSnippet = buildSnippet(findLastByRole(messages, "assistant"));
-    const title = escapeHtml(session.title ?? "");
-    const agent = entry.agent ? escapeHtml(entry.agent) : "?";
+    const title = escapeHtml(rawTitle ?? "");
+    const agent = rawAgent ? escapeHtml(rawAgent) : "?";
     const text = [
       `<b>\uC138\uC158 #${n}</b>: ${title}`,
       `\uC5D0\uC774\uC804\uD2B8: ${agent}`,
@@ -2167,6 +2425,8 @@ function readinessMessage(reason) {
       return "plan \uC758 \uBAA8\uB4E0 task \uAC00 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uC0C8 plan \uC791\uC131 \uD544\uC694";
     case "boulder-active":
       return ".omo/boulder.json \uC774 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4. \uAE30\uC874 \uC791\uC5C5\uC774 \uC9C4\uD589 \uC911\uC774\uAC70\uB098 archive \uAC00 \uD544\uC694\uD569\uB2C8\uB2E4";
+    case "no-session-plan":
+      return "\uD574\uB2F9 \uC138\uC158\uACFC \uC5F0\uACB0\uB41C plan \uC774 \uC5C6\uC2B5\uB2C8\uB2E4";
   }
 }
 function isSessionNotFoundError(err) {
@@ -2331,7 +2591,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) {
@@ -2377,6 +2637,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;
+      }
     }
   };
 }
@@ -2420,7 +2692,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
+        };
       }
     }
   }
@@ -2865,11 +3141,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,
@@ -2934,21 +3213,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();
     };
@@ -2980,34 +3295,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 }) => {
@@ -3058,14 +3380,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.1.0",
+  "version": "1.1.2",
   "description": "Control and monitor OpenCode from Telegram with notifications, question replies, and subagent-aware completion.",
   "type": "module",
   "main": "dist/telegram-remote.js",