@coinseeker/opencode-telegram-plugin 1.0.12 → 1.0.14

package/dist/telegram-remote.js

@@ -5,8 +5,8 @@
 
 // src/telegram-remote.ts
 import { createHash as createHash5 } from "crypto";
-import { tmpdir as tmpdir5 } from "os";
-import { dirname as dirname5, join as join7 } from "path";
+import { homedir as homedir3, tmpdir as tmpdir5 } from "os";
+import { dirname as dirname6, join as join10 } from "path";
 import { fileURLToPath } from "url";
 
 // src/bot.ts
@@ -46,6 +46,11 @@ function createTelegramBot(opts) {
   let questionDispatcher;
   let permissionDispatcher;
   let startWorkDispatcher;
+  let sessionsDispatcher;
+  let statusDispatcher;
+  let startWorkCommandDispatcher;
+  let helpDispatcher;
+  let managerObj;
   if (polling) {
     bot.use(async (ctx, next) => {
       const userId = ctx.from?.id;
@@ -105,6 +110,36 @@ This chat is now active for OpenCode notifications.`
       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;
@@ -122,12 +157,22 @@ This chat is now active for OpenCode notifications.`
     }
     throw new Error(`No active chat for ${action}. Send any message to the bot first.`);
   };
-  return {
+  managerObj = {
     async start() {
       if (!polling) {
         logger.info("pass-through mode - skipping bot.start()");
         return;
       }
+      try {
+        await bot.api.setMyCommands([
+          { command: "sessions", description: "\uD65C\uC131 \uC138\uC158 \uBAA9\uB85D (top 20)" },
+          { command: "status", description: "\uC138\uC158 \uC0C1\uD0DC \uC870\uD68C (/status N)" },
+          { command: "start_work", description: "plan-ready \uC138\uC158 \uC2E4\uD589 (/start_work N)" },
+          { command: "help", description: "\uBA85\uB839 \uB3C4\uC6C0\uB9D0" }
+        ]);
+      } catch (err) {
+        logger.warn("setMyCommands failed", { error: String(err) });
+      }
       await bot.start({
         drop_pending_updates: true,
         onStart: () => {
@@ -201,8 +246,21 @@ This chat is now active for OpenCode notifications.`
     },
     setStartWorkDispatcher(dispatcher) {
       startWorkDispatcher = dispatcher;
+    },
+    setSessionsDispatcher(dispatcher) {
+      sessionsDispatcher = dispatcher;
+    },
+    setStatusDispatcher(dispatcher) {
+      statusDispatcher = dispatcher;
+    },
+    setStartWorkCommandDispatcher(dispatcher) {
+      startWorkCommandDispatcher = dispatcher;
+    },
+    setHelpDispatcher(dispatcher) {
+      helpDispatcher = dispatcher;
     }
   };
+  return managerObj;
 }
 
 // src/config.ts
@@ -959,9 +1017,313 @@ async function handleQuestionReplied(event, ctx) {
   }
 }
 
+// src/lib/session-registry.ts
+import { chmod, mkdir as mkdir4, readFile as readFile3, readdir as readdir4, rename as rename3, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/lib/opencode-http.ts
+var ALLOWED_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1", "[::1]"]);
+function asRecord(value) {
+  if (!value || typeof value !== "object") return void 0;
+  return value;
+}
+function isStatusType(value) {
+  return value === "idle" || value === "busy" || value === "retry";
+}
+function normalizeOpenCodeServerUrl(value) {
+  if (!value) return void 0;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    if (url.username || url.password) return void 0;
+    if (url.search || url.hash) return void 0;
+    if (url.pathname !== "/" && url.pathname !== "") return void 0;
+    if (!ALLOWED_HOSTNAMES.has(url.hostname)) return void 0;
+    return url.href;
+  } catch {
+    return void 0;
+  }
+}
+function requireOpenCodeServerUrl(serverUrl) {
+  const normalized = normalizeOpenCodeServerUrl(serverUrl);
+  if (!normalized) throw new Error("Invalid OpenCode server URL");
+  return normalized;
+}
+function endpoint(serverUrl, path) {
+  return new URL(path, requireOpenCodeServerUrl(serverUrl));
+}
+function isDifferentServerUrl(sourceServerUrl, currentServerUrl) {
+  const source = normalizeOpenCodeServerUrl(sourceServerUrl);
+  const current = normalizeOpenCodeServerUrl(currentServerUrl);
+  if (!source || !current) return false;
+  return source !== current;
+}
+function normalizeSession(value) {
+  const record = asRecord(value);
+  if (!record || typeof record.directory !== "string") return void 0;
+  const session = { directory: record.directory };
+  if (typeof record.id === "string") session.id = record.id;
+  if (typeof record.title === "string") session.title = record.title;
+  if (typeof record.parentID === "string" || record.parentID === null) {
+    session.parentID = record.parentID;
+  }
+  if (typeof record.agent === "string") session.agent = record.agent;
+  return session;
+}
+function normalizeSessionList(value) {
+  if (!Array.isArray(value)) return [];
+  const sessions = [];
+  for (const raw of value) {
+    const record = asRecord(raw);
+    const time = asRecord(record?.time);
+    if (!record) continue;
+    if (typeof record.id !== "string") continue;
+    if (typeof record.title !== "string") continue;
+    if (!time || typeof time.updated !== "number") continue;
+    const session = {
+      id: record.id,
+      title: record.title,
+      time: { updated: time.updated }
+    };
+    if (typeof record.parentID === "string" || record.parentID === null) {
+      session.parentID = record.parentID;
+    }
+    if (typeof record.agent === "string") session.agent = record.agent;
+    sessions.push(session);
+  }
+  return sessions;
+}
+function normalizeStatusMap(value) {
+  const record = asRecord(value);
+  if (!record) return {};
+  const out = {};
+  for (const [sessionId, rawStatus] of Object.entries(record)) {
+    const status = asRecord(rawStatus);
+    if (status && isStatusType(status.type)) out[sessionId] = { type: status.type };
+  }
+  return out;
+}
+function normalizeMessages(value) {
+  if (!Array.isArray(value)) return [];
+  const messages = [];
+  for (const rawMessage of value) {
+    const message = asRecord(rawMessage);
+    const info = asRecord(message?.info);
+    if (!message || !info || typeof info.role !== "string" || !Array.isArray(message.parts)) continue;
+    const parts = [];
+    for (const rawPart of message.parts) {
+      const part = asRecord(rawPart);
+      if (!part || typeof part.type !== "string") continue;
+      const normalized = { type: part.type };
+      if (typeof part.text === "string") normalized.text = part.text;
+      parts.push(normalized);
+    }
+    messages.push({ info: { role: info.role }, parts });
+  }
+  return messages;
+}
+async function fetchJson(serverUrl, path, fetcher) {
+  const response = await fetcher(endpoint(serverUrl, path), { redirect: "error" });
+  if (response.status === 404) return { data: void 0, response: { status: response.status } };
+  if (!response.ok) {
+    throw new Error(`OpenCode request failed: ${response.status} ${response.statusText}`);
+  }
+  return { data: await response.json(), response: { status: response.status } };
+}
+async function getRemoteSession(serverUrl, sessionId, fetcher = fetch) {
+  const result = await fetchJson(serverUrl, `/session/${encodeURIComponent(sessionId)}`, fetcher);
+  return { data: normalizeSession(result.data), response: result.response };
+}
+async function getRemoteStatusMap(serverUrl, fetcher = fetch) {
+  const result = await fetchJson(serverUrl, "/session/status", fetcher);
+  return normalizeStatusMap(result.data);
+}
+async function getRemoteSessions(serverUrl, fetcher = fetch) {
+  const result = await fetchJson(serverUrl, "/session", fetcher);
+  return normalizeSessionList(result.data);
+}
+async function getRemoteMessages(serverUrl, sessionId, limit, fetcher = fetch) {
+  const url = endpoint(serverUrl, `/session/${encodeURIComponent(sessionId)}/message`);
+  url.searchParams.set("limit", String(limit));
+  const response = await fetcher(url, { redirect: "error" });
+  if (response.status === 404) return [];
+  if (!response.ok) {
+    throw new Error(`OpenCode request failed: ${response.status} ${response.statusText}`);
+  }
+  return normalizeMessages(await response.json());
+}
+
+// src/lib/session-registry.ts
+function filenameForSession(sessionId) {
+  return Buffer.from(sessionId).toString("base64url") + ".json";
+}
+function hasCode4(err, code) {
+  return err instanceof Error && "code" in err && err.code === code;
+}
+function normalizeEntry(entry) {
+  const serverUrl = normalizeOpenCodeServerUrl(entry.serverUrl);
+  if (!serverUrl) throw new Error("invalid registry serverUrl");
+  const out = {
+    sessionId: entry.sessionId,
+    title: entry.title,
+    parentID: entry.parentID,
+    serverUrl,
+    updatedAt: entry.updatedAt
+  };
+  if (entry.agent !== void 0) out.agent = entry.agent;
+  if (entry.status !== void 0) out.status = entry.status;
+  return out;
+}
+function isRegistryFile(value) {
+  if (!value || typeof value !== "object") return false;
+  const file = value;
+  if (file.version !== 1) return false;
+  const entry = file.entry;
+  if (!entry || typeof entry !== "object") return false;
+  const e = entry;
+  if (typeof e.sessionId !== "string") return false;
+  if (typeof e.title !== "string") return false;
+  if (e.parentID !== null && typeof e.parentID !== "string") return false;
+  if (e.agent !== void 0 && typeof e.agent !== "string") return false;
+  if (e.status !== void 0 && e.status !== "idle" && e.status !== "busy" && e.status !== "retry") {
+    return false;
+  }
+  if (typeof e.serverUrl !== "string") return false;
+  if (!normalizeOpenCodeServerUrl(e.serverUrl)) return false;
+  if (typeof e.updatedAt !== "number") return false;
+  return true;
+}
+function agentFromSession(session) {
+  const candidate = session;
+  return typeof candidate.agent === "string" ? candidate.agent : void 0;
+}
+function registryEntryFromSession(session, serverUrl, status) {
+  const entry = {
+    sessionId: session.id,
+    title: session.title,
+    parentID: session.parentID ?? null,
+    serverUrl,
+    updatedAt: session.time.updated
+  };
+  const agent = agentFromSession(session);
+  if (agent !== void 0) entry.agent = agent;
+  if (status !== void 0) entry.status = status;
+  return entry;
+}
+function createSessionRegistryStore(opts) {
+  const registryDir = join4(opts.configDir, "session-registry", opts.tokenHash);
+  function filePath(sessionId) {
+    return join4(registryDir, filenameForSession(sessionId));
+  }
+  async function readEntry(sessionId) {
+    let text;
+    try {
+      text = await readFile3(filePath(sessionId), "utf8");
+    } catch (err) {
+      if (hasCode4(err, "ENOENT")) return null;
+      opts.logger.error("session-registry: failed to read file", {
+        sessionId,
+        error: String(err)
+      });
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(text);
+      if (!isRegistryFile(parsed)) return null;
+      return normalizeEntry(parsed.entry);
+    } catch (err) {
+      opts.logger.error("session-registry: corrupted JSON", { sessionId, error: String(err) });
+      return null;
+    }
+  }
+  async function writeEntry(entry) {
+    await mkdir4(registryDir, { recursive: true });
+    try {
+      await chmod(registryDir, 448);
+    } catch (err) {
+      opts.logger.error("session-registry: failed to chmod dir", { error: String(err) });
+    }
+    const payload = { version: 1, entry: normalizeEntry(entry) };
+    const target = filePath(entry.sessionId);
+    const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
+    await writeFile3(tmp, JSON.stringify(payload, null, 2), "utf8");
+    try {
+      await rename3(tmp, target);
+    } catch (err) {
+      try {
+        await unlink4(tmp);
+      } catch {
+      }
+      throw err;
+    }
+    await chmod(target, 384);
+  }
+  async function upsertSession(entry) {
+    const existing = await readEntry(entry.sessionId);
+    await writeEntry({
+      ...existing,
+      ...entry,
+      agent: entry.agent ?? existing?.agent,
+      status: entry.status ?? existing?.status
+    });
+  }
+  async function updateSession(sessionId, patch) {
+    const existing = await readEntry(sessionId);
+    if (!existing) return;
+    await writeEntry({
+      ...existing,
+      ...patch,
+      sessionId,
+      title: patch.title ?? existing.title,
+      parentID: patch.parentID ?? existing.parentID,
+      serverUrl: patch.serverUrl ?? existing.serverUrl,
+      updatedAt: patch.updatedAt ?? Date.now()
+    });
+  }
+  async function listSessions() {
+    let names;
+    try {
+      names = await readdir4(registryDir);
+    } catch (err) {
+      if (hasCode4(err, "ENOENT")) return [];
+      opts.logger.error("session-registry: failed to list dir", { error: String(err) });
+      return [];
+    }
+    const entries = [];
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      let text;
+      try {
+        text = await readFile3(join4(registryDir, name), "utf8");
+      } catch (err) {
+        opts.logger.error("session-registry: failed to read listed file", {
+          file: name,
+          error: String(err)
+        });
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(text);
+        if (isRegistryFile(parsed)) entries.push(normalizeEntry(parsed.entry));
+      } catch (err) {
+        opts.logger.error("session-registry: corrupted listed file", {
+          file: name,
+          error: String(err)
+        });
+      }
+    }
+    return entries;
+  }
+  return { upsertSession, updateSession, listSessions };
+}
+
 // src/events/session-created.ts
 async function handleSessionCreated(event, ctx) {
-  ctx.sessionTitleService.setSessionInfo(event.properties.info);
+  const info = event.properties.info;
+  ctx.sessionTitleService.setSessionInfo(info);
+  await ctx.sessionRegistry.upsertSession(
+    registryEntryFromSession(info, ctx.serverUrl.href, ctx.sessionTitleService.getSessionStatus(info.id))
+  );
 }
 
 // src/lib/abort-tracker.ts
@@ -1003,14 +1365,14 @@ async function handleSessionError(event, ctx) {
 
 // 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 { mkdir as mkdir5, readdir as readdir5, readFile as readFile4, rename as rename4, unlink as unlink5, writeFile as writeFile4 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
-function hasCode4(err, code) {
+import { dirname as dirname3, join as join5 } from "path";
+function hasCode5(err, code) {
   return "code" in err && err.code === code;
 }
 function pendingFilePath3(dir, shortHash) {
-  return join4(dir, `${shortHash}.json`);
+  return join5(dir, `${shortHash}.json`);
 }
 function parsePending3(text) {
   const parsed = JSON.parse(text);
@@ -1029,10 +1391,10 @@ function parsePending3(text) {
 }
 async function listPendingFiles3(dir) {
   try {
-    const entries = await readdir4(dir, { withFileTypes: true });
+    const entries = await readdir5(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 [];
+    if (err instanceof Error && hasCode5(err, "ENOENT")) return [];
     throw err;
   }
 }
@@ -1040,29 +1402,29 @@ 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}`);
+  const dir = opts.baseDir ?? join5(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 });
+      await mkdir5(dirname3(filePath), { recursive: true });
       const tmpPath = `${filePath}.tmp.${process.pid}`;
-      await writeFile3(tmpPath, JSON.stringify(data, null, 2), "utf8");
-      await rename3(tmpPath, filePath);
+      await writeFile4(tmpPath, JSON.stringify(data, null, 2), "utf8");
+      await rename4(tmpPath, filePath);
     },
     async loadPending(shortHash) {
       try {
-        return parsePending3(await readFile3(pendingFilePath3(dir, shortHash), "utf8"));
+        return parsePending3(await readFile4(pendingFilePath3(dir, shortHash), "utf8"));
       } catch (err) {
-        if (err instanceof Error && hasCode4(err, "ENOENT")) return void 0;
+        if (err instanceof Error && hasCode5(err, "ENOENT")) return void 0;
         throw err;
       }
     },
     async deletePending(shortHash) {
       try {
-        await unlink4(pendingFilePath3(dir, shortHash));
+        await unlink5(pendingFilePath3(dir, shortHash));
       } catch (err) {
-        if (!(err instanceof Error) || !hasCode4(err, "ENOENT")) throw err;
+        if (!(err instanceof Error) || !hasCode5(err, "ENOENT")) throw err;
       }
     },
     async sweepExpired() {
@@ -1170,6 +1532,13 @@ async function resolveParentID(sessionId, ctx) {
     const result = await ctx.client.session.get({ path: { id: sessionId } });
     if (result.data) {
       ctx.sessionTitleService.setSessionInfo(result.data);
+      await ctx.sessionRegistry.upsertSession(
+        registryEntryFromSession(
+          result.data,
+          ctx.serverUrl.href,
+          ctx.sessionTitleService.getSessionStatus(sessionId)
+        )
+      );
       return ctx.sessionTitleService.getParentID(sessionId);
     }
     ctx.logger.warn("session parentID cache miss fetch returned no data", { sessionId });
@@ -1186,6 +1555,9 @@ async function hydrateDescendants(sessionId, ctx, seen = /* @__PURE__ */ new Set
     const result = await ctx.client.session.children({ path: { id: sessionId } });
     for (const child of result.data ?? []) {
       ctx.sessionTitleService.setSessionInfo(child);
+      await ctx.sessionRegistry.upsertSession(
+        registryEntryFromSession(child, ctx.serverUrl.href, ctx.sessionTitleService.getSessionStatus(child.id))
+      );
       await hydrateDescendants(child.id, ctx, seen);
     }
   } catch (err) {
@@ -1255,6 +1627,7 @@ async function handleSessionIdle(event, ctx) {
   const sessionId = event.properties.sessionID;
   const parentID = await resolveParentID(sessionId, ctx);
   ctx.sessionTitleService.setSessionStatus(sessionId, "idle");
+  await ctx.sessionRegistry.updateSession(sessionId, { status: "idle", updatedAt: Date.now() });
   if (typeof parentID === "string") {
     ctx.logger.info("suppressing child session idle notification", { sessionId, parentID });
     await flushDeferredParentIfReady(parentID, ctx);
@@ -1281,9 +1654,14 @@ async function handleSessionIdle(event, ctx) {
 async function handleSessionStatus(event, ctx) {
   const sessionId = event.properties.sessionID;
   const statusType = event.properties.status.type;
+  const previousStatus = ctx.sessionTitleService.getSessionStatus(sessionId);
   ctx.sessionTitleService.setSessionStatus(sessionId, statusType);
   if (statusType === "idle") {
     await handleSessionIdle(event, ctx);
+    return;
+  }
+  if (previousStatus !== statusType) {
+    await ctx.sessionRegistry.updateSession(sessionId, { status: statusType, updatedAt: Date.now() });
   }
 }
 
@@ -1291,19 +1669,605 @@ async function handleSessionStatus(event, ctx) {
 async function handleSessionUpdated(event, ctx) {
   const info = event.properties.info;
   ctx.sessionTitleService.setSessionInfo(info);
+  await ctx.sessionRegistry.upsertSession(
+    registryEntryFromSession(info, ctx.serverUrl.href, ctx.sessionTitleService.getSessionStatus(info.id))
+  );
+}
+
+// src/lib/html-escape.ts
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function truncateForTelegram(input, maxChars, ellipsis = "\u2026") {
+  const single = input.replace(/\s+/g, " ").trim();
+  if (single.length <= maxChars) return single;
+  if (maxChars <= 0) return "";
+  if (ellipsis.length >= maxChars) return ellipsis.slice(0, maxChars);
+  return single.slice(0, maxChars - ellipsis.length) + ellipsis;
+}
+function stripCodeFences(input) {
+  return input.replace(/```[^\r\n`]*\r?\n([\s\S]*?)```/g, "$1").replace(/```([\s\S]*?)```/g, "$1").replace(/`([^`]*)`/g, "$1").replace(/\s+/g, " ").trim();
+}
+
+// src/events/sessions-command.ts
+var MAX_BODY_CHARS = 3900;
+var MAX_TITLE_CHARS = 55;
+var MAX_SESSIONS = 20;
+function agentFromSession2(session) {
+  const candidate = session;
+  return typeof candidate.agent === "string" ? candidate.agent : void 0;
+}
+function isRootSession(session) {
+  return session.parentID === void 0 || session.parentID === null;
+}
+function isRootRegistryEntry(entry) {
+  return entry.parentID === null;
+}
+function isRootRemoteSession(session) {
+  return session.parentID === void 0 || session.parentID === null;
+}
+function addRegistryRecord(combined, entry, status) {
+  combined.set(entry.sessionId, {
+    sessionId: entry.sessionId,
+    title: entry.title,
+    agent: entry.agent,
+    status: status ?? entry.status ?? "idle",
+    serverUrl: entry.serverUrl,
+    updatedAt: entry.updatedAt
+  });
+}
+async function addRemoteServerRecords(combined, serverUrl, deps) {
+  const [remoteSessions, remoteStatusMap] = await Promise.all([
+    getRemoteSessions(serverUrl, deps.opencodeFetch),
+    getRemoteStatusMap(serverUrl, deps.opencodeFetch)
+  ]);
+  for (const session of remoteSessions.filter(isRootRemoteSession)) {
+    const status = remoteStatusMap[session.id]?.type ?? "idle";
+    combined.set(session.id, {
+      sessionId: session.id,
+      title: session.title,
+      agent: session.agent,
+      status,
+      serverUrl,
+      updatedAt: session.time.updated
+    });
+    await deps.sessionRegistry.upsertSession({
+      sessionId: session.id,
+      title: session.title,
+      parentID: session.parentID ?? null,
+      agent: session.agent,
+      status,
+      serverUrl,
+      updatedAt: session.time.updated
+    });
+  }
+}
+function createSessionsDispatcher(deps) {
+  return async ({ chatId, bot }) => {
+    let sessions;
+    try {
+      const [listResult, statusResult] = await Promise.all([
+        deps.client.session.list(),
+        deps.client.session.status()
+      ]);
+      const statusMap = statusResult.data ?? {};
+      for (const session of listResult.data ?? []) {
+        deps.sessionTitleService.setSessionInfo(session);
+        deps.sessionTitleService.setServerUrl(session.id, deps.serverUrl);
+        const status = statusMap[session.id]?.type ?? "idle";
+        await deps.sessionRegistry.upsertSession(
+          registryEntryFromSession(session, deps.serverUrl, status)
+        );
+        if (status !== void 0) deps.sessionTitleService.setSessionStatus(session.id, status);
+      }
+      const registrySessions = await deps.sessionRegistry.listSessions();
+      const combined = /* @__PURE__ */ new Map();
+      const remoteServerUrls = /* @__PURE__ */ new Set();
+      for (const entry of registrySessions.filter(isRootRegistryEntry)) {
+        const serverUrl = normalizeOpenCodeServerUrl(entry.serverUrl);
+        if (!serverUrl) continue;
+        if (isDifferentServerUrl(serverUrl, deps.serverUrl)) {
+          remoteServerUrls.add(serverUrl);
+          continue;
+        }
+        addRegistryRecord(combined, { ...entry, serverUrl }, statusMap[entry.sessionId]?.type);
+      }
+      for (const serverUrl of remoteServerUrls) {
+        try {
+          await addRemoteServerRecords(combined, serverUrl, deps);
+        } catch (err) {
+          deps.logger.error("sessions remote server refresh failed", { serverUrl, error: String(err) });
+        }
+      }
+      for (const session of (listResult.data ?? []).filter(isRootSession)) {
+        combined.set(session.id, {
+          sessionId: session.id,
+          title: session.title,
+          agent: agentFromSession2(session),
+          status: statusMap[session.id]?.type ?? "idle",
+          serverUrl: deps.serverUrl,
+          updatedAt: session.time.updated
+        });
+      }
+      sessions = [...combined.values()].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, MAX_SESSIONS);
+    } catch (err) {
+      await bot.sendMessage("\uC138\uC158 \uBAA9\uB85D\uC744 \uBD88\uB7EC\uC624\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", { parse_mode: "HTML" });
+      deps.logger.error("sessions list failed", { chatId, error: String(err) });
+      return;
+    }
+    if (sessions.length === 0) {
+      await bot.sendMessage("\uC138\uC158\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", { parse_mode: "HTML" });
+      return;
+    }
+    const capturedAt = Date.now();
+    const entries = sessions.map((session, i) => {
+      const entry = {
+        index: i + 1,
+        sessionId: session.sessionId,
+        title: session.title,
+        capturedAt
+      };
+      if (session.agent !== void 0) entry.agent = session.agent;
+      entry.status = session.status;
+      if (session.serverUrl !== void 0) entry.serverUrl = session.serverUrl;
+      return entry;
+    });
+    await deps.snapshotStore.saveSnapshot(chatId, entries);
+    const lines = entries.map((entry) => {
+      const agent = entry.agent ? escapeHtml(entry.agent) : "?";
+      const title = truncateForTelegram(escapeHtml(entry.title), MAX_TITLE_CHARS);
+      const status = ` \u2014 ${escapeHtml(entry.status ?? "idle")}`;
+      return `${entry.index}. [${agent}] ${title}${status}`;
+    });
+    let body = lines.join("\n");
+    if (body.length > MAX_BODY_CHARS) {
+      body = body.slice(0, MAX_BODY_CHARS) + "\u2026";
+    }
+    const text = `<b>\uCD5C\uADFC \uC138\uC158 (top ${entries.length})</b>
+${body}
+
+<i>/status N \uB610\uB294 /start_work N \uC73C\uB85C \uC870\uC791</i>`;
+    await bot.sendMessage(text, { parse_mode: "HTML" });
+    deps.logger.info("sessions listed", { chatId, count: entries.length });
+  };
+}
+
+// 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");
+  try {
+    await access(omoDir);
+  } catch {
+    return {
+      ready: false,
+      reason: "no-omo-dir",
+      detail: `${omoDir} does not exist`
+    };
+  }
+  try {
+    await access(boulderPath);
+    return {
+      ready: false,
+      reason: "boulder-active",
+      detail: `${boulderPath} exists`
+    };
+  } catch {
+  }
+  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}`
+    };
+  }
+  const stats = await Promise.all(
+    planFiles.map(async (f) => {
+      const full = join6(plansDir, f);
+      const s = await stat2(full);
+      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");
+  const totalMatches = content.match(/^- \[[ xX]\]/gm) ?? [];
+  const completedMatches = content.match(/^- \[[xX]\]/gm) ?? [];
+  const total = totalMatches.length;
+  const completed = completedMatches.length;
+  if (total === 0) {
+    return {
+      ready: false,
+      reason: "plan-empty",
+      detail: `${latest.name}: no checkboxes found`
+    };
+  }
+  if (completed >= total) {
+    return {
+      ready: false,
+      reason: "all-plans-complete",
+      detail: `${latest.name}: ${completed}/${total} complete`
+    };
+  }
+  return {
+    ready: true,
+    planPath: latest.path,
+    planName: latest.name.replace(/\.md$/, ""),
+    total,
+    completed
+  };
+}
+async function recheckSessionIdle(client, sessionId) {
+  const result = await client.session.status();
+  const statuses = result.data ?? {};
+  const sessionStatus = statuses[sessionId];
+  return (sessionStatus?.type ?? "idle") === "idle";
+}
+
+// src/events/status-command.ts
+var SNIPPET_MAX_CHARS = 80;
+var MESSAGES_LIMIT = 10;
+var EMPTY_MESSAGE = "\uBA54\uC2DC\uC9C0 \uC5C6\uC74C";
+function resolveProjectRoot(session) {
+  if (!session.directory) throw new Error("session directory missing");
+  return session.directory;
+}
+function extractTextFromParts(parts) {
+  const pieces = [];
+  for (const part of parts) {
+    if (part.type === "text" && typeof part.text === "string") {
+      pieces.push(part.text);
+    }
+  }
+  return pieces.join(" ");
+}
+function buildSnippet(envelope) {
+  if (!envelope) return EMPTY_MESSAGE;
+  try {
+    const raw = extractTextFromParts(envelope.parts);
+    const cleaned = stripCodeFences(raw);
+    const truncated = truncateForTelegram(cleaned, SNIPPET_MAX_CHARS);
+    if (!truncated) return EMPTY_MESSAGE;
+    return escapeHtml(truncated);
+  } catch {
+    return EMPTY_MESSAGE;
+  }
+}
+function findLastByRole(messages, role) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (msg && msg.info.role === role) return msg;
+  }
+  return void 0;
+}
+function planReadinessKorean(result) {
+  if (result.ready) {
+    return `${result.completed}/${result.total} (${result.planName})`;
+  }
+  switch (result.reason) {
+    case "no-omo-dir":
+      return "`.omo/` \uC5C6\uC74C";
+    case "no-plans":
+      return "plan \uD30C\uC77C \uC5C6\uC74C";
+    case "plan-empty":
+      return "\uCCB4\uD06C\uBC15\uC2A4 \uC5C6\uC74C";
+    case "all-plans-complete": {
+      const match = result.detail.match(/(\d+)\/(\d+)/);
+      if (match) return `${match[1]}/${match[2]} \uC644\uB8CC`;
+      return "\uC644\uB8CC";
+    }
+    case "boulder-active":
+      return "boulder \uD65C\uC131";
+  }
+}
+function planLine(result) {
+  if (result.ready) {
+    return `<b>\uD50C\uB79C \uC9C4\uD589\uB3C4</b>: ${result.completed}/${result.total} (${escapeHtml(result.planName)})`;
+  }
+  return `<b>\uD50C\uB79C \uC0C1\uD0DC</b>: ${planReadinessKorean(result)}`;
+}
+function boulderLine(result) {
+  const active = !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", {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    const n = Number(rawN);
+    if (Number.isNaN(n)) {
+      await bot.sendMessage(`\uC798\uBABB\uB41C \uC785\uB825: ${escapeHtml(rawN)}\uC740 \uC22B\uC790\uC5EC\uC57C \uD569\uB2C8\uB2E4`, {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    const snapshot = await deps.snapshotStore.loadSnapshot(chatId);
+    if (!snapshot) {
+      await bot.sendMessage("\uC138\uC158 \uBAA9\uB85D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 /sessions \uB97C \uC2E4\uD589\uD558\uC138\uC694.", {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    const entry = snapshot.find((e) => e.index === n);
+    if (!entry) {
+      await bot.sendMessage(`${n}\uBC88 \uC138\uC158 \uC5C6\uC74C. \uD604\uC7AC \uBAA9\uB85D \uD06C\uAE30: ${snapshot.length}`, {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    const rawSourceServerUrl = entry.serverUrl ?? deps.sessionTitleService.getServerUrl(entry.sessionId);
+    const sourceServerUrl = normalizeOpenCodeServerUrl(rawSourceServerUrl);
+    if (rawSourceServerUrl && !sourceServerUrl) {
+      await bot.sendMessage("\uC138\uC158 \uC11C\uBC84 \uC815\uBCF4\uAC00 \uC720\uD6A8\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. /sessions \uC7AC\uC2E4\uD589 \uD544\uC694", {
+        parse_mode: "HTML"
+      });
+      deps.logger.error("status invalid server url", { chatId, sessionId: entry.sessionId });
+      return;
+    }
+    const useRemoteServer = isDifferentServerUrl(sourceServerUrl, deps.serverUrl);
+    let session;
+    let responseStatus;
+    let sessionStatus = "idle";
+    let messages = [];
+    if (sourceServerUrl && useRemoteServer) {
+      try {
+        const getResult = await getRemoteSession(sourceServerUrl, entry.sessionId, deps.opencodeFetch);
+        session = getResult.data;
+        responseStatus = getResult.response.status;
+        if (!session || responseStatus === 404) {
+          await bot.sendMessage("\uC138\uC158\uC774 \uB354 \uC774\uC0C1 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. /sessions \uC7AC\uC2E4\uD589 \uD544\uC694", {
+            parse_mode: "HTML"
+          });
+          return;
+        }
+        const [statusMap, remoteMessages] = await Promise.all([
+          getRemoteStatusMap(sourceServerUrl, deps.opencodeFetch),
+          getRemoteMessages(sourceServerUrl, entry.sessionId, MESSAGES_LIMIT, deps.opencodeFetch)
+        ]);
+        sessionStatus = statusMap[entry.sessionId]?.type ?? "idle";
+        messages = remoteMessages;
+      } catch (err) {
+        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) });
+        return;
+      }
+    } else {
+      const [getResult, statusResult, messagesResult] = await Promise.all([
+        deps.client.session.get({ path: { id: entry.sessionId } }),
+        deps.client.session.status(),
+        deps.client.session.messages({
+          path: { id: entry.sessionId },
+          query: { limit: MESSAGES_LIMIT }
+        })
+      ]);
+      session = normalizeSession(getResult.data);
+      responseStatus = getResult.response?.status;
+      const statusMap = normalizeStatusMap(statusResult.data);
+      sessionStatus = statusMap[entry.sessionId]?.type ?? "idle";
+      messages = normalizeMessages(messagesResult.data);
+    }
+    if (!session || responseStatus === 404) {
+      await bot.sendMessage("\uC138\uC158\uC774 \uB354 \uC774\uC0C1 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. /sessions \uC7AC\uC2E4\uD589 \uD544\uC694", {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    const projectRoot = resolveProjectRoot(session);
+    const planReady = await checkPlanReadiness({ projectRoot });
+    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 text = [
+      `<b>\uC138\uC158 #${n}</b>: ${title}`,
+      `\uC5D0\uC774\uC804\uD2B8: ${agent}`,
+      `\uC0C1\uD0DC: ${escapeHtml(sessionStatus)}`,
+      ``,
+      `<b>\uB9C8\uC9C0\uB9C9 \uBA54\uC2DC\uC9C0</b>`,
+      `\uC720\uC800: ${userSnippet}`,
+      `\uC5D0\uC774\uC804\uD2B8: ${assistantSnippet}`,
+      ``,
+      planLine(planReady),
+      ``,
+      boulderLine(planReady)
+    ].join("\n");
+    await bot.sendMessage(text, { parse_mode: "HTML" });
+    deps.logger.info("status shown", {
+      chatId,
+      sessionId: entry.sessionId,
+      snapshotIndex: n
+    });
+  };
+}
+
+// src/events/start-work-command.ts
+function agentFromSession3(session) {
+  return session.agent;
+}
+function resolveProjectRoot2(session) {
+  return session.directory;
+}
+function readinessMessage(reason) {
+  switch (reason) {
+    case "no-omo-dir":
+      return ".omo/ \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. plan \uC791\uC131\uC774 \uC120\uD589\uB418\uC5B4\uC57C \uD569\uB2C8\uB2E4";
+    case "no-plans":
+      return ".omo/plans/ \uC5D0 plan \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4";
+    case "plan-empty":
+      return "plan \uD30C\uC77C\uC5D0 \uCCB4\uD06C\uBC15\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4 (\uD5E4\uB354\uB9CC \uC874\uC7AC)";
+    case "all-plans-complete":
+      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";
+  }
+}
+function isSessionNotFoundError(err) {
+  const httpError = err;
+  return httpError.status === 404 || httpError.statusCode === 404 || httpError.response?.status === 404 || err.message.includes("404");
+}
+async function sendHtml(bot, text) {
+  await bot.sendMessage(text, { parse_mode: "HTML" });
+}
+async function sendPlain(bot, text) {
+  await bot.sendMessage(text);
+}
+function createStartWorkCommandDispatcher(deps) {
+  return async ({ chatId, bot, args }) => {
+    const rawIndex = args[0]?.trim();
+    if (!rawIndex) {
+      await sendPlain(bot, "\uC0AC\uC6A9\uBC95: /start_work <\uBC88\uD638>. \uBA3C\uC800 /sessions \uB85C \uBAA9\uB85D \uD655\uC778");
+      return;
+    }
+    const index = Number(rawIndex);
+    if (Number.isNaN(index)) {
+      await sendPlain(bot, `\uC798\uBABB\uB41C \uC785\uB825: ${rawIndex}\uC740 \uC22B\uC790\uC5EC\uC57C \uD569\uB2C8\uB2E4`);
+      return;
+    }
+    const snapshot = await deps.snapshotStore.loadSnapshot(chatId);
+    if (snapshot === null) {
+      await sendPlain(bot, "\uC138\uC158 \uBAA9\uB85D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 /sessions \uC2E4\uD589");
+      return;
+    }
+    const entry = snapshot.find((candidate) => candidate.index === index);
+    if (!entry) {
+      await sendPlain(bot, `${index}\uBC88 \uC138\uC158 \uC5C6\uC74C (\uBAA9\uB85D \uD06C\uAE30: ${snapshot.length})`);
+      return;
+    }
+    const sessionId = entry.sessionId;
+    const rawSourceServerUrl = entry.serverUrl ?? deps.sessionTitleService.getServerUrl(sessionId);
+    const sourceServerUrl = normalizeOpenCodeServerUrl(rawSourceServerUrl);
+    if (rawSourceServerUrl && !sourceServerUrl) {
+      await sendPlain(bot, "\uC138\uC158 \uC11C\uBC84 \uC815\uBCF4\uAC00 \uC720\uD6A8\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. /sessions \uC7AC\uC2E4\uD589 \uD544\uC694");
+      deps.logger.error("start-work invalid server url", { sessionId });
+      return;
+    }
+    const useRemoteServer = isDifferentServerUrl(sourceServerUrl, deps.serverUrl);
+    let session;
+    try {
+      if (sourceServerUrl && useRemoteServer) {
+        const result = await getRemoteSession(sourceServerUrl, sessionId, deps.opencodeFetch);
+        if (!result.data || result.response.status === 404) {
+          await sendPlain(bot, "\uC138\uC158\uC774 \uB354 \uC774\uC0C1 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+          return;
+        }
+        session = result.data;
+      } else {
+        const result = await deps.client.session.get({ path: { id: sessionId } });
+        if (!result.data) {
+          await sendPlain(bot, "\uC138\uC158\uC774 \uB354 \uC774\uC0C1 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+          return;
+        }
+        session = result.data;
+      }
+    } catch (err) {
+      if (err instanceof Error && isSessionNotFoundError(err)) {
+        await sendPlain(bot, "\uC138\uC158\uC774 \uB354 \uC774\uC0C1 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+        return;
+      }
+      await sendPlain(bot, "\uC138\uC158 \uD655\uC778 \uC2E4\uD328. /sessions \uC7AC\uC2E4\uD589 \uD544\uC694");
+      deps.logger.error("start-work session lookup failed", { sessionId, error: String(err) });
+      return;
+    }
+    const agent = deps.sessionTitleService.getSessionAgent(sessionId) ?? agentFromSession3(session) ?? entry.agent;
+    if (agent !== "plan") {
+      await sendPlain(
+        bot,
+        `${index}\uBC88 \uC138\uC158\uC758 \uC5D0\uC774\uC804\uD2B8\uB294 'plan' \uC774 \uC544\uB2D9\uB2C8\uB2E4 (\uD604\uC7AC: ${agent ?? "unknown"}). /start_work \uB294 plan \uC138\uC158\uC5D0\uC11C\uB9CC \uAC00\uB2A5\uD569\uB2C8\uB2E4`
+      );
+      return;
+    }
+    let idle;
+    try {
+      idle = sourceServerUrl && useRemoteServer ? ((await getRemoteStatusMap(sourceServerUrl, deps.opencodeFetch))[sessionId]?.type ?? "idle") === "idle" : await recheckSessionIdle(deps.client, sessionId);
+    } catch (err) {
+      await sendPlain(bot, "\uC138\uC158 \uC0C1\uD0DC \uD655\uC778 \uC2E4\uD328. /sessions \uC7AC\uC2E4\uD589 \uD544\uC694");
+      deps.logger.error("start-work idle recheck failed", { sessionId, error: String(err) });
+      return;
+    }
+    if (!idle) {
+      await sendPlain(bot, `${index}\uBC88 \uC138\uC158\uC774 idle \uC0C1\uD0DC\uAC00 \uC544\uB2D9\uB2C8\uB2E4. \uC791\uC5C5 \uC644\uB8CC\uB97C \uAE30\uB2E4\uB9AC\uC138\uC694`);
+      return;
+    }
+    const readiness = await checkPlanReadiness({ projectRoot: resolveProjectRoot2(session) });
+    if (!readiness.ready) {
+      await sendPlain(bot, readinessMessage(readiness.reason));
+      return;
+    }
+    try {
+      await deps.runSessionCommand(sessionId, "start-work", sourceServerUrl);
+      await sendHtml(
+        bot,
+        `${index}\uBC88 \uC138\uC158\uC5D0 opencode /start-work \uC2AC\uB798\uC2DC \uCEE4\uB9E8\uB4DC \uC804\uC1A1 \uC644\uB8CC. (${escapeHtml(entry.title)})`
+      );
+      deps.logger.info("start-work dispatched", { chatId, sessionId, index });
+    } catch (err) {
+      await sendHtml(bot, "opencode /start-work \uC804\uC1A1 \uC2E4\uD328");
+      deps.logger.error("start-work dispatch failed", { sessionId, error: String(err) });
+    }
+  };
+}
+
+// src/events/help-command.ts
+var HELP_TEXT = `<b>OpenCode Telegram Plugin \u2014 \uBA85\uB839 \uB3C4\uC6C0\uB9D0</b>
+
+<b>/sessions</b>
+\uD65C\uC131 root \uC138\uC158 \uBAA9\uB85D\uC744 \uBC88\uD638\uC640 \uD568\uAED8 \uD45C\uC2DC (\uCD5C\uADFC\uD65C\uB3D9\uC21C top 20).
+
+<b>/status &lt;\uBC88\uD638&gt;</b>
+\uD574\uB2F9 \uC138\uC158\uC758 \uC5D0\uC774\uC804\uD2B8/\uC0C1\uD0DC/\uB9C8\uC9C0\uB9C9 \uBA54\uC2DC\uC9C0 \uC2A4\uB2C8\uD3AB/\uD50C\uB79C \uC9C4\uD589\uB3C4/boulder \uC0C1\uD0DC \uD45C\uC2DC.
+
+<b>/start_work &lt;\uBC88\uD638&gt;</b>
+\uD574\uB2F9 \uC138\uC158\uC5D0 opencode <code>/start-work</code> \uC2AC\uB798\uC2DC \uCEE4\uB9E8\uB4DC \uC804\uC1A1.
+\uC548\uC804 \uAC8C\uC774\uD2B8: agent='plan' AND status=idle AND .omo/plans \uC5D0 \uBBF8\uC644\uB8CC plan \uC874\uC7AC AND .omo/boulder.json \uBD80\uC7AC.
+\uC870\uAC74 \uBBF8\uCDA9\uC871\uC2DC \uAD6C\uCCB4\uC801 \uC0AC\uC720 \uC548\uB0B4.
+(Telegram \uBD07 \uBA85\uB839\uC740 <code>/start_work</code>, \uB0B4\uBD80 \uD2B8\uB9AC\uAC70 \uB300\uC0C1\uC740 opencode \uC758 <code>/start-work</code>)
+
+<b>/help</b>
+\uC774 \uB3C4\uC6C0\uB9D0 \uD45C\uC2DC.
+
+<b>\uC81C\uC57D</b>
+\uBC88\uD638\uB294 <code>/sessions</code> \uB9C8\uC9C0\uB9C9 \uD638\uCD9C\uC758 \uC2A4\uB0C5\uC0F7\uC5D0 \uC885\uC18D (TTL 1\uC2DC\uAC04).
+leader \uD504\uB85C\uC138\uC2A4\uAC00 \uAD00\uCC30\uD55C \uC138\uC158\uB9CC \uD45C\uC2DC \u2014 \uB2E4\uB978 OpenCode \uD504\uB85C\uC138\uC2A4\uC758 \uC138\uC158\uC740 \uBCF4\uC774\uC9C0 \uC54A\uC744 \uC218 \uC788\uC74C.`;
+function createHelpDispatcher(deps) {
+  return async ({ chatId, bot }) => {
+    await bot.sendMessage(HELP_TEXT, { parse_mode: "HTML" });
+    deps.logger.info("help shown", { chatId });
+  };
 }
 
 // src/lib/env-loader.ts
 import { existsSync } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import dotenv from "dotenv";
 function loadPluginEnv(opts) {
   const paths = [
-    join5(opts.pluginDir, "../../.env"),
-    join5(opts.pluginDir, "..", ".env"),
-    join5(opts.pluginDir, ".env"),
-    join5(opts.homeDir ?? homedir(), ".config/opencode/telegram-remote/.env")
+    join7(opts.pluginDir, "../../.env"),
+    join7(opts.pluginDir, "..", ".env"),
+    join7(opts.pluginDir, ".env"),
+    join7(opts.homeDir ?? homedir(), ".config/opencode/telegram-remote/.env")
   ];
   const loadedFrom = [];
   const values = {};
@@ -1321,10 +2285,10 @@ function loadPluginEnv(opts) {
 }
 
 // src/lib/lock.ts
-import { open as open2, readFile as readFile4, stat as stat2, unlink as unlink5 } from "fs/promises";
+import { open as open2, readFile as readFile6, stat as stat3, unlink as unlink6 } from "fs/promises";
 import { hostname } from "os";
 var DEFAULT_TTL_MS2 = 5 * 60 * 1e3;
-function hasCode5(err, code) {
+function hasCode6(err, code) {
   return "code" in err && err.code === code;
 }
 function parseLockData(text) {
@@ -1343,7 +2307,7 @@ function isPidAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    if (err instanceof Error && hasCode5(err, "ESRCH")) return false;
+    if (err instanceof Error && hasCode6(err, "ESRCH")) return false;
     return true;
   }
 }
@@ -1364,7 +2328,7 @@ async function createLock(lockPath, pid) {
       if (released) return;
       released = true;
       try {
-        await unlink5(lockPath);
+        await unlink6(lockPath);
       } catch {
       }
     }
@@ -1374,7 +2338,7 @@ async function inspectExisting(lockPath, ttlMs) {
   let ownerPid;
   let dead = false;
   try {
-    const text = await readFile4(lockPath, "utf8");
+    const text = await readFile6(lockPath, "utf8");
     const data = parseLockData(text);
     if (data) {
       ownerPid = data.pid;
@@ -1384,7 +2348,7 @@ async function inspectExisting(lockPath, ttlMs) {
     return { stale: true, reason: "unreadable lock" };
   }
   try {
-    const fileStat = await stat2(lockPath);
+    const fileStat = await stat3(lockPath);
     const expired = Date.now() - fileStat.mtimeMs > ttlMs;
     if (dead) return { stale: true, ownerPid, reason: "dead owner" };
     if (expired) return { stale: true, ownerPid, reason: "expired lock" };
@@ -1400,7 +2364,7 @@ async function acquireLock(opts) {
     try {
       return { acquired: true, handle: await createLock(opts.lockPath, pid) };
     } catch (err) {
-      if (!(err instanceof Error) || !hasCode5(err, "EEXIST")) {
+      if (!(err instanceof Error) || !hasCode6(err, "EEXIST")) {
         return { acquired: false, reason: err instanceof Error ? err.message : String(err) };
       }
       const existing = await inspectExisting(opts.lockPath, ttlMs);
@@ -1408,7 +2372,7 @@ async function acquireLock(opts) {
         return { acquired: false, reason: existing.reason, ownerPid: existing.ownerPid };
       }
       try {
-        await unlink5(opts.lockPath);
+        await unlink6(opts.lockPath);
       } catch {
         return { acquired: false, reason: "failed to remove stale lock", ownerPid: existing.ownerPid };
       }
@@ -1487,11 +2451,152 @@ function createLogger(opts = {}) {
   };
 }
 
+// src/lib/session-snapshot.ts
+import { chmod as chmod2, mkdir as mkdir6, readFile as readFile7, rename as rename5, unlink as unlink7, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname4, join as join8 } from "path";
+var TTL_MS = 60 * 60 * 1e3;
+function hasCode7(err, code) {
+  return err instanceof Error && "code" in err && err.code === code;
+}
+function isSnapshotFile(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.version !== 1) return false;
+  if (typeof v.chatId !== "number") return false;
+  if (typeof v.createdAt !== "number") return false;
+  if (!Array.isArray(v.entries)) return false;
+  for (const entry of v.entries) {
+    if (!entry || typeof entry !== "object") return false;
+    const e = entry;
+    if (typeof e.index !== "number") return false;
+    if (typeof e.sessionId !== "string") return false;
+    if (typeof e.title !== "string") return false;
+    if (typeof e.capturedAt !== "number") return false;
+    if (e.agent !== void 0 && typeof e.agent !== "string") return false;
+    if (e.status !== void 0 && typeof e.status !== "string") return false;
+    if (e.serverUrl !== void 0) {
+      if (typeof e.serverUrl !== "string") return false;
+      if (!normalizeOpenCodeServerUrl(e.serverUrl)) return false;
+    }
+  }
+  return true;
+}
+function normalizeEntry2(entry) {
+  const out = {
+    index: entry.index,
+    sessionId: entry.sessionId,
+    title: entry.title,
+    capturedAt: entry.capturedAt
+  };
+  if (entry.agent !== void 0) out.agent = entry.agent;
+  if (entry.status !== void 0) out.status = entry.status;
+  if (entry.serverUrl !== void 0) {
+    const serverUrl = normalizeOpenCodeServerUrl(entry.serverUrl);
+    if (serverUrl !== void 0) out.serverUrl = serverUrl;
+  }
+  return out;
+}
+function createSnapshotStore(opts) {
+  const { configDir, tokenHash, logger } = opts;
+  const snapshotsDir = join8(configDir, "snapshots");
+  const writeLocks = /* @__PURE__ */ new Map();
+  function snapshotFilePath(chatId) {
+    return join8(snapshotsDir, `${tokenHash}-${chatId}.json`);
+  }
+  async function performSave(chatId, entries) {
+    const filePath = snapshotFilePath(chatId);
+    const parent = dirname4(filePath);
+    await mkdir6(parent, { recursive: true });
+    try {
+      await chmod2(parent, 448);
+    } catch (err) {
+      logger.error("snapshot: failed to chmod parent dir", {
+        path: parent,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    const payload = {
+      version: 1,
+      chatId,
+      createdAt: Date.now(),
+      entries: entries.map(normalizeEntry2)
+    };
+    const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+    await writeFile5(tmpPath, JSON.stringify(payload, null, 2), "utf8");
+    try {
+      await rename5(tmpPath, filePath);
+    } catch (err) {
+      try {
+        await unlink7(tmpPath);
+      } catch {
+      }
+      throw err;
+    }
+    await chmod2(filePath, 384);
+  }
+  async function saveSnapshot(chatId, entries) {
+    const prev = writeLocks.get(chatId) ?? Promise.resolve();
+    const next = prev.catch(() => void 0).then(() => performSave(chatId, entries));
+    const tracked = next.catch(() => void 0);
+    writeLocks.set(chatId, tracked);
+    try {
+      await next;
+    } finally {
+      if (writeLocks.get(chatId) === tracked) {
+        writeLocks.delete(chatId);
+      }
+    }
+  }
+  async function loadSnapshot(chatId) {
+    const filePath = snapshotFilePath(chatId);
+    let text;
+    try {
+      text = await readFile7(filePath, "utf8");
+    } catch (err) {
+      if (hasCode7(err, "ENOENT")) return null;
+      logger.error("snapshot: failed to read file", {
+        path: filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      logger.error("snapshot: corrupted JSON", {
+        path: filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+    if (!isSnapshotFile(parsed)) {
+      logger.error("snapshot: invalid shape", { path: filePath });
+      return null;
+    }
+    if (parsed.createdAt + TTL_MS < Date.now()) {
+      try {
+        await unlink7(filePath);
+      } catch (err) {
+        if (!hasCode7(err, "ENOENT")) {
+          logger.error("snapshot: failed to unlink expired file", {
+            path: filePath,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      return null;
+    }
+    return parsed.entries.map(normalizeEntry2);
+  }
+  return { saveSnapshot, loadSnapshot, snapshotFilePath };
+}
+
 // src/lib/state-store.ts
-import { mkdir as mkdir5, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile8, rename as rename6, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join6 } from "path";
-function hasCode6(err, code) {
+import { dirname as dirname5, join as join9 } from "path";
+function hasCode8(err, code) {
   return "code" in err && err.code === code;
 }
 function parseState(text) {
@@ -1503,28 +2608,28 @@ function parseState(text) {
   return state;
 }
 function createStateStore(opts = {}) {
-  const filePath = opts.filePath ?? join6(homedir2(), ".config/opencode/telegram-remote/state.json");
+  const filePath = opts.filePath ?? join9(homedir2(), ".config/opencode/telegram-remote/state.json");
   return {
     async read() {
       try {
-        return parseState(await readFile5(filePath, "utf8"));
+        return parseState(await readFile8(filePath, "utf8"));
       } catch (err) {
-        if (err instanceof Error && hasCode6(err, "ENOENT")) return {};
+        if (err instanceof Error && hasCode8(err, "ENOENT")) return {};
         throw err;
       }
     },
     async write(patch) {
       const existing = await this.read();
       const next = { ...existing, ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      await mkdir5(dirname4(filePath), { recursive: true });
+      await mkdir7(dirname5(filePath), { recursive: true });
       const tmpPath = `${filePath}.tmp.${process.pid}`;
-      await writeFile4(tmpPath, JSON.stringify(next, null, 2), "utf8");
+      await writeFile6(tmpPath, JSON.stringify(next, null, 2), "utf8");
       try {
-        await rename4(tmpPath, filePath);
+        await rename6(tmpPath, filePath);
       } catch (err) {
-        if (!(err instanceof Error) || !hasCode6(err, "ENOENT")) throw err;
-        await writeFile4(tmpPath, JSON.stringify(next, null, 2), "utf8");
-        await rename4(tmpPath, filePath);
+        if (!(err instanceof Error) || !hasCode8(err, "ENOENT")) throw err;
+        await writeFile6(tmpPath, JSON.stringify(next, null, 2), "utf8");
+        await rename6(tmpPath, filePath);
       }
       return next;
     }
@@ -1532,7 +2637,7 @@ function createStateStore(opts = {}) {
 }
 
 // src/services/session-title-service.ts
-function agentFromSession(info) {
+function agentFromSession4(info) {
   const candidate = info;
   return typeof candidate.agent === "string" ? candidate.agent : void 0;
 }
@@ -1543,9 +2648,11 @@ var SessionTitleService = class {
     this.sessions.set(info.id, {
       title: info.title || null,
       parentID: info.parentID ?? null,
-      agent: agentFromSession(info) ?? existing?.agent,
+      agent: agentFromSession4(info) ?? existing?.agent,
       status: existing?.status,
-      idleNotificationPending: existing?.idleNotificationPending ?? false
+      idleNotificationPending: existing?.idleNotificationPending ?? false,
+      lastSeenAt: Date.now(),
+      serverUrl: existing?.serverUrl
     });
   }
   setSessionTitle(sessionId, title) {
@@ -1555,7 +2662,9 @@ var SessionTitleService = class {
       parentID: existing?.parentID,
       agent: existing?.agent,
       status: existing?.status,
-      idleNotificationPending: existing?.idleNotificationPending ?? false
+      idleNotificationPending: existing?.idleNotificationPending ?? false,
+      lastSeenAt: Date.now(),
+      serverUrl: existing?.serverUrl
     });
   }
   setSessionAgent(sessionId, agent) {
@@ -1565,7 +2674,9 @@ var SessionTitleService = class {
       parentID: existing?.parentID,
       agent,
       status: existing?.status,
-      idleNotificationPending: existing?.idleNotificationPending ?? false
+      idleNotificationPending: existing?.idleNotificationPending ?? false,
+      lastSeenAt: Date.now(),
+      serverUrl: existing?.serverUrl
     });
   }
   setSessionStatus(sessionId, status) {
@@ -1575,9 +2686,48 @@ var SessionTitleService = class {
       parentID: existing?.parentID,
       agent: existing?.agent,
       status,
-      idleNotificationPending: status === "idle" ? existing?.idleNotificationPending ?? false : false
+      idleNotificationPending: status === "idle" ? existing?.idleNotificationPending ?? false : false,
+      lastSeenAt: Date.now(),
+      serverUrl: existing?.serverUrl
     });
   }
+  setServerUrl(sessionId, serverUrl) {
+    const existing = this.sessions.get(sessionId);
+    if (existing?.serverUrl) return;
+    const lastSeenAt = existing?.lastSeenAt ?? Date.now();
+    this.sessions.set(sessionId, {
+      ...existing ?? {
+        title: null,
+        parentID: void 0,
+        idleNotificationPending: false,
+        lastSeenAt
+      },
+      lastSeenAt,
+      serverUrl
+    });
+  }
+  getServerUrl(sessionId) {
+    return this.sessions.get(sessionId)?.serverUrl;
+  }
+  getRootSessionsByRecency(limit) {
+    const results = [];
+    for (const [sessionId, entry] of this.sessions.entries()) {
+      if (entry.parentID !== null) continue;
+      results.push({
+        sessionId,
+        title: entry.title,
+        agent: entry.agent,
+        status: entry.status,
+        serverUrl: entry.serverUrl
+      });
+    }
+    results.sort((a, b) => {
+      const lastSeenA = this.sessions.get(a.sessionId)?.lastSeenAt ?? 0;
+      const lastSeenB = this.sessions.get(b.sessionId)?.lastSeenAt ?? 0;
+      return lastSeenB - lastSeenA;
+    });
+    return results.slice(0, limit);
+  }
   getSessionTitle(sessionId) {
     return this.sessions.get(sessionId)?.title ?? null;
   }
@@ -1605,7 +2755,9 @@ var SessionTitleService = class {
       parentID: existing?.parentID,
       agent: existing?.agent,
       status: existing?.status ?? "idle",
-      idleNotificationPending: true
+      idleNotificationPending: true,
+      lastSeenAt: existing?.lastSeenAt ?? Date.now(),
+      serverUrl: existing?.serverUrl
     });
   }
   hasDeferredIdleNotification(sessionId) {
@@ -1622,19 +2774,19 @@ var SessionTitleService = class {
 };
 
 // src/telegram-remote.ts
-var pluginDir = dirname5(fileURLToPath(import.meta.url));
+var pluginDir = dirname6(fileURLToPath(import.meta.url));
 async function postToServer(serverUrl, path, body) {
-  const url = new URL(path, serverUrl);
+  const safeServerUrl = normalizeOpenCodeServerUrl(serverUrl);
+  if (!safeServerUrl) throw new Error("Invalid OpenCode server URL");
+  const url = new URL(path, safeServerUrl);
   const response = await fetch(url, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    redirect: "error"
   });
   if (response.ok) return;
-  const text = await response.text();
-  throw new Error(
-    `OpenCode request failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
-  );
+  throw new Error(`OpenCode request failed: ${response.status} ${response.statusText}`);
 }
 function getSessionAgentFromMessage(event) {
   const info = event.properties.info;
@@ -1658,8 +2810,11 @@ var TelegramRemote = async (input) => {
     const stateStore = createStateStore();
     const initialState = await stateStore.read();
     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 configDir = join10(homedir3(), ".config/opencode/telegram-remote");
+    const snapshotStore = createSnapshotStore({ configDir, tokenHash, logger });
+    const sessionRegistry = createSessionRegistryStore({ configDir, tokenHash, logger });
+    const lockPath = join10(tmpdir5(), `opencoder-telegram-${tokenHash}.lock`);
+    const claimsDir = join10(tmpdir5(), `opencoder-telegram-claims-${tokenHash}`);
     const pendingQuestions = createPendingQuestionStore({ tokenHash });
     const pendingPermissions = createPendingPermissionStore({ tokenHash });
     const pendingStartWorks = createPendingStartWorkStore({ tokenHash });
@@ -1689,8 +2844,8 @@ var TelegramRemote = async (input) => {
         throwOnError: true
       });
     };
-    const replyToPermission = async (requestID, sessionID, reply, endpoint, serverUrl = input.serverUrl.href) => {
-      if (endpoint === "request") {
+    const replyToPermission = async (requestID, sessionID, reply, endpoint2, serverUrl = input.serverUrl.href) => {
+      if (endpoint2 === "request") {
         const path2 = `/permission/${encodeURIComponent(requestID)}/reply`;
         if (serverUrl !== input.serverUrl.href) {
           await postToServer(serverUrl, path2, { reply });
@@ -1774,6 +2929,7 @@ var TelegramRemote = async (input) => {
       pendingQuestions,
       pendingPermissions,
       pendingStartWorks,
+      sessionRegistry,
       replyToQuestion,
       replyToPermission,
       runSessionCommand
@@ -1782,6 +2938,30 @@ var TelegramRemote = async (input) => {
       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({
+        snapshotStore,
+        sessionTitleService,
+        client: input.client,
+        logger,
+        serverUrl: input.serverUrl.href
+      }));
+      bot.setStartWorkCommandDispatcher(createStartWorkCommandDispatcher({
+        snapshotStore,
+        sessionTitleService,
+        client: input.client,
+        serverUrl: input.serverUrl.href,
+        runSessionCommand,
+        logger
+      }));
+      bot.setHelpDispatcher(createHelpDispatcher({ logger }));
     }
     return {
       event: async ({ event }) => {
@@ -1793,13 +2973,25 @@ var TelegramRemote = async (input) => {
             logger.info("session.status received", { statusType: event.properties.status.type });
             return handleSessionStatus(event, ctx);
           case "session.created":
+            ctx.sessionTitleService.setServerUrl(event.properties.info.id, input.serverUrl.href);
             return handleSessionCreated(event, ctx);
           case "session.updated":
+            ctx.sessionTitleService.setServerUrl(event.properties.info.id, input.serverUrl.href);
             return handleSessionUpdated(event, ctx);
           case "message.updated": {
             const messageAgent = getSessionAgentFromMessage(event);
-            if (messageAgent)
+            if (messageAgent) {
+              const previousAgent = ctx.sessionTitleService.getSessionAgent(messageAgent.sessionID);
               ctx.sessionTitleService.setSessionAgent(messageAgent.sessionID, messageAgent.agent);
+              ctx.sessionTitleService.setServerUrl(messageAgent.sessionID, input.serverUrl.href);
+              if (previousAgent !== messageAgent.agent) {
+                await ctx.sessionRegistry.updateSession(messageAgent.sessionID, {
+                  agent: messageAgent.agent,
+                  serverUrl: input.serverUrl.href,
+                  updatedAt: Date.now()
+                });
+              }
+            }
             return;
           }
           case "permission.updated":
@@ -1807,7 +2999,16 @@ var TelegramRemote = async (input) => {
           default: {
             const stepAgent = getSessionAgentFromNextStep(extEvent);
             if (stepAgent) {
+              const previousAgent = ctx.sessionTitleService.getSessionAgent(stepAgent.sessionID);
               ctx.sessionTitleService.setSessionAgent(stepAgent.sessionID, stepAgent.agent);
+              ctx.sessionTitleService.setServerUrl(stepAgent.sessionID, input.serverUrl.href);
+              if (previousAgent !== stepAgent.agent) {
+                await ctx.sessionRegistry.updateSession(stepAgent.sessionID, {
+                  agent: stepAgent.agent,
+                  serverUrl: input.serverUrl.href,
+                  updatedAt: Date.now()
+                });
+              }
               return;
             }
             if (isEventPermissionAsked(extEvent)) {