@llblab/pi-kit 0.1.9 → 0.1.10

package/node_modules/@llblab/pi-telegram/lib/bus.ts

@@ -816,8 +816,11 @@ export type TelegramBusEnvelope = (
           | "commit-unknown"
           | "request-id-collision"
           | "ledger-overloaded"
-          | "incompatible-protocol";
+          | "incompatible-protocol"
+          | "stale-target";
         method?: string;
+        chatId?: number;
+        threadId?: number;
       };
     }
 ) & { auth?: string };
@@ -947,6 +950,18 @@ export interface TelegramBusLocalServer {
   ensureEndpoint: () => Promise<boolean>;
 }
 
+const TELEGRAM_ACTIVE_LOCAL_SERVERS = Symbol.for(
+  "@llblab/pi-telegram/active-local-servers",
+);
+type TelegramBusServerGlobal = typeof globalThis & {
+  [TELEGRAM_ACTIVE_LOCAL_SERVERS]?: Map<string, TelegramBusLocalServer>;
+};
+
+function getActiveTelegramBusLocalServers(): Map<string, TelegramBusLocalServer> {
+  const root = globalThis as TelegramBusServerGlobal;
+  return (root[TELEGRAM_ACTIVE_LOCAL_SERVERS] ??= new Map());
+}
+
 export type TelegramBusSocketPathSource = string | (() => string);
 
 const TELEGRAM_BUS_MAX_DIRECT_UNIX_ENDPOINT_BYTES = 80;
@@ -1560,6 +1575,11 @@ export function createTelegramBusLocalServer(
     start: async () => {
       if (server) return;
       const socketPath = resolveTelegramBusSocketPath(deps.socketPath);
+      const activeServers = getActiveTelegramBusLocalServers();
+      const replacedServer = activeServers.get(socketPath);
+      if (replacedServer && replacedServer !== runtime) {
+        await replacedServer.stop();
+      }
       const usesWindowsPipe = isTelegramBusPipePath(socketPath);
       const endpointGeneration = randomBytes(8).toString("hex");
       const listenPath = usesWindowsPipe
@@ -1598,6 +1618,19 @@ export function createTelegramBusLocalServer(
           await delayTelegramBusTransportRetry(25);
         }
       }
+      if (usesWindowsPipe) {
+        await deps.beforeEndpointPublication?.();
+        const committed = deps.commitEndpointPublication
+          ? deps.commitEndpointPublication(() => {})
+          : true;
+        if (!committed) {
+          activeSocketPath = undefined;
+          activeListenPath = undefined;
+          throw new Error(
+            "Telegram bus endpoint publication lost transport ownership.",
+          );
+        }
+      }
       server = createServer((socket) => {
         sockets.add(socket);
         let buffer = "";
@@ -1631,6 +1664,7 @@ export function createTelegramBusLocalServer(
           server?.once("error", reject);
           server?.listen(listenPath, resolve);
         });
+        activeServers.set(socketPath, runtime);
         deps.recordTransportEvent?.(
           "server-started",
           getTelegramBusEndpointDiagnostics(socketPath),
@@ -1671,6 +1705,9 @@ export function createTelegramBusLocalServer(
           server = undefined;
           activeSocketPath = undefined;
           activeListenPath = undefined;
+          if (activeServers.get(socketPath) === runtime) {
+            activeServers.delete(socketPath);
+          }
           if (failedServer) {
             await new Promise<void>((resolve) =>
               failedServer.close(() => resolve()),
@@ -1686,6 +1723,12 @@ export function createTelegramBusLocalServer(
       const activeServer = server;
       const socketPath = activeSocketPath;
       const listenPath = activeListenPath;
+      if (
+        socketPath &&
+        getActiveTelegramBusLocalServers().get(socketPath) === runtime
+      ) {
+        getActiveTelegramBusLocalServers().delete(socketPath);
+      }
       server = undefined;
       activeSocketPath = undefined;
       activeListenPath = undefined;
@@ -2527,13 +2570,24 @@ function parseAckEnvelope(
       code === "commit-unknown" ||
       code === "request-id-collision" ||
       code === "ledger-overloaded" ||
-      code === "incompatible-protocol"
+      code === "incompatible-protocol" ||
+      code === "stale-target"
     ) {
+      const chatId = value.error.chatId;
+      const threadId = value.error.threadId;
+      if (
+        code === "stale-target" &&
+        (!Number.isSafeInteger(chatId) || !Number.isSafeInteger(threadId))
+      ) {
+        return undefined;
+      }
       envelope.error = {
         code,
         ...(typeof value.error.method === "string"
           ? { method: value.error.method }
           : {}),
+        ...(typeof chatId === "number" ? { chatId } : {}),
+        ...(typeof threadId === "number" ? { threadId } : {}),
       };
     }
   }

package/node_modules/@llblab/pi-telegram/lib/command-templates.ts

@@ -6,7 +6,7 @@
 
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { isAbsolute, resolve } from "node:path";
+import { extname, isAbsolute, normalize, resolve } from "node:path";
 
 export type CommandTemplateFailureScope = "continue" | "branch" | "root";
 
@@ -541,7 +541,8 @@ export function splitCommandTemplate(input: string): string[] {
   let quote: "'" | '"' | undefined;
   let escaped = false;
   let active = false;
-  for (const char of input) {
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index] ?? "";
     if (escaped) {
       current += char;
       escaped = false;
@@ -549,7 +550,16 @@ export function splitCommandTemplate(input: string): string[] {
       continue;
     }
     if (char === "\\" && quote !== "'") {
-      escaped = true;
+      const next = input[index + 1];
+      const escapesNext = quote === '"'
+        ? next === '"' || next === "\\"
+        : next !== undefined &&
+          (/\s/u.test(next) || next === "'" || next === '"' || next === "\\");
+      if (escapesNext) {
+        escaped = true;
+      } else {
+        current += "\\";
+      }
       active = true;
       continue;
     }
@@ -844,15 +854,66 @@ export async function execCommandTemplate(
   return lastResult;
 }
 
+const WINDOWS_COMMAND_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+
+function escapeWindowsCommand(value: string): string {
+  return value.replace(WINDOWS_COMMAND_META_CHARS, "^$1");
+}
+
+function escapeWindowsCommandArgument(
+  value: string,
+  doubleEscapeMetaChars: boolean,
+): string {
+  let escaped = value
+    .replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"")
+    .replace(/(?=(\\+?)?)\1$/g, "$1$1");
+  escaped = `"${escaped}"`.replace(WINDOWS_COMMAND_META_CHARS, "^$1");
+  return doubleEscapeMetaChars
+    ? escaped.replace(WINDOWS_COMMAND_META_CHARS, "^$1")
+    : escaped;
+}
+
+function resolveCommandTemplateSpawn(
+  command: string,
+  args: string[],
+): {
+  command: string;
+  args: string[];
+  windowsVerbatimArguments?: boolean;
+} {
+  if (
+    process.platform !== "win32" ||
+    ![".bat", ".cmd"].includes(extname(command).toLowerCase())
+  ) {
+    return { command, args };
+  }
+  const normalizedCommand = normalize(command);
+  const isNodeModulesShim = /[\\/]node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/iu
+    .test(normalizedCommand);
+  const shellCommand = [
+    escapeWindowsCommand(normalizedCommand),
+    ...args.map((arg) =>
+      escapeWindowsCommandArgument(arg, isNodeModulesShim)
+    ),
+  ].join(" ");
+  return {
+    command: process.env.ComSpec ?? process.env.COMSPEC ?? "cmd.exe",
+    args: ["/d", "/s", "/c", `"${shellCommand}"`],
+    windowsVerbatimArguments: true,
+  };
+}
+
 function execCommandTemplateOnce(
   command: string,
   args: string[],
   options: CommandTemplateExecOptions = {},
 ): Promise<CommandTemplateExecResult> {
   return new Promise((resolve) => {
-    const proc = spawn(command, args, {
+    const invocation = resolveCommandTemplateSpawn(command, args);
+    const proc = spawn(invocation.command, invocation.args, {
       cwd: options.cwd,
       shell: false,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
       stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
     });
     let stdout = "";

package/node_modules/@llblab/pi-telegram/lib/commands.ts

@@ -9,6 +9,7 @@ import {
   TELEGRAM_DEFAULT_PROFILE_NAME,
 } from "./config.ts";
 import type { ExtensionAPI, ExtensionCommandContext } from "./pi.ts";
+import { escapeHtml } from "./rendering.ts";
 import type { TelegramBridgeStatusLineOptions } from "./status.ts";
 import {
   createTelegramControlItemBuilder,
@@ -185,9 +186,24 @@ export function formatTelegramCommandEmojiPrefix(
   return `${getTelegramCommandEmoji(command)} `;
 }
 
+export function formatTelegramInformationHeading(
+  emoji: string,
+  text: string,
+): string {
+  return `<b>${escapeHtml(emoji)} ${escapeHtml(text)}</b>`;
+}
+
 export const TELEGRAM_COMPACTION_STARTED_TEXT =
-  `${formatTelegramCommandEmojiPrefix("compact")}Compaction started.`;
-export const TELEGRAM_COMPACTION_COMPLETED_TEXT = "✅ Compaction completed.";
+  formatTelegramInformationHeading(
+    getTelegramCommandEmoji("compact"),
+    "Compaction started.",
+  );
+export const TELEGRAM_COMPACTION_COMPLETED_TEXT =
+  formatTelegramInformationHeading("✅", "Compaction completed.");
+export const TELEGRAM_COMPACTION_STARTED_MARKDOWN =
+  `**${formatTelegramCommandEmojiPrefix("compact")}Compaction started.**`;
+export const TELEGRAM_COMPACTION_COMPLETED_MARKDOWN =
+  "**✅ Compaction completed.**";
 
 function formatTelegramBotCommandDescription(
   command: TelegramCommandEmojiName,
@@ -585,7 +601,10 @@ export interface TelegramStopCommandDeps {
   setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   abortCurrentTurn: () => void;
   updateStatus: () => void;
-  sendTextReply: (text: string) => Promise<void>;
+  sendTextReply: (
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
 }
 
 export interface TelegramRuntimeEventRecorderPort {
@@ -619,7 +638,10 @@ export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorder
     onComplete: () => void;
     onError: (error: unknown) => void;
   }) => void;
-  sendTextReply: (text: string) => Promise<void>;
+  sendTextReply: (
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
   suppressStartNotice?: boolean;
 }
 
@@ -921,8 +943,11 @@ export function createTelegramCommandTargetRuntime<
         await deps.sendTextReply(
           target.chatId,
           target.replyToMessageId,
-          "Settings menu is unavailable.",
-          { target },
+          formatTelegramInformationHeading(
+            "🚫",
+            "Settings menu is unavailable.",
+          ),
+          { target, parseMode: "HTML" },
         );
         return;
       }
@@ -1108,6 +1133,25 @@ function getTelegramCommandErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function formatTelegramCompactionFailure(error: unknown): string {
+  let message = getTelegramCommandErrorMessage(error).trim();
+  const redundantPrefixes = [
+    "Compaction failed: ",
+    "Turn prefix summarization failed: ",
+  ];
+  let stripped = true;
+  while (stripped) {
+    stripped = false;
+    for (const prefix of redundantPrefixes) {
+      if (!message.startsWith(prefix)) continue;
+      message = message.slice(prefix.length).trim();
+      stripped = true;
+    }
+  }
+  const sentence = /[.!?]$/u.test(message) ? message : `${message}.`;
+  return `Compaction failed! ${sentence}`;
+}
+
 export function parseTelegramCommand(
   text: string,
 ): ParsedTelegramCommand | undefined {
@@ -1165,7 +1209,10 @@ export async function handleTelegramStopCommand(
         ? ` Cleared ${formatTelegramQueuedTurnCount(clearedCount)}.`
         : "";
     if (clearedCount > 0) deps.updateStatus();
-    await deps.sendTextReply(`No active turn.${clearedSuffix}`);
+    await deps.sendTextReply(
+      formatTelegramInformationHeading("💤", `No active turn.${clearedSuffix}`),
+      { parseMode: "HTML" },
+    );
     return;
   }
   deps.abortCurrentTurn();
@@ -1174,7 +1221,13 @@ export async function handleTelegramStopCommand(
     clearedCount > 0
       ? ` Cleared ${formatTelegramQueuedTurnCount(clearedCount)}.`
       : "";
-  await deps.sendTextReply(`Aborted current turn.${clearedSuffix}`);
+  await deps.sendTextReply(
+    formatTelegramInformationHeading(
+      "⏹️",
+      `Aborted current turn.${clearedSuffix}`,
+    ),
+    { parseMode: "HTML" },
+  );
 }
 
 export async function handleTelegramAbortCommand(deps: {
@@ -1184,17 +1237,26 @@ export async function handleTelegramAbortCommand(deps: {
   abortCurrentTurn: () => void;
   setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
   updateStatus: () => void;
-  sendTextReply: (text: string) => Promise<void>;
+  sendTextReply: (
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
 }): Promise<void> {
   deps.clearPendingModelSwitch();
   if (!deps.hasAbortHandler()) {
-    await deps.sendTextReply("No active turn.");
+    await deps.sendTextReply(
+      formatTelegramInformationHeading("💤", "No active turn."),
+      { parseMode: "HTML" },
+    );
     return;
   }
   deps.setFoldQueuedPromptsIntoHistory(deps.hasActiveTelegramTurn());
   deps.abortCurrentTurn();
   deps.updateStatus();
-  await deps.sendTextReply("Aborted current turn.");
+  await deps.sendTextReply(
+    formatTelegramInformationHeading("⏹️", "Aborted current turn."),
+    { parseMode: "HTML" },
+  );
 }
 
 export async function handleTelegramNextCommand(deps: {
@@ -1213,7 +1275,10 @@ export async function handleTelegramNextCommand(deps: {
 }): Promise<void> {
   deps.clearPendingModelSwitch();
   if (!deps.hasQueuedItems()) {
-    await deps.sendTextReply("<b>Queue is empty.</b>", { parseMode: "HTML" });
+    await deps.sendTextReply(
+      formatTelegramInformationHeading("⌛", "Queue is empty."),
+      { parseMode: "HTML" },
+    );
     return;
   }
   if (!deps.isIdle() && deps.hasAbortHandler()) {
@@ -1221,17 +1286,30 @@ export async function handleTelegramNextCommand(deps: {
     deps.abortCurrentTurn();
     deps.updateStatus();
     await deps.sendTextReply(
-      "Aborted current turn. Dispatching next queued turn.",
+      formatTelegramInformationHeading(
+        "⏩",
+        "Aborted! Dispatching next queued turn.",
+      ),
+      { parseMode: "HTML" },
     );
     return;
   }
   if (!deps.isIdle()) {
-    await deps.sendTextReply("Pi is busy. Send /abort or /stop first.");
+    await deps.sendTextReply(
+      formatTelegramInformationHeading(
+        "⏳",
+        "Pi is busy. Send /abort or /stop first.",
+      ),
+      { parseMode: "HTML" },
+    );
     return;
   }
   deps.dispatchNextQueuedTurn();
   deps.updateStatus();
-  await deps.sendTextReply("Dispatching next queued turn.");
+  await deps.sendTextReply(
+    formatTelegramInformationHeading("▶️", "Dispatching next queued turn."),
+    { parseMode: "HTML" },
+  );
 }
 
 export async function handleTelegramContinueCommand<TMessage, TContext>(
@@ -1301,15 +1379,15 @@ export async function handleTelegramCompactConfirmationCallback<TContext>(
   const chatId = callbackMessage?.chat?.id;
   const messageId = callbackMessage?.message_id;
   if (typeof chatId !== "number" || typeof messageId !== "number") {
-    await deps.answerCallbackQuery(query.id, "Interactive message expired.");
+    await deps.answerCallbackQuery(query.id, "⌛ Interactive message expired.");
     return true;
   }
   if (query.data === "compact:cancel") {
     await deps.editInteractiveMessage(
       chatId,
       messageId,
-      "Compaction cancelled.",
-      "plain",
+      "<b>🚫 Compaction cancelled.</b>",
+      "html",
       { inline_keyboard: [] },
     );
     await deps.answerCallbackQuery(query.id);
@@ -1319,7 +1397,7 @@ export async function handleTelegramCompactConfirmationCallback<TContext>(
     chatId,
     messageId,
     TELEGRAM_COMPACTION_STARTED_TEXT,
-    "plain",
+    "html",
     { inline_keyboard: [] },
   );
   await deps.answerCallbackQuery(query.id);
@@ -1345,7 +1423,11 @@ export async function handleTelegramCompactCommand(
     deps.isCompactionInProgress()
   ) {
     await deps.sendTextReply(
-      "Cannot compact while Pi or the Telegram queue is busy. Wait for queued turns to finish or send /abort first.",
+      formatTelegramInformationHeading(
+        "⏳",
+        "Cannot compact while Pi or the Telegram queue is busy. Wait for queued turns to finish or send /abort first.",
+      ),
+      { parseMode: "HTML" },
     );
     return;
   }
@@ -1359,7 +1441,9 @@ export async function handleTelegramCompactCommand(
         deps.setCompactionInProgress(false);
         deps.updateStatus();
         dispatchNextQueuedTelegramTurnAfterCompact(deps);
-        void deps.sendTextReply(TELEGRAM_COMPACTION_COMPLETED_TEXT);
+        void deps.sendTextReply(TELEGRAM_COMPACTION_COMPLETED_TEXT, {
+          parseMode: "HTML",
+        });
       },
       onError: (error) => {
         deps.stopTypingLoop?.();
@@ -1367,8 +1451,13 @@ export async function handleTelegramCompactCommand(
         deps.updateStatus();
         dispatchNextQueuedTelegramTurnAfterCompact(deps);
         deps.recordRuntimeEvent?.("compact", error);
-        const errorMessage = getTelegramCommandErrorMessage(error);
-        void deps.sendTextReply(`Compaction failed: ${errorMessage}`);
+        void deps.sendTextReply(
+          formatTelegramInformationHeading(
+            "⚠️",
+            formatTelegramCompactionFailure(error),
+          ),
+          { parseMode: "HTML" },
+        );
       },
     });
   } catch (error) {
@@ -1376,14 +1465,19 @@ export async function handleTelegramCompactCommand(
     deps.setCompactionInProgress(false);
     deps.updateStatus();
     deps.recordRuntimeEvent?.("compact", error);
-    const errorMessage = getTelegramCommandErrorMessage(error);
-    await deps.sendTextReply(`Compaction failed: ${errorMessage}`);
+    await deps.sendTextReply(
+      formatTelegramInformationHeading(
+        "⚠️",
+        formatTelegramCompactionFailure(error),
+      ),
+      { parseMode: "HTML" },
+    );
     return;
   }
   if (!deps.suppressStartNotice) {
-    await deps.sendTextReply(
-      TELEGRAM_COMPACTION_STARTED_TEXT,
-    );
+    await deps.sendTextReply(TELEGRAM_COMPACTION_STARTED_TEXT, {
+      parseMode: "HTML",
+    });
   }
 }
 

package/node_modules/@llblab/pi-telegram/lib/journal.ts

@@ -3381,15 +3381,8 @@ export function createTelegramUpdateJournalStore(
         const recoveredUpdateIds = [...requestedIds].sort((a, b) => a - b);
         const published = publishMutation(
           current,
-          current.file.entries.map((entry) =>
-            requestedIds.has(entry.updateId)
-              ? {
-                  updateId: entry.updateId,
-                  update: entry.update,
-                  admittedAtMs: entry.admittedAtMs,
-                  state: "pending" as const,
-                }
-              : entry,
+          current.file.entries.filter(
+            (entry) => !requestedIds.has(entry.updateId),
           ),
           true,
         );

package/node_modules/@llblab/pi-telegram/lib/lifecycle.ts

@@ -345,25 +345,27 @@ export function createTelegramBridgeSessionLifecycleAssembly<
     stopPolling: suspendForReplacement,
     clearPendingMediaGroups: deps.services.suspendGroupedInput,
   });
-  const servicesLifecycle = appendTelegramLifecycleHooks(
-    queueLifecycle,
-    {
-      async onSessionStart(event, ctx) {
-        deps.services.resumeGroupedInput(ctx);
-        await deps.services.delivery.onSessionStart();
-        await deps.services.polling.onSessionStart(event, ctx);
-        deps.services.capabilityMonitor.start(ctx);
-        deps.services.queueWatchdog.start(ctx);
-      },
-      async onSessionShutdown() {
-        await deps.services.delivery.onSessionShutdown();
-        deps.services.queueWatchdog.stop();
-        deps.services.capabilityMonitor.stop();
-        await deps.services.inboundWorker.onSessionShutdown();
-      },
+  const servicesLifecycle: TelegramSessionLifecycleHooks = {
+    async onSessionStart(event, ctx) {
+      await queueLifecycle.onSessionStart(event, ctx);
+      if (!isSessionActive(ctx)) return;
+      deps.services.resumeGroupedInput(ctx);
+      await deps.services.delivery.onSessionStart();
+      await deps.services.polling.onSessionStart(event, ctx);
+      deps.services.capabilityMonitor.start(ctx);
+      deps.services.queueWatchdog.start(ctx);
     },
-    isSessionActive,
-  );
+    async onSessionShutdown(event, ctx) {
+      if (!isSessionActive(ctx)) return;
+      await deps.services.delivery.onSessionShutdown();
+      if (!isSessionActive(ctx)) return;
+      deps.services.queueWatchdog.stop();
+      deps.services.capabilityMonitor.stop();
+      await queueLifecycle.onSessionShutdown(event, ctx);
+      if (!isSessionActive(ctx)) return;
+      await deps.services.inboundWorker.onSessionShutdown();
+    },
+  };
   const followerLifecycle = appendTelegramLifecycleHooks(
     servicesLifecycle,
     {

package/node_modules/@llblab/pi-telegram/lib/locks.ts

@@ -423,7 +423,12 @@ function reclaimAbandonedDirectoryGuard(
     // Claim inside the still-occupied guard before making its stable path free.
     renameRecovery(sourcePath, reclaimPath);
   } catch (error) {
-    if ((error as { code?: unknown })?.code === "ENOENT") return false;
+    const code = (error as { code?: unknown })?.code;
+    if (code === "ENOENT") return false;
+    // macOS may report EINVAL instead of ENOENT when another process wins
+    // the same source rename. Only classify it as contention once the
+    // observed source is actually gone; preserve unrelated EINVAL failures.
+    if (code === "EINVAL" && !existsSync(sourcePath)) return false;
     throw error;
   }
 

package/node_modules/@llblab/pi-telegram/lib/menu-queue.ts

@@ -73,6 +73,10 @@ function toTelegramQueueMenuItems<Context>(
   });
 }
 
+function formatSkippedTelegramQueuePosition(position: number): string {
+  return Array.from(String(position), (char) => `${char}\u0335`).join("");
+}
+
 function buildTelegramQueueMenuReplyMarkup(
   items: readonly TelegramQueueMenuItem[],
   emptyRefreshIndex = 0,
@@ -86,7 +90,7 @@ function buildTelegramQueueMenuReplyMarkup(
       : "queue:refresh";
   const refreshRow = [{ text: "🌀 Refresh", callback_data: refreshData }];
   if (items.length === 0) return { inline_keyboard: [backRow, refreshRow] };
-  const rows = items.map((item, index) => {
+  const rows = items.map((item) => {
     const prefix = item.reactionSuppressionEmoji
       ? `${item.reactionSuppressionEmoji} `
       : item.isPriority
@@ -94,7 +98,11 @@ function buildTelegramQueueMenuReplyMarkup(
         : item.hasAttachments
           ? "📎 "
           : "";
-    const label = `${index + 1}. ${prefix}${item.statusSummary}`;
+    const position = item.reactionSuppressionEmoji
+      ? formatSkippedTelegramQueuePosition(item.queuePosition)
+      : String(item.queuePosition);
+    const ordinalSeparator = item.reactionSuppressionEmoji ? "\u200A" : "";
+    const label = `${position}${ordinalSeparator}. ${prefix}${item.statusSummary}`;
     return [
       {
         text: label,
@@ -162,7 +170,10 @@ function getTelegramQueueMenuItemText(item: TelegramQueueMenuItem): string {
     : item.isPriority
       ? ` ${item.priorityEmoji ?? "⚡"}`
       : "";
-  const heading = `<b>${item.queuePosition}.</b>${badge}`;
+  const position = item.reactionSuppressionEmoji
+    ? `<s>${item.queuePosition}</s>.`
+    : `<b>${item.queuePosition}.</b>`;
+  const heading = `${position}${badge}`;
   const preview = `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
   return `${heading}\n${preview}`;
 }
@@ -182,7 +193,7 @@ function buildTelegramQueueItemSubmenuReplyMarkup(
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:priority`,
         },
         {
-          text: isPriority ? "⚫️ Normal" : "🟣 Normal",
+          text: isPriority ? "⚫️ Normal" : "🔵 Normal",
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:normal`,
         },
       ],