kiro-telegram-bot 1.6.0 → 1.7.2

package/src/bot/bot.ts

@@ -30,6 +30,8 @@ import { registerPhotos } from "./handlers/photo.js";
 import { registerProjects } from "./handlers/projects.js";
 import { registerRunning, switchAndShow } from "./handlers/running.js";
 import { registerSessions } from "./handlers/sessions.js";
+import { registerSessionKill } from "./handlers/session-kill.js";
+import { registerReauth } from "./handlers/auth.js";
 import { registerSystem } from "./handlers/system.js";
 import { registerTasks, registerWizardInput } from "./handlers/tasks.js";
 import { registerUsage } from "./handlers/usage.js";
@@ -117,6 +119,11 @@ export async function createBot(cfg: AppConfig, acp: AcpClient): Promise<BotBund
   const permissions = new PermissionService(bot.api, registry);
   acp.permissionHandler = (p) => permissions.handle(p);
 
+  // The bot pins/unpins the status panel, and Telegram emits a "pinned a
+  // message" service message for each pin. Delete those so the chat stays clean
+  // — registered BEFORE auth so these bot-authored updates never reach the gate.
+  bot.on("message:pinned_message", (ctx) => void ctx.deleteMessage().catch(() => {}));
+
   bot.use(createAuthMiddleware(cfg));
 
   // Keep history clean: after handling, delete the user's command (/…) and
@@ -146,9 +153,11 @@ export async function createBot(cfg: AppConfig, acp: AcpClient): Promise<BotBund
   registerControl(bot, deps);
   registerProjects(bot, deps);
   registerSessions(bot, deps);
+  registerSessionKill(bot, deps);
   registerRunning(bot, deps);
   registerHistory(bot, deps);
   registerSystem(bot, deps);
+  registerReauth(bot, deps);
   registerUsage(bot, deps);
   registerKill(bot, deps);
   registerMcp(bot, deps);

package/src/bot/chat-controller.ts

@@ -20,6 +20,8 @@ export interface RunningSession {
   busy: boolean;
   foreground: boolean;
   unread: number;
+  /** Latest task-completion % (0–100) for this session, if known. */
+  progress?: number;
 }
 
 export interface SwitchResult {
@@ -71,6 +73,7 @@ export class ChatController {
       busy: rt.isBusy,
       foreground: rt.isForeground,
       unread: this.unreadCount(rt),
+      progress: rt.taskProgress,
     }));
   }
 
@@ -188,6 +191,13 @@ export class ChatController {
     return this.runtimes.length;
   }
 
+  /** Latest task-progress % for a controlled session id, if this chat runs it. */
+  progressFor(sessionId?: string): number | undefined {
+    if (!sessionId) return undefined;
+    this.ensureRestored();
+    return this.runtimes.find((r) => r.sessionId === sessionId)?.taskProgress;
+  }
+
   findBySession(sessionId: string): boolean {
     return this.runtimes.some((r) => r.sessionId === sessionId);
   }

package/src/bot/commands.ts

@@ -23,6 +23,7 @@ export const COMMANDS: { command: string; description: string }[] = [
   { command: "unwatch", description: "Stop following a live session" },
   { command: "model", description: "Switch model: /model <id>" },
   { command: "restart", description: "Restart the Kiro agent" },
+  { command: "reauth", description: "Log out & log in to Kiro (device flow)" },
   { command: "help", description: "Show help" },
 ];
 

package/src/bot/handlers/auth.ts

@@ -0,0 +1,89 @@
+/**
+ * /reauth — re-authenticate Kiro. Instead of always running one provider's
+ * device flow, it first shows a login-method picker (Builder ID, Google,
+ * GitHub, IAM Identity Center). The chosen method drives a logout → device-flow
+ * login → agent restart on a single, self-animated status message. Inline
+ * buttons drive the flow:
+ *   • Builder ID / Google / GitHub / IAM Identity Center — pick how to log in
+ *   • Cancel        — abort the picker or the in-flight logout/login
+ *   • Back / Change method — return to the picker
+ *   • Retry         — re-run the last method on the same message
+ *   • Restart agent — retry just the agent restart after a restart failure
+ *
+ * Power users can still skip the picker by passing flags directly, e.g.
+ * `/reauth --license pro --identity-provider <url> --region <region>`.
+ *
+ * Guarded: refused while a prompt is in flight (logging out would break the
+ * running turn) and serialised per chat so two runs can't overlap.
+ */
+import type { Bot } from "grammy";
+import type { BotDeps } from "../deps.js";
+import { type LoginMethod, ReauthController } from "../reauth-controller.js";
+
+export function registerReauth(bot: Bot, deps: BotDeps): void {
+  const controller = new ReauthController(deps.api, deps.acp, deps.cfg.kiroCliPath, () => deps.usage.account());
+
+  // IDC start-URL/region text capture. Registered before the catch-all message
+  // handler so the reply feeds the reauth flow instead of becoming a prompt.
+  bot.on("message:text", async (ctx, next) => {
+    const chatId = ctx.chat.id;
+    if (!controller.awaitingIdcInput(chatId)) return next();
+    const text = ctx.message.text;
+    if (text.startsWith("/")) return next(); // let a command through; picker stays
+    await controller.submitIdcInput(chatId, text);
+  });
+
+  bot.command("reauth", async (ctx) => {
+    if (controller.isBusy(ctx.chat.id)) {
+      await ctx.reply("\u{1F510} A re-authentication is already in progress.");
+      return;
+    }
+    const extra = (ctx.match?.toString() ?? "").trim().split(/\s+/).filter(Boolean);
+    // Explicit flags skip the picker (advanced / scripted use); otherwise ask.
+    if (extra.length > 0) await controller.begin(ctx.chat.id, extra);
+    else await controller.chooseMethod(ctx.chat.id);
+  });
+
+  bot.callbackQuery(/^reauth:method:(builder|google|github|idc)$/, async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const chatId = ctx.chat?.id;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    if (chatId !== undefined && messageId !== undefined) {
+      await controller.pickMethod(chatId, messageId, ctx.match![1] as LoginMethod);
+    }
+  });
+
+  bot.callbackQuery("reauth:choose-back", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const chatId = ctx.chat?.id;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    if (chatId !== undefined && messageId !== undefined) await controller.chooseMethod(chatId, messageId);
+  });
+
+  bot.callbackQuery("reauth:choose-cancel", async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "Cancelled" });
+    const chatId = ctx.chat?.id;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    if (chatId !== undefined && messageId !== undefined) await controller.cancelChoice(chatId, messageId);
+  });
+
+  bot.callbackQuery("reauth:cancel", async (ctx) => {
+    const chatId = ctx.chat?.id;
+    const ok = chatId !== undefined && controller.cancel(chatId);
+    await ctx.answerCallbackQuery({ text: ok ? "Cancelling\u2026" : "Nothing to cancel" });
+  });
+
+  bot.callbackQuery("reauth:retry", async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "Retrying\u2026" });
+    const chatId = ctx.chat?.id;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    if (chatId !== undefined && messageId !== undefined) await controller.retry(chatId, messageId);
+  });
+
+  bot.callbackQuery("reauth:restart", async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "Restarting agent\u2026" });
+    const chatId = ctx.chat?.id;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    if (chatId !== undefined && messageId !== undefined) await controller.restartAgent(chatId, messageId);
+  });
+}

package/src/bot/handlers/control.ts

@@ -18,8 +18,8 @@ export function registerControl(bot: Bot, deps: BotDeps): void {
       "\u{1F44B} Welcome! I bridge Telegram to Kiro CLI over ACP.",
       agent?.name ? `Connected to ${agent.name} ${agent.version ?? ""}`.trim() : "",
       "",
-      "Tap \u2630 Menu for everything. The pinned panel above always shows your",
-      "project, agent, reasoning and model. Just send a message to start.",
+      "Tap \u2630 Menu for everything. A live status panel appears while I work",
+      "(\u2630 Menu \u2192 Status shows it anytime). Just send a message to start.",
     ].filter(Boolean);
     await ctx.reply(lines.join("\n"), { reply_markup: compactKeyboard() });
     await deps.statusPanel.refresh(ctx.chat.id);

package/src/bot/handlers/kill.ts

@@ -3,14 +3,11 @@
  * holding a live session lock), excluding the bot's own agent process. Guarded
  * by an inline confirmation since it kills processes.
  */
-import { execFileSync } from "node:child_process";
 import { type Bot, type Context, InlineKeyboard } from "grammy";
-import { createLogger } from "../../logger.js";
+import { killPid } from "../../sessions/process.js";
 import type { SessionMeta } from "../../sessions/types.js";
 import type { BotDeps } from "../deps.js";
 
-const log = createLogger("killall");
-
 function targets(deps: BotDeps): SessionMeta[] {
   const self = deps.acp.pid;
   return deps.store.listActive().filter((s) => s.lockPid && s.lockPid !== self);
@@ -55,17 +52,3 @@ export function registerKill(bot: Bot, deps: BotDeps): void {
     await ctx.editMessageText(`\u{1F6D1} Killed ${killed} of ${active.length} active session(s).`).catch(() => {});
   });
 }
-
-function killPid(pid: number): boolean {
-  try {
-    if (process.platform === "win32") {
-      execFileSync("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
-    } else {
-      process.kill(pid, "SIGKILL");
-    }
-    return true;
-  } catch (e) {
-    log.debug(`kill ${pid} failed:`, (e as Error).message);
-    return false;
-  }
-}

package/src/bot/handlers/running.ts

@@ -8,6 +8,7 @@ import type { RunningSession, SwitchResult } from "../chat-controller.js";
 import type { BotDeps } from "../deps.js";
 import type { HistoryEntry } from "../../sessions/types.js";
 import { jsonlMtimeMs, readFirstPrompt } from "../../sessions/history.js";
+import { progressBar } from "../../render/progress.js";
 import { refreshMenu } from "../menu/refresh.js";
 import { sendMarkdownDoc } from "../telegram-io.js";
 
@@ -71,6 +72,7 @@ function buildRunningCard(s: RunningSession, deps: BotDeps, now: number): { text
     prompt ? `\u{1F4AC} \u201C${trunc(prompt, 120)}\u201D` : "\u{1F4AC} (no messages yet)",
     `\u{1F552} ${meta.join(" \u00B7 ")}`,
   ];
+  if (s.progress !== undefined) lines.push(`\u{1F4C8} ${progressBar(s.progress)}`);
   if (s.sessionId) lines.push(`\u{1F194} ${s.sessionId.slice(0, 8)}`);
 
   const kb = new InlineKeyboard();

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

@@ -8,11 +8,20 @@
  */
 import { InlineKeyboard } from "grammy";
 import { basename } from "node:path";
+import { progressBar } from "../../render/progress.js";
 import type { SessionMeta } from "../../sessions/types.js";
 
 export interface SessionCardExtras {
   /** Context-usage %, when the session is loaded in the current ACP process. */
   contextPct?: number;
+  /**
+   * PID of the bot's own `kiro-cli acp` process. A session locked by this PID
+   * powers the bot itself, so its card omits the Kill button (killing it would
+   * take the bot down). Other live sessions get a 🛑 Kill button.
+   */
+  selfPid?: number;
+  /** Latest task-completion % (0–100) for this session, if this chat runs it. */
+  progress?: number;
 }
 
 export interface SessionCard {
@@ -31,6 +40,7 @@ export function buildSessionCard(m: SessionMeta, extra: SessionCardExtras = {}):
   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}`);
+  if (typeof extra.progress === "number") lines.push(`\u{1F4C8} ${progressBar(extra.progress)}`);
   lines.push(`\u{1F194} ${m.sessionId.slice(0, 8)}`);
 
   const connect = m.active ? "\u{1F374} Continue (fork)" : "\u{1F517} Resume";
@@ -39,6 +49,12 @@ export function buildSessionCard(m: SessionMeta, extra: SessionCardExtras = {}):
     .text("\u{1F4DC} History", `hist:${m.sessionId}`)
     .text("\u{1F4E1} Watch", `watch:${m.sessionId}`);
 
+  // A live session running in another process can be terminated by PID. The
+  // bot's own agent (selfPid) is never offered — killing it would stop the bot.
+  if (m.active && typeof m.lockPid === "number" && m.lockPid !== extra.selfPid) {
+    keyboard.row().text(`\u{1F6D1} Kill \u00B7 pid ${m.lockPid}`, `killsess:${m.sessionId}`);
+  }
+
   return { text: lines.join("\n"), keyboard };
 }
 

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

@@ -0,0 +1,95 @@
+/**
+ * Per-session kill — terminate the OS process holding a live session's `.lock`
+ * straight from its card in /sessions or /active.
+ *
+ * Flow (callback data, UUID-keyed so it survives bot restarts):
+ *   killsess:<id>          a tap on the card's 🛑 Kill button → ask to confirm
+ *   killsess:do:<id>       confirmed → kill the lockPid, report the outcome
+ *   killsess:cancel:<id>   abort → restore the card's normal buttons
+ *
+ * Guards: the bot's own agent (acp.pid) is never killable here (its card never
+ * shows the button, and the handlers re-check), and state is re-read from disk
+ * at every step so a session that already stopped can't be "killed" twice.
+ */
+import { type Bot, type Context, InlineKeyboard } from "grammy";
+import { killPid } from "../../sessions/process.js";
+import type { SessionMeta } from "../../sessions/types.js";
+import type { BotDeps } from "../deps.js";
+import { buildSessionCard } from "./session-card.js";
+
+const UUID = "([0-9a-fA-F-]{36})";
+
+/** Rebuild the standard card keyboard for the freshest on-disk session state. */
+function cardKeyboard(deps: BotDeps, meta: SessionMeta): InlineKeyboard {
+  const contextPct = deps.acp.metadataFor(meta.sessionId)?.contextUsagePercentage;
+  return buildSessionCard(meta, { contextPct, selfPid: deps.acp.pid }).keyboard;
+}
+
+/** Re-read the session and decide whether its PID may be killed right now. */
+function killable(
+  deps: BotDeps,
+  id: string,
+): { ok: true; meta: SessionMeta; pid: number } | { ok: false; meta?: SessionMeta; reason: string } {
+  const meta = deps.store.get(id);
+  if (!meta) return { ok: false, reason: "Session not found." };
+  if (!meta.active || typeof meta.lockPid !== "number") {
+    return { ok: false, meta, reason: "Session is no longer running." };
+  }
+  if (meta.lockPid === deps.acp.pid) {
+    return { ok: false, meta, reason: "That's the bot's own agent — can't kill it." };
+  }
+  return { ok: true, meta, pid: meta.lockPid };
+}
+
+export function registerSessionKill(bot: Bot, deps: BotDeps): void {
+  // Step 1 — ask to confirm. Swap the card's buttons for a Kill/Cancel row.
+  bot.callbackQuery(new RegExp(`^killsess:${UUID}$`), async (ctx) => {
+    const id = ctx.match![1]!;
+    const check = killable(deps, id);
+    if (!check.ok) {
+      await ctx.answerCallbackQuery({ text: check.reason });
+      // The button is stale (session stopped); refresh it to the normal card.
+      if (check.meta) await ctx.editMessageReplyMarkup({ reply_markup: cardKeyboard(deps, check.meta) }).catch(() => {});
+      return;
+    }
+    await ctx.answerCallbackQuery();
+    const kb = new InlineKeyboard()
+      .text(`\u{1F6D1} Kill pid ${check.pid}`, `killsess:do:${id}`)
+      .text("\u21A9 Cancel", `killsess:cancel:${id}`);
+    await ctx.editMessageReplyMarkup({ reply_markup: kb }).catch(() => {});
+  });
+
+  // Step 2a — confirmed. Re-validate (it may have died meanwhile), then kill.
+  bot.callbackQuery(new RegExp(`^killsess:do:${UUID}$`), async (ctx) => {
+    const id = ctx.match![1]!;
+    const check = killable(deps, id);
+    if (!check.ok) {
+      await ctx.answerCallbackQuery({ text: check.reason });
+      await appendStatus(ctx, check.reason);
+      return;
+    }
+    const title = check.meta.title;
+    const ok = killPid(check.pid);
+    await ctx.answerCallbackQuery({ text: ok ? "Killed" : "Kill failed" });
+    const note = ok
+      ? `\u{1F6D1} Killed ${title} (pid ${check.pid}).`
+      : `\u26A0\uFE0F Could not kill pid ${check.pid} (already gone, or not permitted).`;
+    await appendStatus(ctx, note);
+  });
+
+  // Step 2b — cancelled. Put the card's normal buttons back.
+  bot.callbackQuery(new RegExp(`^killsess:cancel:${UUID}$`), async (ctx) => {
+    const id = ctx.match![1]!;
+    await ctx.answerCallbackQuery({ text: "Cancelled" });
+    const meta = deps.store.get(id);
+    if (meta) await ctx.editMessageReplyMarkup({ reply_markup: cardKeyboard(deps, meta) }).catch(() => {});
+    else await ctx.editMessageReplyMarkup().catch(() => {});
+  });
+}
+
+/** Append a one-line status under the card and drop its keyboard. */
+async function appendStatus(ctx: Context, note: string): Promise<void> {
+  const body = ctx.callbackQuery?.message?.text;
+  const text = body ? `${body}\n\n${note}` : note;
+  await ctx.editMessageText(text).catch(() => {});
+}

package/src/bot/handlers/sessions.ts

@@ -52,7 +52,8 @@ async function renderSessionPage(ctx: Context, deps: BotDeps, page: number): Pro
 
   for (const m of slice) {
     const contextPct = deps.acp.metadataFor(m.sessionId)?.contextUsagePercentage;
-    const { text, keyboard } = buildSessionCard(m, { contextPct });
+    const progress = deps.registry.controller(ctx.chat!.id).progressFor(m.sessionId);
+    const { text, keyboard } = buildSessionCard(m, { contextPct, selfPid: deps.acp.pid, progress });
     await deps.ephemeral.reply(ctx, text, { reply_markup: keyboard });
   }
 

package/src/bot/menu/status-panel.ts

@@ -6,6 +6,7 @@
 import { type Api, GrammyError } from "grammy";
 import { basename } from "node:path";
 import { reasoningLabel } from "../../app/reasoning.js";
+import { progressBar } from "../../render/progress.js";
 import type { SettingsStore } from "../../app/settings-store.js";
 import { createLogger } from "../../logger.js";
 import type { RuntimeRegistry } from "../registry.js";
@@ -28,32 +29,54 @@ export class StatusPanel {
     // after switching between controlled sessions in different projects.
     const project = rt.projectName || (rt.cwd ? basename(rt.cwd) : "(none)");
     const session = rt.sessionId ? rt.sessionId.slice(0, 8) : "none";
-    const state = rt.isBusy ? "\u23F3 working" : "\u2705 idle";
-    const watch = rt.isWatching ? "  \u{1F4E1} watching" : "";
     const meta = rt.contextInfo();
-    const ctx = meta?.contextUsagePercentage !== undefined ? `${meta.contextUsagePercentage.toFixed(0)}%` : "\u2014";
+    const ctxPct = meta?.contextUsagePercentage;
     const running = this.registry.controller(chatId).count();
-    const sessionLine = running > 1 ? `${session}   \u{1F9ED} ${running} controlled` : session;
-    const lines = [
-      "\u{1F4CA} Kiro \u2014 Status",
-      `\u{1F4C1} Project:   ${project}`,
-      `\u{1F916} Agent:     ${s.agent || "default"}`,
-      `\u{1F9E0} Reasoning: ${reasoningLabel(s.reasoning)}`,
-      `\u{1F9E9} Model:     ${s.model || "default"}`,
-      `\u{1F9F5} Session:   ${sessionLine}`,
-      `\u{1F4CA} Context:   ${ctx} used`,
-      `\u2699\uFE0F State:     ${state}   \u{1F4E5} Queue: ${rt.queueLength}${watch}`,
-    ];
     const subagents = this.registry.subagentSummaryForChat(chatId);
-    if (subagents) lines.push(`\u{1F465} Subagents: ${subagents}`);
+    const progress = rt.taskProgress;
+
+    const SEP = " | "; // pipe delimiter between inline fields
+    const lines: string[] = [];
+
+    // 1) Progress first — only while a turn is live (cleared when it ends), so
+    //    the collapsed pin preview shows how far along the current task is.
+    if (progress !== undefined) lines.push(`\u{1F4C8} ${progressBar(progress)}`);
+
+    // 2) Activity: state + only the counters that currently apply.
+    const activity: string[] = [rt.isBusy ? "\u23F3 Working" : "\u2705 Idle"];
+    if (rt.queueLength > 0) activity.push(`\u{1F4E5} ${rt.queueLength} queued`);
+    if (running > 1) activity.push(`\u{1F9ED} ${running} sessions`);
+    if (rt.isWatching) activity.push("\u{1F4E1} watching");
+    if (subagents) activity.push(`\u{1F465} ${subagents}`);
+    lines.push(activity.join(SEP));
+
+    // 3) Where: project | session | context usage.
+    const loc = [`\u{1F4C1} ${project}`, `\u{1F9F5} ${session}`];
+    if (ctxPct !== undefined) loc.push(`\u{1F4CA} ${ctxPct.toFixed(0)}% context`);
+    lines.push(loc.join(SEP));
+
+    // 4) How: agent | reasoning | model.
+    lines.push([`\u{1F916} ${s.agent || "default"}`, `\u{1F9E0} ${reasoningLabel(s.reasoning)}`, `\u{1F9E9} ${s.model || "default"}`].join(SEP));
+
     return lines.join("\n");
   }
 
   /** Refresh (or create + pin) the status message for a chat. */
   async refresh(chatId: number): Promise<void> {
-    const text = this.render(chatId);
+    const rt = this.registry.get(chatId);
     const id = this.settings.get(chatId).statusMessageId;
 
+    // The pinned panel exists only while there's live work — a running turn or a
+    // queued follow-up about to run. When the session is idle there's nothing to
+    // show, so remove the panel to keep the chat clean. (The on-demand /status
+    // still renders full state when explicitly requested.)
+    const active = rt.isBusy || rt.queueLength > 0;
+    if (!active) {
+      if (id) await this.remove(chatId, id);
+      return;
+    }
+
+    const text = this.render(chatId);
     if (id) {
       try {
         await this.api.editMessageText(chatId, id, text);
@@ -66,6 +89,20 @@ export class StatusPanel {
     await this.create(chatId, text);
   }
 
+  /** Remove the pinned panel (unpin + delete) and forget its id. */
+  private async remove(chatId: number, id: number): Promise<void> {
+    this.settings.update(chatId, { statusMessageId: undefined });
+    try {
+      await this.api.deleteMessage(chatId, id); // deleting a pinned message also unpins it
+    } catch {
+      try {
+        await this.api.unpinChatMessage(chatId, id);
+      } catch {
+        /* best-effort */
+      }
+    }
+  }
+
   private async create(chatId: number, text: string): Promise<void> {
     try {
       const msg = await this.api.sendMessage(chatId, text, { disable_notification: true });

package/src/bot/prompt-content.ts

@@ -9,6 +9,8 @@ import type { PromptInput } from "../app/types.js";
 export interface ContentOptions {
   reasoning?: string;
   priming?: string;
+  /** Appended at the very bottom so the agent emits a `{progress: N%}` marker. */
+  progress?: string;
 }
 
 export function buildContentBlocks(input: PromptInput, opts: ContentOptions = {}): ContentBlock[] {
@@ -28,6 +30,9 @@ export function buildContentBlocks(input: PromptInput, opts: ContentOptions = {}
   if (opts.reasoning) {
     text = `(${opts.reasoning})\n\n${text}`;
   }
+  if (opts.progress) {
+    text = `${text}\n\n${opts.progress}`;
+  }
 
   blocks.push({ type: "text", text });
   return blocks;