kiro-telegram-bot 1.5.1

package/src/bot/handlers/projects.ts

@@ -0,0 +1,83 @@
+/**
+ * /projects — browse, search, or create the folder Kiro works in.
+ *   /projects              list all projects
+ *   /projects <query>      list projects whose name contains <query>
+ *   /projects new <name>   create a folder and start a session in it
+ * Exposes a reusable project menu used by the menu button and the task wizard.
+ */
+import { type Context, InlineKeyboard } from "grammy";
+import type { Bot } from "grammy";
+import type { ProjectEntry } from "../../projects/manager.js";
+import type { BotDeps } from "../deps.js";
+import { refreshMenu } from "../menu/refresh.js";
+
+const PAGE = 40;
+
+/** Send a project picker. `prefix` is the callback-data prefix (e.g. "proj:"). */
+export async function sendProjectMenu(
+  ctx: Context,
+  deps: BotDeps,
+  prefix: string,
+  title: string,
+  entries?: ProjectEntry[],
+): Promise<void> {
+  const chatId = ctx.chat!.id;
+  const list = entries ?? deps.projects.list(PAGE);
+  deps.menuCache.setProjects(chatId, list);
+  if (list.length === 0) {
+    await ctx.reply("No matching projects. Try `/projects new <name>` to create one.");
+    return;
+  }
+  const kb = new InlineKeyboard();
+  list.forEach((p, i) => kb.text(`\u{1F4C1} ${p.name}`, `${prefix}${i}`).row());
+  await ctx.reply(title, { reply_markup: kb });
+}
+
+export async function showProjects(ctx: Context, deps: BotDeps, query?: string): Promise<void> {
+  const arg = (query ?? "").trim();
+
+  // Create: /projects new <name>
+  const create = /^new\s+(.+)$/i.exec(arg);
+  if (create) {
+    try {
+      const entry = deps.projects.create(create[1]!);
+      await deps.registry.controller(ctx.chat!.id).addNew(entry.path, entry.name);
+      await refreshMenu(ctx, deps, `\u2705 Created and opened project: ${entry.name}\n${entry.path}`);
+    } catch (e) {
+      await ctx.reply(`\u274C Could not create project: ${(e as Error).message}`);
+    }
+    return;
+  }
+
+  // Search: /projects <query>
+  if (arg) {
+    const found = deps.projects.search(arg, PAGE);
+    await sendProjectMenu(ctx, deps, "proj:", `Projects matching "${arg}":`, found);
+    return;
+  }
+
+  await sendProjectMenu(ctx, deps, "proj:", "Choose a project:");
+}
+
+export function registerProjects(bot: Bot, deps: BotDeps): void {
+  bot.command("projects", (ctx) => showProjects(ctx, deps, ctx.match?.toString()));
+
+  bot.callbackQuery(/^proj:(\d+)$/, async (ctx) => {
+    const index = Number(ctx.match![1]);
+    const entry = deps.menuCache.getProject(ctx.chat!.id, index);
+    if (!entry) {
+      await ctx.answerCallbackQuery({ text: "Selection expired, run /projects again." });
+      return;
+    }
+    await ctx.answerCallbackQuery();
+    try {
+      await deps.registry.controller(ctx.chat!.id).addNew(entry.path, entry.name);
+      await ctx.editMessageText(
+        `\u2705 Project set: ${entry.name}\n${entry.path}\n\nNew session ready \u2014 send a message.`,
+      );
+      await refreshMenu(ctx, deps, `\u{1F4C1} Now working in ${entry.name}`);
+    } catch (err) {
+      await ctx.editMessageText(`\u274C Could not open ${entry.name}: ${(err as Error).message}`);
+    }
+  });
+}

package/src/bot/handlers/running.ts

@@ -0,0 +1,104 @@
+/**
+ * /running — the sessions this chat controls. Tap one to switch to it; on
+ * switch you see a header + the target's unread messages (what happened while
+ * you were away) or its recent history the first time.
+ */
+import { type Bot, type Context, InlineKeyboard } from "grammy";
+import type { SwitchResult } from "../chat-controller.js";
+import type { BotDeps } from "../deps.js";
+import type { HistoryEntry } from "../../sessions/types.js";
+import { refreshMenu } from "../menu/refresh.js";
+import { sendMarkdownDoc } from "../telegram-io.js";
+
+const UUID = "([0-9a-fA-F-]{36})";
+const ROLE_ICON: Record<string, string> = {
+  user: "\u{1F464}",
+  assistant: "\u{1F916}",
+  tool: "\u{1F527}",
+  system: "\u2139\uFE0F",
+};
+const ENTRY_MAX = 700;
+
+function trunc(s: string, n: number): string {
+  return s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+}
+
+function listView(deps: BotDeps, chatId: number): { text: string; kb: InlineKeyboard } {
+  const list = deps.registry.controller(chatId).list();
+  const kb = new InlineKeyboard();
+  if (list.length === 0) {
+    return { text: "No sessions controlled yet. Use \u{1F4C1} Project or /new to start one.", kb };
+  }
+  for (const s of list) {
+    const dot = s.foreground ? "\u25B6\uFE0F" : s.busy ? "\u{1F7E0}" : "\u26AA";
+    const flags = `${s.busy ? " \u00B7 \u23F3" : ""}${s.unread > 0 ? ` \u00B7 ${s.unread}\u{1F4EC}` : ""}`;
+    const label = `${dot} ${trunc(s.projectName, 22)}${flags}`;
+    if (!s.sessionId) {
+      kb.text(label, "run:noop").row();
+      continue;
+    }
+    kb.text(label, s.foreground ? "run:noop" : `run:switch:${s.sessionId}`).text("\u2716", `run:close:${s.sessionId}`).row();
+  }
+  return { text: `\u{1F9ED} Sessions controlled by this chat (${list.length}) \u2014 tap to switch:`, kb };
+}
+
+export async function showRunning(ctx: Context, deps: BotDeps): Promise<void> {
+  const { text, kb } = listView(deps, ctx.chat!.id);
+  await ctx.reply(text, { reply_markup: kb });
+}
+
+/** Switch the chat to a session and show its summary + unread. */
+export async function switchAndShow(ctx: Context, deps: BotDeps, sessionId: string): Promise<void> {
+  const res = await deps.registry.controller(ctx.chat!.id).switchTo(sessionId);
+  if (!res) {
+    await ctx.reply("Session not found (it may have been closed).");
+    return;
+  }
+  await deliverSwitch(ctx, deps, res);
+}
+
+export function registerRunning(bot: Bot, deps: BotDeps): void {
+  bot.command("running", (ctx) => showRunning(ctx, deps));
+
+  bot.callbackQuery("run:noop", (ctx) => ctx.answerCallbackQuery({ text: "Already in foreground" }));
+
+  bot.callbackQuery(new RegExp(`^run:switch:${UUID}$`), async (ctx) => {
+    await ctx.answerCallbackQuery();
+    await switchAndShow(ctx, deps, ctx.match![1]!);
+  });
+
+  bot.callbackQuery(new RegExp(`^run:close:${UUID}$`), async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "Closed" });
+    await deps.registry.controller(ctx.chat!.id).close(ctx.match![1]!);
+    const { text, kb } = listView(deps, ctx.chat!.id);
+    await ctx.editMessageText(text, { reply_markup: kb }).catch(() => {});
+  });
+}
+
+async function deliverSwitch(ctx: Context, deps: BotDeps, res: SwitchResult): Promise<void> {
+  const proj = res.projectName ?? "session";
+  const sid = res.sessionId ? res.sessionId.slice(0, 8) : "?";
+  if (res.alreadyForeground) {
+    await ctx.reply(`You're already on ${proj} (${sid}).`);
+    return;
+  }
+  const working = res.busy ? " \u00B7 \u23F3 still working (live updates follow)" : "";
+  await refreshMenu(ctx, deps, `\u{1F500} Switched to ${proj} (${sid})${working}`);
+
+  if (res.unread.length === 0) {
+    if (!res.busy) await ctx.reply(res.firstView ? "No earlier messages here." : "\u2705 Nothing new while you were away.");
+    return;
+  }
+  const header = res.firstView
+    ? `\u{1F4DC} **Recent history** \u2014 ${proj}`
+    : `\u{1F4EC} **${res.unread.length} message(s) while away** \u2014 ${proj}`;
+  const body = res.unread.map(fmtEntry).join("\n\n");
+  await sendMarkdownDoc(deps.api, ctx.chat!.id, `${header}\n\n${body}`);
+}
+
+function fmtEntry(e: HistoryEntry): string {
+  const icon = ROLE_ICON[e.role] ?? "\u2022";
+  if (e.role === "tool") return `${icon} ${e.tool ? `\`${e.tool}\`` : "tool"}`;
+  const text = e.text.length > ENTRY_MAX ? e.text.slice(0, ENTRY_MAX) + " \u2026" : e.text;
+  return `${icon} ${text}`;
+}

package/src/bot/handlers/session-card.ts

@@ -0,0 +1,65 @@
+/**
+ * Builds a rich, readable "card" for a single Kiro session: a plain-text body
+ * (no MarkdownV2 so Windows paths and titles never need escaping) plus an
+ * inline keyboard with Connect / History / Watch actions.
+ *
+ * Callback data is unchanged (`sess:` / `hist:` / `watch:` + UUID) so the
+ * existing handlers in sessions.ts keep working.
+ */
+import { InlineKeyboard } from "grammy";
+import { basename } from "node:path";
+import type { SessionMeta } from "../../sessions/types.js";
+
+export interface SessionCardExtras {
+  /** Context-usage %, when the session is loaded in the current ACP process. */
+  contextPct?: number;
+}
+
+export interface SessionCard {
+  text: string;
+  keyboard: InlineKeyboard;
+}
+
+/** Build the card body + buttons for one session. */
+export function buildSessionCard(m: SessionMeta, extra: SessionCardExtras = {}): SessionCard {
+  const dot = m.active ? "\u{1F7E2}" : "\u26AA";
+  const state = m.active ? `running${m.lockPid ? ` \u00B7 pid ${m.lockPid}` : ""}` : "idle";
+  const proj = m.cwd ? basename(m.cwd) : "(no project)";
+
+  const lines = [`${dot} ${m.title}`, `\u{1F4C1} ${proj}`];
+  if (m.cwd) lines.push(`   ${m.cwd}`);
+  lines.push(`\u{1F552} updated ${relTime(m.updatedAt)} \u00B7 created ${relTime(m.createdAt)}`);
+  const ctx = typeof extra.contextPct === "number" ? ` \u00B7 \u{1F9E0} ctx ${Math.round(extra.contextPct)}%` : "";
+  lines.push(`\u{1F4CA} ${state} \u00B7 \u{1F4DC} history ${humanSize(m.historyBytes)}${ctx}`);
+  lines.push(`\u{1F194} ${m.sessionId.slice(0, 8)}`);
+
+  const connect = m.active ? "\u{1F374} Continue (fork)" : "\u{1F517} Resume";
+  const keyboard = new InlineKeyboard()
+    .text(connect, `sess:${m.sessionId}`)
+    .text("\u{1F4DC} History", `hist:${m.sessionId}`)
+    .text("\u{1F4E1} Watch", `watch:${m.sessionId}`);
+
+  return { text: lines.join("\n"), keyboard };
+}
+
+/** Compact relative time, e.g. "42s ago", "5m ago", "3h ago", "2d ago". */
+export function relTime(iso: string): string {
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return "unknown";
+  const s = Math.max(0, Math.round((Date.now() - t) / 1000));
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  return `${d}d ago`;
+}
+
+/** Human-readable byte size, e.g. "812 B", "42.3 KB", "1.2 MB". */
+export function humanSize(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/src/bot/handlers/sessions.ts

@@ -0,0 +1,131 @@
+/**
+ * /sessions — list recent Kiro sessions and connect to one.
+ * /active   — list sessions currently running on this PC.
+ * /unwatch  — stop following a live session.
+ *
+ * Each session is shown as its own card (status, project + path, times, history
+ * size, context %), with Connect (resume, or fork if the session is locked/live),
+ * 📜 History (static view), and 📡 Watch (live read-only follow) buttons.
+ */
+import { type Bot, type Context } from "grammy";
+import { basename } from "node:path";
+import type { BotDeps } from "../deps.js";
+import { readHistory } from "../../sessions/history.js";
+import type { SessionMeta } from "../../sessions/types.js";
+import { refreshMenu } from "../menu/refresh.js";
+import { showHistory } from "./history.js";
+import { buildSessionCard } from "./session-card.js";
+
+/** How many session cards to send at once (avoids flooding the chat). */
+const CARD_LIMIT = 8;
+const UUID = "([0-9a-fA-F-]{36})";
+
+export async function showSessions(ctx: Context, deps: BotDeps, query?: string): Promise<void> {
+  const q = (query ?? "").trim().toLowerCase();
+  let metas = deps.store.list(q ? 200 : 50);
+  if (q) {
+    metas = metas.filter((m) => `${m.title} ${m.cwd} ${m.sessionId}`.toLowerCase().includes(q));
+  }
+  if (metas.length === 0) {
+    await ctx.reply(q ? `No sessions match "${q}".` : "No saved sessions found in ~/.kiro/sessions/cli.");
+    return;
+  }
+  await sendSessionCards(ctx, deps, metas, q ? `Sessions matching "${q}"` : "Recent sessions");
+}
+
+/** Send a header then one rich card per session (active first, capped). */
+async function sendSessionCards(
+  ctx: Context,
+  deps: BotDeps,
+  metas: SessionMeta[],
+  heading: string,
+): Promise<void> {
+  const shown = metas.slice(0, CARD_LIMIT);
+  const live = shown.filter((m) => m.active).length;
+  const ofTotal = metas.length > shown.length ? ` of ${metas.length}` : "";
+  const liveStr = live ? ` \u00B7 \u{1F7E2} ${live} live` : "";
+  await ctx.reply(`\u{1F5C2} ${heading} \u2014 ${shown.length} shown${ofTotal}${liveStr}`);
+
+  for (const m of shown) {
+    const contextPct = deps.acp.metadataFor(m.sessionId)?.contextUsagePercentage;
+    const { text, keyboard } = buildSessionCard(m, { contextPct });
+    await ctx.reply(text, { reply_markup: keyboard });
+  }
+
+  if (metas.length > shown.length) {
+    await ctx.reply(`\u2026and ${metas.length - shown.length} more. Use /sessions <query> to filter.`);
+  }
+}
+
+export function registerSessions(bot: Bot, deps: BotDeps): void {
+  bot.command("sessions", (ctx) => showSessions(ctx, deps, ctx.match?.toString()));
+
+  bot.command("active", async (ctx) => {
+    const metas = deps.store.listActive();
+    if (metas.length === 0) {
+      await ctx.reply("No sessions are currently running on this PC.");
+      return;
+    }
+    await sendSessionCards(ctx, deps, metas, "Live sessions running now");
+  });
+
+  bot.command("unwatch", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    await ctx.reply(rt.stopWatch() ? "\u{1F6D1} Stopped watching." : "Not watching anything.");
+  });
+
+  bot.callbackQuery(new RegExp(`^sess:${UUID}$`), async (ctx) => {
+    const id = ctx.match![1]!;
+    const meta = deps.store.get(id);
+    if (!meta) {
+      await ctx.answerCallbackQuery({ text: "Session not found." });
+      return;
+    }
+    await ctx.answerCallbackQuery();
+    const fgCwd = deps.registry.get(ctx.chat!.id).cwd;
+    const cwd = meta.cwd || fgCwd;
+    const projectName = basename(meta.cwd || fgCwd) || "session";
+    const prior = readHistory(deps.store.jsonlPath(id), 24);
+    try {
+      const { result, alreadyControlled } = await deps.registry
+        .controller(ctx.chat!.id)
+        .addAttach(id, cwd, projectName, prior);
+      await ctx.editMessageText(alreadyControlled ? `\u{1F500} Switched to ${meta.title}` : connectMessage(result, meta));
+      await refreshMenu(ctx, deps, `\u{1F4C2} ${meta.title}`);
+      await showHistory(deps, ctx.chat!.id, id, meta);
+    } catch (err) {
+      await ctx.editMessageText(`\u274C Could not connect: ${(err as Error).message}`);
+    }
+  });
+
+  bot.callbackQuery(new RegExp(`^hist:${UUID}$`), async (ctx) => {
+    const id = ctx.match![1]!;
+    await ctx.answerCallbackQuery();
+    const meta = deps.store.get(id);
+    await showHistory(deps, ctx.chat!.id, id, meta);
+  });
+
+  bot.callbackQuery(new RegExp(`^watch:${UUID}$`), async (ctx) => {
+    const id = ctx.match![1]!;
+    await ctx.answerCallbackQuery();
+    const meta = deps.store.get(id);
+    const rt = deps.registry.get(ctx.chat!.id);
+    rt.startWatch(deps.store.jsonlPath(id));
+    await ctx.reply(
+      `\u{1F4E1} Watching live: ${meta?.title ?? id.slice(0, 8)}\nNew activity streams here. Send /unwatch to stop.`,
+    );
+  });
+}
+
+function connectMessage(result: "resumed" | "forked", meta: SessionMeta): string {
+  if (result === "resumed") {
+    return `\u2705 Resumed: ${meta.title}\n${meta.cwd}\n\nSend a message to continue.`;
+  }
+  return [
+    `\u26A0\uFE0F ${meta.title} is live on your PC right now, so Kiro keeps it locked.`,
+    `I opened a linked continuation here in the same project with its recent context.`,
+    `${meta.cwd}`,
+    ``,
+    `Send a message to keep going \u2014 or tap \u{1F4E1} to watch the original live.`,
+  ].join("\n");
+}

package/src/bot/handlers/system.ts

@@ -0,0 +1,51 @@
+/**
+ * System commands: /queue /clearqueue /model /restart.
+ */
+import type { Bot } from "grammy";
+import type { BotDeps } from "../deps.js";
+
+export function registerSystem(bot: Bot, deps: BotDeps): void {
+  bot.command("queue", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    if (rt.queueLength === 0) {
+      await ctx.reply("Queue is empty. Send a message while I'm busy, or use /btw <text>.");
+      return;
+    }
+    await ctx.reply(`\u{1F4E5} ${rt.queueLength} follow-up(s) queued. They run automatically after the current turn, or use /flush.`);
+  });
+
+  bot.command("clearqueue", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    const n = rt.clearQueue();
+    await ctx.reply(n > 0 ? `\u{1F5D1} Cleared ${n} queued message(s).` : "Queue was already empty.");
+  });
+
+  bot.command("model", async (ctx) => {
+    const modelId = (ctx.match || "").toString().trim();
+    const rt = deps.registry.get(ctx.chat.id);
+    if (!modelId) {
+      await ctx.reply("Usage: /model <model-id>  (changes the model for the current session)");
+      return;
+    }
+    if (!rt.sessionId) {
+      await ctx.reply("No active session yet. Send a message or pick a /projects folder first.");
+      return;
+    }
+    try {
+      await deps.acp.setModel(rt.sessionId, modelId);
+      await ctx.reply(`\u2705 Model set to \`${modelId}\` for this session.`, { parse_mode: "Markdown" });
+    } catch (err) {
+      await ctx.reply(`\u274C Could not set model: ${(err as Error).message}`);
+    }
+  });
+
+  bot.command("restart", async (ctx) => {
+    await ctx.reply("\u{1F501} Restarting the Kiro agent\u2026");
+    try {
+      await deps.acp.restart();
+      await ctx.reply("\u2705 Kiro agent restarted. Your session will re-bind on the next message.");
+    } catch (err) {
+      await ctx.reply(`\u274C Restart failed: ${(err as Error).message}`);
+    }
+  });
+}

package/src/bot/handlers/tasks.ts

@@ -0,0 +1,223 @@
+/**
+ * /tasks — manage scheduled tasks (create, list, view, edit, delete, run now).
+ * /newtask — start the creation wizard.
+ *
+ * A task is a prompt + a project + a schedule (once/daily/weekly/monthly/
+ * interval). The scheduler runs it and delivers the result here.
+ */
+import { type Bot, type Context, InlineKeyboard } from "grammy";
+import { basename } from "node:path";
+import type { BotDeps } from "../deps.js";
+import { describeSchedule } from "../../tasks/schedule.js";
+import type { Task } from "../../tasks/types.js";
+import type { ScheduleType } from "../../tasks/types.js";
+import type { WizardPrompt } from "../wizard/task-wizard.js";
+import { sendProjectMenu } from "./projects.js";
+
+const UUID = "([0-9a-fA-F-]{36})";
+
+export async function showTasks(ctx: Context, deps: BotDeps): Promise<void> {
+  const { text, kb } = listView(deps, ctx.chat!.id);
+  await ctx.reply(text, { reply_markup: kb });
+}
+
+export async function renderWizardPrompt(ctx: Context, deps: BotDeps, p: WizardPrompt): Promise<void> {
+  switch (p.kind) {
+    case "text":
+      await ctx.reply(p.text);
+      return;
+    case "project":
+      await sendProjectMenu(ctx, deps, "wiz:proj:", p.text);
+      return;
+    case "scheduleType": {
+      const kb = new InlineKeyboard()
+        .text("Once", "wiz:sched:once")
+        .text("Daily", "wiz:sched:daily")
+        .row()
+        .text("Weekly", "wiz:sched:weekly")
+        .text("Monthly", "wiz:sched:monthly")
+        .row()
+        .text("Every N minutes", "wiz:sched:interval");
+      await ctx.reply(p.text, { reply_markup: kb });
+      return;
+    }
+    case "confirm": {
+      const kb = new InlineKeyboard().text("\u2705 Save", "wiz:confirm").text("\u2716 Cancel", "wiz:cancel");
+      await ctx.reply(p.text, { reply_markup: kb });
+      return;
+    }
+    case "done":
+      await ctx.reply(p.text);
+      return;
+    case "aborted":
+      await ctx.reply("Cancelled.");
+      return;
+  }
+}
+
+/**
+ * Wizard text-input interceptor. Registered BEFORE command/prompt handlers so
+ * that, while a task wizard is active, free text feeds the wizard. A slash
+ * command aborts the wizard and is allowed through.
+ */
+export function registerWizardInput(bot: Bot, deps: BotDeps): void {
+  bot.on("message:text", async (ctx, next) => {
+    const chatId = ctx.chat.id;
+    if (!deps.wizard.isActive(chatId)) return next();
+    const text = ctx.message.text;
+    if (text.startsWith("/")) {
+      deps.wizard.abort(chatId);
+      return next();
+    }
+    const p = deps.wizard.handleText(chatId, text);
+    if (p) await renderWizardPrompt(ctx, deps, p);
+  });
+}
+
+export function registerTasks(bot: Bot, deps: BotDeps): void {
+  bot.command("tasks", (ctx) => showTasks(ctx, deps));
+  bot.command("newtask", async (ctx) => {
+    await renderWizardPrompt(ctx, deps, deps.wizard.startCreate(ctx.chat.id));
+  });
+
+  bot.callbackQuery("task:new", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    await renderWizardPrompt(ctx, deps, deps.wizard.startCreate(ctx.chat!.id));
+  });
+
+  bot.callbackQuery(new RegExp(`^task:view:${UUID}$`), async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const task = deps.tasks.get(ctx.match![1]!);
+    if (!task) return void ctx.editMessageText("Task not found.");
+    const { text, kb } = detailView(task);
+    await ctx.editMessageText(text, { reply_markup: kb });
+  });
+
+  bot.callbackQuery("task:list", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const { text, kb } = listView(deps, ctx.chat!.id);
+    await ctx.editMessageText(text, { reply_markup: kb });
+  });
+
+  bot.callbackQuery(new RegExp(`^task:toggle:${UUID}$`), async (ctx) => {
+    const task = deps.tasks.get(ctx.match![1]!);
+    if (!task) return void ctx.answerCallbackQuery({ text: "Not found" });
+    const updated = deps.tasks.update(task.id, { enabled: !task.enabled });
+    await ctx.answerCallbackQuery({ text: updated?.enabled ? "Enabled" : "Disabled" });
+    if (updated) {
+      const { text, kb } = detailView(updated);
+      await ctx.editMessageText(text, { reply_markup: kb });
+    }
+  });
+
+  bot.callbackQuery(new RegExp(`^task:run:${UUID}$`), async (ctx) => {
+    const task = deps.tasks.get(ctx.match![1]!);
+    if (!task) return void ctx.answerCallbackQuery({ text: "Not found" });
+    await ctx.answerCallbackQuery({ text: "Running now\u2026" });
+    void deps.taskRunner.run(task);
+  });
+
+  bot.callbackQuery(new RegExp(`^task:del:${UUID}$`), async (ctx) => {
+    deps.tasks.delete(ctx.match![1]!);
+    await ctx.answerCallbackQuery({ text: "Deleted" });
+    const { text, kb } = listView(deps, ctx.chat!.id);
+    await ctx.editMessageText(text, { reply_markup: kb });
+  });
+
+  bot.callbackQuery(new RegExp(`^task:editmenu:${UUID}$`), async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const task = deps.tasks.get(ctx.match![1]!);
+    if (!task) return;
+    await ctx.editMessageText(`Edit "${task.name}" — choose what to change:`, {
+      reply_markup: editMenu(task.id),
+    });
+  });
+
+  bot.callbackQuery(new RegExp(`^task:edit:(name|prompt|project|schedule):${UUID}$`), async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const field = ctx.match![1] as "name" | "prompt" | "project" | "schedule";
+    const p = deps.wizard.startEdit(ctx.chat!.id, ctx.match![2]!, field);
+    if (p) await renderWizardPrompt(ctx, deps, p);
+    else await ctx.reply("Task not found.");
+  });
+
+  // ── wizard inline steps ────────────────────────────────────────────────
+  bot.callbackQuery(/^wiz:proj:(\d+)$/, async (ctx) => {
+    const entry = deps.menuCache.getProject(ctx.chat!.id, Number(ctx.match![1]));
+    if (!entry) return void ctx.answerCallbackQuery({ text: "Expired, restart the task." });
+    await ctx.answerCallbackQuery();
+    const p = deps.wizard.setProject(ctx.chat!.id, entry.path, entry.name);
+    if (p) await renderWizardPrompt(ctx, deps, p);
+  });
+
+  bot.callbackQuery(/^wiz:sched:(once|daily|weekly|monthly|interval)$/, async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const p = deps.wizard.setScheduleType(ctx.chat!.id, ctx.match![1] as ScheduleType);
+    if (p) await renderWizardPrompt(ctx, deps, p);
+  });
+
+  bot.callbackQuery("wiz:confirm", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const p = deps.wizard.confirm(ctx.chat!.id);
+    if (p) await renderWizardPrompt(ctx, deps, p);
+  });
+
+  bot.callbackQuery("wiz:cancel", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    deps.wizard.abort(ctx.chat!.id);
+    await ctx.editMessageText("Cancelled.");
+  });
+}
+
+// ── views ────────────────────────────────────────────────────────────────
+
+function listView(deps: BotDeps, chatId: number): { text: string; kb: InlineKeyboard } {
+  const tasks = deps.tasks.forChat(chatId);
+  const kb = new InlineKeyboard();
+  if (tasks.length === 0) {
+    kb.text("\u2795 New task", "task:new");
+    return { text: "You have no scheduled tasks yet.", kb };
+  }
+  for (const t of tasks) {
+    const dot = t.enabled ? "\u{1F7E2}" : "\u26AA";
+    const name = t.name.length > 24 ? t.name.slice(0, 24) + "\u2026" : t.name;
+    kb.text(`${dot} ${name} \u00B7 ${describeSchedule(t.schedule)}`, `task:view:${t.id}`).row();
+  }
+  kb.text("\u2795 New task", "task:new");
+  return { text: `\u{1F5D3} Your scheduled tasks (${tasks.length}):`, kb };
+}
+
+function detailView(t: Task): { text: string; kb: InlineKeyboard } {
+  const next = t.nextRun ? new Date(t.nextRun).toLocaleString() : "\u2014";
+  const last = t.lastRun ? `${new Date(t.lastRun).toLocaleString()} (${t.lastStatus ?? "?"})` : "never";
+  const prompt = t.prompt.length > 300 ? t.prompt.slice(0, 300) + "\u2026" : t.prompt;
+  const text = [
+    `\u{1F5D3} ${t.name}  ${t.enabled ? "\u{1F7E2} enabled" : "\u26AA disabled"}`,
+    `\u{1F4C1} Project: ${t.projectName || basename(t.projectPath)}`,
+    `\u{1F501} Schedule: ${describeSchedule(t.schedule)}`,
+    `\u23ED Next run: ${next}`,
+    `\u23EE Last run: ${last}`,
+    "",
+    `\u{1F4AC} ${prompt}`,
+  ].join("\n");
+  const kb = new InlineKeyboard()
+    .text("\u25B6 Run now", `task:run:${t.id}`)
+    .text(t.enabled ? "\u23F8 Disable" : "\u25B6 Enable", `task:toggle:${t.id}`)
+    .row()
+    .text("\u270F\uFE0F Edit", `task:editmenu:${t.id}`)
+    .text("\u{1F5D1} Delete", `task:del:${t.id}`)
+    .row()
+    .text("\u2B05 Back", "task:list");
+  return { text, kb };
+}
+
+function editMenu(id: string): InlineKeyboard {
+  return new InlineKeyboard()
+    .text("Rename", `task:edit:name:${id}`)
+    .text("Prompt", `task:edit:prompt:${id}`)
+    .row()
+    .text("Project", `task:edit:project:${id}`)
+    .text("Schedule", `task:edit:schedule:${id}`)
+    .row()
+    .text("\u2B05 Back", `task:view:${id}`);
+}