kiro-telegram-bot 1.5.1 → 1.6.0

package/src/app/updater.ts

@@ -0,0 +1,234 @@
+/**
+ * Auto-updater — once an hour, asks npm for the latest published version with a
+ * single lightweight request. When a newer version exists AND the bot is fully
+ * idle (no in-flight prompt, no other active Kiro session on the PC), it
+ * announces in chat, runs `npm install -g kiro-telegram-bot@<latest>`, and
+ * restarts to apply. After the restart it posts the new version's CHANGELOG
+ * (tagged #update) so every release is easy to find in the conversation.
+ *
+ * Safety:
+ *   • only ever updates when idle — never interrupts a running turn/task;
+ *   • only for a global npm install (a cloned/source checkout is left alone);
+ *   • restart is supervisor-aware: under systemd/launchd it exits cleanly and
+ *     lets the supervisor relaunch; on Windows / foreground it re-execs itself.
+ */
+import { spawn } from "node:child_process";
+import { get } from "node:https";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { JsonStore } from "./json-store.js";
+import { createLogger } from "../logger.js";
+import { extractChangelog, isNewer, isSafeVersion } from "./version.js";
+
+const log = createLogger("updater");
+const PKG = "kiro-telegram-bot";
+
+interface PendingUpdate {
+  from: string;
+  to: string;
+  chats: number[];
+}
+
+export interface UpdaterOptions {
+  enabled: boolean;
+  intervalMs: number;
+  projectRoot: string;
+  instanceDir: string;
+  dataDir: string;
+  /** True while the agent is busy (a chat turn or scheduled task). */
+  isPromptInFlight: () => boolean;
+  /** Active Kiro sessions on this PC NOT owned by the bot's own agent. */
+  otherActiveSessions: () => number;
+  /** Send a plain or markdown message to every chat. */
+  announce: (text: string, markdown: boolean) => Promise<void>;
+  /** Stop polling + the agent before the process exits/re-execs. */
+  shutdown: () => Promise<void>;
+}
+
+export class Updater {
+  private timer: NodeJS.Timeout | undefined;
+  private readonly state: JsonStore<PendingUpdate | null>;
+  private readonly current: string;
+  private attempting = false;
+  private readonly tried = new Set<string>();
+
+  constructor(private readonly opts: UpdaterOptions) {
+    this.state = new JsonStore<PendingUpdate | null>(join(opts.dataDir, "update-state.json"), null);
+    this.current = readVersion(opts.projectRoot);
+  }
+
+  /** Announce a just-applied update (if any), then begin hourly checks. */
+  async start(): Promise<void> {
+    await this.announcePending();
+    if (!this.opts.enabled) {
+      log.info("auto-update disabled (AUTO_UPDATE=false)");
+      return;
+    }
+    if (!this.isNpmInstall()) {
+      log.info("running from source — auto-update is a no-op (use git to update)");
+      return;
+    }
+    // First check shortly after boot, then on the configured interval.
+    this.timer = setTimeout(() => void this.tick(), 60_000);
+  }
+
+  stop(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+  }
+
+  private schedule(): void {
+    this.timer = setTimeout(() => void this.tick(), this.opts.intervalMs);
+  }
+
+  private async tick(): Promise<void> {
+    try {
+      await this.checkAndUpdate();
+    } catch (e) {
+      log.debug("update check failed:", (e as Error).message);
+    } finally {
+      this.schedule();
+    }
+  }
+
+  private async checkAndUpdate(): Promise<void> {
+    if (this.attempting) return;
+    const latest = await fetchLatestVersion();
+    if (!latest || !isSafeVersion(latest)) return;
+    if (!isNewer(latest, this.current)) return;
+    if (this.tried.has(latest)) return; // don't loop on a version we already tried
+
+    if (this.opts.isPromptInFlight() || this.opts.otherActiveSessions() > 0) {
+      log.info(`update ${this.current} -> ${latest} available; waiting for idle`);
+      return; // re-evaluated next interval
+    }
+    await this.applyUpdate(latest);
+  }
+
+  private async applyUpdate(latest: string): Promise<void> {
+    this.attempting = true;
+    this.tried.add(latest);
+    log.info(`updating ${this.current} -> ${latest}`);
+    await this.opts.announce(
+      `\u{1F504} #update Updating ${PKG} v${this.current} \u2192 v${latest}\u2026\nThe bot is idle, so it's safe \u2014 it will restart and report what changed.`,
+      false,
+    );
+
+    const ok = await npmInstall(latest);
+    if (!ok) {
+      this.attempting = false;
+      await this.opts.announce(
+        `\u26A0\uFE0F #update Update to v${latest} failed (\`npm install -g\`). I'll try again after the next restart.`,
+        false,
+      );
+      return;
+    }
+
+    this.state.set({ from: this.current, to: latest, chats: this.announceChats() });
+    await this.restart();
+  }
+
+  /** After a restart, post the new version's changelog (once), tagged #update. */
+  private async announcePending(): Promise<void> {
+    const pending = this.state.get();
+    if (!pending) return;
+    this.state.set(null); // consume regardless, so we never re-announce
+    if (pending.to !== this.current) {
+      log.warn(`pending update to ${pending.to} but running ${this.current}; skipping announce`);
+      return;
+    }
+    const notes = this.changelogFor(pending.to);
+    const body = notes
+      ? `\u{1F680} #update Updated v${pending.from} \u2192 **v${pending.to}**\n\n${notes}`
+      : `\u{1F680} #update Updated to **v${pending.to}**.`;
+    await this.opts.announce(body, true);
+  }
+
+  private async restart(): Promise<void> {
+    await this.opts.shutdown().catch(() => {});
+    // Under systemd/launchd, a clean exit triggers a managed relaunch (no double
+    // instance). On Windows / foreground there is no supervisor, so re-exec.
+    if (process.env.KIRO_TG_SUPERVISED === "1") {
+      log.info("exiting for supervisor to relaunch the updated bot");
+      setTimeout(() => process.exit(0), 250);
+      return;
+    }
+    log.info("re-executing the updated bot");
+    const child = spawn(
+      process.execPath,
+      ["--import", "tsx", join(this.opts.projectRoot, "src", "index.ts"), "--instance", this.opts.instanceDir],
+      { detached: true, stdio: "ignore", cwd: this.opts.projectRoot, env: process.env },
+    );
+    child.unref();
+    setTimeout(() => process.exit(0), 500);
+  }
+
+  private isNpmInstall(): boolean {
+    return this.opts.projectRoot.replace(/\\/g, "/").includes("/node_modules/");
+  }
+
+  private announceChats(): number[] {
+    const pending = this.state.get();
+    return pending?.chats ?? [];
+  }
+
+  private changelogFor(version: string): string {
+    try {
+      const md = readFileSync(join(this.opts.projectRoot, "CHANGELOG.md"), "utf-8");
+      return extractChangelog(md, version);
+    } catch {
+      return "";
+    }
+  }
+}
+
+/** Read the installed version from package.json (falls back to "0.0.0"). */
+function readVersion(projectRoot: string): string {
+  try {
+    return (JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf-8")) as { version?: string }).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+/** One small HTTPS GET to the npm registry's dist-tag manifest for `latest`. */
+function fetchLatestVersion(): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    const req = get(
+      `https://registry.npmjs.org/${PKG}/latest`,
+      { timeout: 10_000, headers: { Accept: "application/json" } },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(undefined);
+          return;
+        }
+        let body = "";
+        res.setEncoding("utf-8");
+        res.on("data", (c) => (body += c));
+        res.on("end", () => {
+          try {
+            resolve((JSON.parse(body) as { version?: string }).version);
+          } catch {
+            resolve(undefined);
+          }
+        });
+      },
+    );
+    req.on("error", () => resolve(undefined));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(undefined);
+    });
+  });
+}
+
+/** Run `npm install -g kiro-telegram-bot@<version>`; resolves true on success. */
+function npmInstall(version: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const child = spawn(npm, ["install", "-g", `${PKG}@${version}`], { stdio: "ignore" });
+    child.on("error", () => resolve(false));
+    child.on("exit", (code) => resolve(code === 0));
+  });
+}

package/src/app/version.ts

@@ -0,0 +1,41 @@
+/**
+ * Tiny semver helpers + CHANGELOG section extraction for the auto-updater.
+ * Pure and dependency-free so they're easy to test.
+ */
+
+/** Parse the leading "X.Y.Z" of a version string (ignores pre-release tags). */
+export function parseSemver(v: string): [number, number, number] {
+  const m = /^\s*v?(\d+)\.(\d+)\.(\d+)/.exec(v);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : [0, 0, 0];
+}
+
+/** True when `latest` is strictly greater than `current` (by major/minor/patch). */
+export function isNewer(latest: string, current: string): boolean {
+  const a = parseSemver(latest);
+  const b = parseSemver(current);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i]! > b[i]!;
+  }
+  return false;
+}
+
+/** A version string is a plain semver we'd trust to pass to `npm install`. */
+export function isSafeVersion(v: string): boolean {
+  return /^\d+\.\d+\.\d+(?:[-.][0-9A-Za-z.-]+)?$/.test(v);
+}
+
+/** Extract the body of a CHANGELOG `## [version] …` section (markdown). */
+export function extractChangelog(md: string, version: string): string {
+  const head = new RegExp(`^##\\s*\\[${version.replace(/\./g, "\\.")}\\]`);
+  const out: string[] = [];
+  let capturing = false;
+  for (const line of md.split("\n")) {
+    if (capturing && /^##\s*\[/.test(line)) break;
+    if (capturing) {
+      out.push(line);
+      continue;
+    }
+    if (head.test(line)) capturing = true;
+  }
+  return out.join("\n").trim();
+}

package/src/bot/bot.ts

@@ -7,8 +7,10 @@ import { Bot } from "grammy";
 import type { AcpClient } from "../acp/client.js";
 import { SettingsStore } from "../app/settings-store.js";
 import { SttService } from "../app/stt.js";
+import { Updater } from "../app/updater.js";
 import { UsageService } from "../app/usage.js";
 import type { AppConfig } from "../config.js";
+import { INSTANCE_DIR } from "../config.js";
 import { createLogger } from "../logger.js";
 import { ProjectManager } from "../projects/manager.js";
 import { SessionStore } from "../sessions/store.js";
@@ -33,6 +35,9 @@ import { registerTasks, registerWizardInput } from "./handlers/tasks.js";
 import { registerUsage } from "./handlers/usage.js";
 import { registerVoice } from "./handlers/voice.js";
 import { StatusPanel } from "./menu/status-panel.js";
+import { sendMarkdownDoc } from "./telegram-io.js";
+import { Ephemeral } from "./menu/ephemeral.js";
+import { BAR_LABELS } from "./menu/keyboard.js";
 import { PermissionService } from "./permission-service.js";
 import { RuntimeRegistry } from "./registry.js";
 import { TaskWizard } from "./wizard/task-wizard.js";
@@ -57,6 +62,7 @@ export interface BotBundle {
   bot: Bot;
   registry: RuntimeRegistry;
   scheduler: Scheduler;
+  updater: Updater;
 }
 
 export async function createBot(cfg: AppConfig, acp: AcpClient): Promise<BotBundle> {
@@ -94,6 +100,7 @@ export async function createBot(cfg: AppConfig, acp: AcpClient): Promise<BotBund
     menuCache: new MenuCache(),
     settings,
     statusPanel,
+    ephemeral: new Ephemeral(bot.api, cfg.dataDir),
     tasks,
     taskRunner,
     wizard,
@@ -112,6 +119,16 @@ export async function createBot(cfg: AppConfig, acp: AcpClient): Promise<BotBund
 
   bot.use(createAuthMiddleware(cfg));
 
+  // Keep history clean: after handling, delete the user's command (/…) and
+  // persistent-bar button taps. Plain prompts and wizard input are kept.
+  bot.on("message:text", async (ctx, next) => {
+    await next();
+    const text = ctx.message?.text ?? "";
+    if (text.startsWith("/") || BAR_LABELS.includes(text)) {
+      await ctx.deleteMessage().catch(() => {});
+    }
+  });
+
   bot.callbackQuery(/^perm:(\d+):(\d+)$/, async (ctx) => {
     const label = permissions.resolveChoice(ctx.match![1]!, Number(ctx.match![2]));
     await ctx.answerCallbackQuery({ text: label ?? "Expired" });
@@ -150,5 +167,40 @@ export async function createBot(cfg: AppConfig, acp: AcpClient): Promise<BotBund
     log.warn("setMyCommands failed:", (e as Error).message);
   }
 
-  return { bot, registry, scheduler: new Scheduler(tasks, taskRunner) };
+  const updater = new Updater({
+    enabled: cfg.autoUpdate,
+    intervalMs: cfg.updateCheckMs,
+    projectRoot: cfg.projectRoot,
+    instanceDir: INSTANCE_DIR,
+    dataDir: cfg.dataDir,
+    isPromptInFlight: () => acp.hasInflightPrompt(),
+    otherActiveSessions: () => store.listActive().filter((s) => s.lockPid !== acp.pid).length,
+    announce: async (text, markdown) => {
+      for (const id of settings.chatIds()) {
+        try {
+          if (markdown) await sendMarkdownDoc(bot.api, id, text, { loud: true });
+          else await bot.api.sendMessage(id, text, { disable_notification: false });
+        } catch {
+          /* per-chat best-effort */
+        }
+      }
+    },
+    shutdown: async () => {
+      try {
+        await bot.stop();
+      } catch {
+        /* ignore */
+      }
+      try {
+        acp.stop();
+      } catch {
+        /* ignore */
+      }
+    },
+  });
+
+  // Remove any navigation surface left over from before a restart.
+  void deps.ephemeral.cleanupAll().catch(() => {});
+
+  return { bot, registry, scheduler: new Scheduler(tasks, taskRunner), updater };
 }

package/src/bot/chat-controller.ts

@@ -64,6 +64,7 @@ export class ChatController {
   /** List the controlled sessions (for /running). */
   list(): RunningSession[] {
     this.ensureRestored();
+    this.pruneDuplicates();
     return this.runtimes.map((rt) => ({
       sessionId: rt.sessionId,
       projectName: rt.projectName ?? basename(rt.cwd),
@@ -76,10 +77,11 @@ export class ChatController {
   /** Start a brand-new session and bring it to the foreground. */
   async addNew(cwd: string, projectName?: string): Promise<SessionRuntime> {
     this.ensureRestored();
-    await this.background(this.fg);
+    const prevFg = this.fg;
     const rt = this.create({ cwd, projectName });
     this.runtimes.push(rt);
     this.fg = rt;
+    await this.background(prevFg);
     await rt.startNewSession(cwd, projectName);
     this.markSeen(rt);
     this.persist();
@@ -101,10 +103,13 @@ export class ChatController {
       const sw = await this.switchTo(sessionId);
       return { rt: sw!.rt, result: "resumed", alreadyControlled: true };
     }
-    await this.background(this.fg);
+    // Reserve the runtime synchronously (before any await) so a concurrent tap
+    // on the same session finds it and switches instead of creating a duplicate.
+    const prevFg = this.fg;
     const rt = this.create({ cwd, projectName, sessionId });
     this.runtimes.push(rt);
     this.fg = rt;
+    await this.background(prevFg);
     const result = await rt.attach(sessionId, cwd, projectName, priorEntries);
     this.markSeen(rt);
     this.persist();
@@ -117,10 +122,11 @@ export class ChatController {
     if (this.runtimes.some((r) => r.sessionId === sessionId)) {
       return (await this.switchTo(sessionId))!;
     }
-    await this.background(this.fg);
+    const prevFg = this.fg;
     const rt = this.create({ cwd, projectName, sessionId });
     this.runtimes.push(rt);
     this.fg = rt;
+    await this.background(prevFg);
     await rt.prepare().catch(() => {});
     const path = this.store.jsonlPath(sessionId);
     const unread = readHistory(path, 12);
@@ -198,8 +204,10 @@ export class ChatController {
     if (this.restored) return;
     this.restored = true;
     const s = this.settings.get(this.chatId);
+    const seen = new Set<string>();
     for (const cs of s.controlledSessions ?? []) {
-      if (!cs.sessionId) continue;
+      if (!cs.sessionId || seen.has(cs.sessionId)) continue; // never restore the same session twice
+      seen.add(cs.sessionId);
       this.runtimes.push(this.create({ cwd: cs.projectPath, projectName: cs.projectName, sessionId: cs.sessionId }));
     }
     if (this.runtimes.length > 0) {
@@ -209,10 +217,51 @@ export class ChatController {
     }
   }
 
+  /** Drop any runtime that duplicates another's sessionId (keeping the
+   *  foreground one), healing a state where two runtimes wrap one session. */
+  private pruneDuplicates(): void {
+    const byId = new Map<string, SessionRuntime>();
+    const kept: SessionRuntime[] = [];
+    for (const rt of this.runtimes) {
+      const id = rt.sessionId;
+      if (!id) {
+        kept.push(rt);
+        continue;
+      }
+      const prev = byId.get(id);
+      if (!prev) {
+        byId.set(id, rt);
+        kept.push(rt);
+        continue;
+      }
+      const loser = prev.isForeground || !rt.isForeground ? rt : prev;
+      const winner = loser === rt ? prev : rt;
+      if (winner !== prev) {
+        byId.set(id, winner);
+        const i = kept.indexOf(prev);
+        if (i !== -1) kept[i] = winner;
+      }
+      if (this.fg === loser) this.fg = winner;
+      loser.dispose();
+    }
+    if (kept.length !== this.runtimes.length) {
+      this.runtimes.length = 0;
+      this.runtimes.push(...kept);
+      this.persist();
+    }
+  }
+
   private create(init: { cwd: string; projectName?: string; sessionId?: string }): SessionRuntime {
     const rt = new SessionRuntime(this.api, this.chatId, this.acp, this.cfg, this.settings, init);
     rt.onStateChange = () => this.refresh(this.chatId);
     rt.onActivity = (busy) => this.notifyActivity(busy);
+    // A logical fork (auto-fork-on-error / lost-session recovery) swaps the
+    // runtime's session id in place — re-persist the controlled list with the
+    // new id and treat the fresh session as already-seen.
+    rt.onSessionChange = () => {
+      this.markSeen(rt);
+      this.persist();
+    };
     return rt;
   }
 
@@ -234,9 +283,13 @@ export class ChatController {
   }
 
   private persist(): void {
-    const controlled = this.runtimes
-      .filter((r) => r.sessionId)
-      .map((r) => ({ sessionId: r.sessionId, projectPath: r.cwd, projectName: r.projectName }));
+    const seen = new Set<string>();
+    const controlled: { sessionId?: string; projectPath: string; projectName?: string }[] = [];
+    for (const r of this.runtimes) {
+      if (!r.sessionId || seen.has(r.sessionId)) continue;
+      seen.add(r.sessionId);
+      controlled.push({ sessionId: r.sessionId, projectPath: r.cwd, projectName: r.projectName });
+    }
     this.settings.update(this.chatId, {
       controlledSessions: controlled,
       foregroundSessionId: this.fg?.sessionId,

package/src/bot/commands.ts

@@ -4,7 +4,7 @@
 export const COMMANDS: { command: string; description: string }[] = [
   { command: "start", description: "Welcome, menu & status panel" },
   { command: "menu", description: "Show the menu keyboard" },
-  { command: "projects", description: "Projects: list / search <q> / new <name>" },
+  { command: "projects", description: "Projects: list / search <q> / open <path> / new <name>" },
   { command: "sessions", description: "List/resume sessions (active first) \u00b7 /sessions <q>" },
   { command: "active", description: "Sessions running now on the PC" },
   { command: "running", description: "Sessions this chat controls \u2014 switch between them" },
@@ -16,7 +16,7 @@ export const COMMANDS: { command: string; description: string }[] = [
   { command: "new", description: "Start a fresh session here" },
   { command: "status", description: "Current session, project & queue" },
   { command: "usage", description: "Account & context usage" },
-  { command: "btw", description: "Queue a follow-up: /btw <text>" },
+  { command: "btw", description: "Run ASAP (now if idle, else next): /btw <text>" },
   { command: "flush", description: "Send queued follow-ups now" },
   { command: "queue", description: "Show queued follow-ups" },
   { command: "cancel", description: "Stop the current turn" },
@@ -41,7 +41,7 @@ export const HELP_TEXT = [
   "/active \u2014 attach to a session currently running on the PC",
   "/history \u2014 show the latest messages of the current session",
   "/new \u2014 start a brand-new session in the current project",
-  "/btw <text> \u2014 add a follow-up to run after the current task",
+  "/btw <text> \u2014 run it now if idle, otherwise right after the current task",
   "/flush \u2014 run queued follow-ups immediately",
   "/cancel \u2014 stop the current turn",
   "/status \u2014 show session, project and queue size",

package/src/bot/deps.ts

@@ -9,10 +9,12 @@ import type { AppConfig } from "../config.js";
 import type { SttService } from "../app/stt.js";
 import type { UsageService } from "../app/usage.js";
 import type { ProjectEntry, ProjectManager } from "../projects/manager.js";
+import type { SessionMeta } from "../sessions/types.js";
 import type { SessionStore } from "../sessions/store.js";
 import type { TaskRunner } from "../tasks/runner.js";
 import type { TaskStore } from "../tasks/store.js";
 import type { StatusPanel } from "./menu/status-panel.js";
+import type { Ephemeral } from "./menu/ephemeral.js";
 import type { RuntimeRegistry } from "./registry.js";
 import type { TaskWizard } from "./wizard/task-wizard.js";
 
@@ -26,6 +28,7 @@ export interface BotDeps {
   menuCache: MenuCache;
   settings: SettingsStore;
   statusPanel: StatusPanel;
+  ephemeral: Ephemeral;
   tasks: TaskStore;
   taskRunner: TaskRunner;
   wizard: TaskWizard;
@@ -36,6 +39,7 @@ export interface BotDeps {
 /** Caches the last project list shown per chat for callback resolution. */
 export class MenuCache {
   private readonly projectLists = new Map<number, ProjectEntry[]>();
+  private readonly sessionLists = new Map<number, { metas: SessionMeta[]; heading: string }>();
 
   setProjects(chatId: number, list: ProjectEntry[]): void {
     this.projectLists.set(chatId, list);
@@ -44,4 +48,18 @@ export class MenuCache {
   getProject(chatId: number, index: number): ProjectEntry | undefined {
     return this.projectLists.get(chatId)?.[index];
   }
+
+  /** The full (sorted) project list, for paging the picker. */
+  getProjects(chatId: number): ProjectEntry[] | undefined {
+    return this.projectLists.get(chatId);
+  }
+
+  /** Remember the session set + heading currently being paged for a chat. */
+  setSessions(chatId: number, metas: SessionMeta[], heading: string): void {
+    this.sessionLists.set(chatId, { metas, heading });
+  }
+
+  getSessions(chatId: number): { metas: SessionMeta[]; heading: string } | undefined {
+    return this.sessionLists.get(chatId);
+  }
 }

package/src/bot/handlers/control.ts

@@ -68,12 +68,20 @@ export function registerControl(bot: Bot, deps: BotDeps): void {
   bot.command("btw", async (ctx) => {
     const text = (ctx.match || "").toString().trim();
     if (!text) {
-      await ctx.reply("Usage: /btw <something to do after the current task>");
+      await ctx.reply("Usage: /btw <something for the agent to do — now if idle, otherwise next>");
       return;
     }
     const rt = deps.registry.get(ctx.chat.id);
-    rt.enqueue(textPrompt(text));
-    await ctx.reply(`\u{1F4E5} Queued (position ${rt.queueLength}). It'll run when the current task finishes.`);
+    // Run it right away when idle; otherwise queue it to run automatically the
+    // moment the current turn finishes (can't interrupt an in-flight agent turn).
+    const outcome = await rt.submit(textPrompt(text));
+    if (outcome === "queued") {
+      await ctx.reply(
+        `\u{1F4E5} Queued (position ${rt.queueLength}) \u2014 it'll run automatically as soon as the current task finishes.`,
+      );
+    } else {
+      await ctx.reply("\u25B6\uFE0F On it\u2026");
+    }
   });
 
   bot.command("flush", async (ctx) => {

package/src/bot/handlers/history.ts

@@ -5,6 +5,7 @@ import type { Bot } from "grammy";
 import { basename } from "node:path";
 import type { BotDeps } from "../deps.js";
 import { readHistory } from "../../sessions/history.js";
+import { sessionHashtags } from "../../render/hashtags.js";
 import type { SessionMeta } from "../../sessions/types.js";
 import { sendMarkdownDoc } from "../telegram-io.js";
 
@@ -24,7 +25,7 @@ export function registerHistory(bot: Bot, deps: BotDeps): void {
       return;
     }
     const meta = deps.store.get(rt.sessionId);
-    await showHistory(deps, ctx.chat.id, rt.sessionId, meta);
+    await showHistory(deps, ctx.chat.id, rt.sessionId, meta, 16, rt.tags);
   });
 }
 
@@ -35,6 +36,7 @@ export async function showHistory(
   sessionId: string,
   meta?: SessionMeta,
   count = 16,
+  tags?: string,
 ): Promise<void> {
   const entries = readHistory(deps.store.jsonlPath(sessionId), count);
   if (entries.length === 0) {
@@ -54,5 +56,8 @@ export async function showHistory(
     })
     .join("\n\n");
 
-  await sendMarkdownDoc(deps.api, chatId, `${header}\n\n${body}`);
+  // Every AI-output surface carries the session's searchable hashtags. A static
+  // view (no live runtime) tags at least project + session id.
+  const footer = tags ?? sessionHashtags({ cwd: meta?.cwd, sessionId });
+  await sendMarkdownDoc(deps.api, chatId, `${header}\n\n${body}\n\n${footer}`);
 }

package/src/bot/handlers/kill.ts

@@ -17,9 +17,10 @@ function targets(deps: BotDeps): SessionMeta[] {
 }
 
 export async function showKillConfirm(ctx: Context, deps: BotDeps): Promise<void> {
+  await deps.ephemeral.open(ctx);
   const active = targets(deps);
   if (active.length === 0) {
-    await ctx.reply("\u2705 No other active Kiro sessions to kill.");
+    await deps.ephemeral.reply(ctx, "\u2705 No other active Kiro sessions to kill.");
     return;
   }
   const list = active
@@ -29,7 +30,8 @@ export async function showKillConfirm(ctx: Context, deps: BotDeps): Promise<void
   const kb = new InlineKeyboard()
     .text(`\u{1F6D1} Kill ${active.length}`, "killall:confirm")
     .text("Cancel", "killall:cancel");
-  await ctx.reply(
+  await deps.ephemeral.reply(
+    ctx,
     `\u{1F6D1} Kill ${active.length} active session(s)?\n${list}\n\n(The bot's own session is excluded.)`,
     { reply_markup: kb },
   );

package/src/bot/handlers/mcp.ts

@@ -87,7 +87,8 @@ function togglePanel(list: McpServer[], page: number): { text: string; kb: Inlin
 export async function showMcp(ctx: Context, deps: BotDeps): Promise<void> {
   const list = snapshot(ctx.chat!.id, deps);
   const { text, kb } = mainPanel(list);
-  await ctx.reply(text, { reply_markup: kb });
+  await deps.ephemeral.open(ctx);
+  await deps.ephemeral.reply(ctx, text, { reply_markup: kb });
 }
 
 function fmtProbe(r: McpProbeResult): string {