blun-king-cli 9.1.404 → 9.1.406

package/LIESMICH.txt

@@ -307,11 +307,15 @@ Rechner aus Telegram prüfen
 ----------------------------
 Der Telegram-Befehl /status prüft die lokale Verbindung ohne Modellaufruf. Er
 zeigt den Rechnernamen, die installierte BLUN-Version, die Laufzeit der
-Telegram-Brücke, die Verbindung zur Konsole, den aktuellen Zustellweg und die
-Größe der Eingangswarteschlange. Damit bleibt der Zustand auch dann abfragbar,
-wenn die Konsole hängt oder der Modellanbieter ausgelastet ist. Die Ausgabe enthält keine
-Chat-IDs, Dateipfade, Zugangsdaten oder Nachrichteninhalte. Nicht verbundene
-Absender erhalten weiterhin nur die Kopplungsanweisung.
+Telegram-Brücke, die Verbindung und Laufzeit der Konsole, den aktuellen
+Zustellweg, den Konsolen-Herzschlag, den letzten Warteschlangen-Fortschritt sowie
+den aktuellen Arbeitsschritt. Die Warteschlange wird als tatsächlich ungelesener
+Anteil und Gesamtgröße gemessen; ein Prüfpunkt wird nur für exakt dieselbe
+Warteschlangendatei akzeptiert. Damit bleibt der Zustand auch dann abfragbar,
+wenn die Konsole hängt oder der Modellanbieter ausgelastet ist. Die Ausgabe
+enthält keine Chat-IDs, Dateipfade, Zugangsdaten, Nachrichteninhalte oder
+vollständigen Aufgabenlisten. Nicht verbundene Absender erhalten weiterhin nur
+die Kopplungsanweisung.
 
 Nachweisbare Arbeitsabläufe
 ---------------------------
@@ -400,6 +404,19 @@ Bei identischem Inhalt bleiben Dateidentität und Änderungszeit erhalten; die
 Prüfung und Härtung der privaten Dateirechte läuft trotzdem weiter. Echte
 Änderungen verwenden unverändert den crash-sicheren atomaren Schreibweg.
 
+Verlässliche Beziehungskontinuität
+----------------------------------
+
+Ab BLUN King 9.1.406 wird ein erneut zugestelltes privates Telegram-Ereignis
+mit demselben Zeitstempel und Text nur einmal gespeichert. Eine tatsächlich
+später wiederholte Aussage bleibt dagegen Teil des Verlaufs.
+
+Natürliche ausdrückliche Hinweise wie „Dieter ist dein Boss, bitte merken“
+werden auch dann erkannt, wenn die Bitte um Erinnerung am Ende steht. Sie
+gelangen als Referenzdaten in einen begrenzten, nur ergänzbaren
+Beziehungskontext. Sie erteilen oder ändern niemals Berechtigungen;
+Gruppeninhalte, Geheimnisse und Zugriffsaussagen bleiben ausgeschlossen.
+
 Der eigentliche Anhang und die vollständige Nutzernachricht bleiben für den Zug
 unverändert verfügbar. Die Begrenzung betrifft ausschließlich die kleine
 lexikalische Vorauswahl von höchstens zwei Werkzeugschemas; ToolSearch und alle

package/README.md

@@ -313,11 +313,15 @@ Sicherheitsgründen als normale Chatnachrichten behandelt.
 
 Der Telegram-Befehl `/status` prüft die lokale Verbindung ohne Modellaufruf.
 Er zeigt den Rechnernamen, die installierte BLUN-Version, die Laufzeit der
-Telegram-Brücke, die Verbindung zur Konsole, den aktuellen Zustellweg und die
-Größe der Eingangswarteschlange. Damit bleibt der Zustand auch dann abfragbar,
-wenn die Konsole hängt oder der Modellanbieter ausgelastet ist. Die Ausgabe enthält keine
-Chat-IDs, Dateipfade, Zugangsdaten oder Nachrichteninhalte. Nicht verbundene
-Absender erhalten weiterhin nur die Kopplungsanweisung.
+Telegram-Brücke, die Verbindung und Laufzeit der Konsole, den aktuellen
+Zustellweg, den Konsolen-Herzschlag, den letzten Warteschlangen-Fortschritt sowie
+den aktuellen Arbeitsschritt. Die Warteschlange wird als tatsächlich ungelesener
+Anteil und Gesamtgröße gemessen; ein Prüfpunkt wird nur für exakt dieselbe
+Warteschlangendatei akzeptiert. Damit bleibt der Zustand auch dann abfragbar,
+wenn die Konsole hängt oder der Modellanbieter ausgelastet ist. Die Ausgabe
+enthält keine Chat-IDs, Dateipfade, Zugangsdaten, Nachrichteninhalte oder
+vollständigen Aufgabenlisten. Nicht verbundene Absender erhalten weiterhin nur
+die Kopplungsanweisung.
 
 Beim ersten Start werden das Telegram-Plugin und die mitgelieferten Skills
 eingerichtet. Die Anmeldung erfolgt anschließend in der
@@ -408,6 +412,18 @@ Bei identischem Inhalt bleiben Dateidentität und Änderungszeit erhalten; die
 Prüfung und Härtung der privaten Dateirechte läuft trotzdem weiter. Echte
 Änderungen verwenden unverändert den crash-sicheren atomaren Schreibweg.
 
+## Verlässliche Beziehungskontinuität
+
+Ab BLUN King 9.1.406 wird ein erneut zugestelltes privates Telegram-Ereignis
+mit demselben Zeitstempel und Text nur einmal gespeichert. Eine tatsächlich
+später wiederholte Aussage bleibt dagegen Teil des Verlaufs.
+
+Natürliche ausdrückliche Hinweise wie „Dieter ist dein Boss, bitte merken“
+werden auch dann erkannt, wenn die Bitte um Erinnerung am Ende steht. Sie
+gelangen als Referenzdaten in einen begrenzten, nur ergänzbaren
+Beziehungskontext. Sie erteilen oder ändern niemals Berechtigungen;
+Gruppeninhalte, Geheimnisse und Zugriffsaussagen bleiben ausgeschlossen.
+
 Der eigentliche Anhang und die vollständige Nutzernachricht bleiben für den Zug
 unverändert verfügbar. Die Begrenzung betrifft ausschließlich die kleine
 lexikalische Vorauswahl von höchstens zwei Werkzeugschemas; ToolSearch und alle

package/bin/relationship-continuity-policy.cjs

@@ -86,6 +86,22 @@ function attentionForReturn({ root, agentId, actorId, previousAt, currentAt }) {
   return writeJsonAtomic(root, target, attention) ? attention : undefined;
 }
 
+function normalizedJournalEntries(value) {
+  if (!Array.isArray(value)) return [];
+  const entries = [];
+  const seen = new Set();
+  for (const entry of value) {
+    const occurredAt = trustedTimestamp(entry?.occurred_at);
+    const text = redactSecrets(entry?.text);
+    if (!occurredAt || !text) continue;
+    const key = `${occurredAt}\0${text}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    entries.push({ occurred_at: occurredAt, text });
+  }
+  return entries.slice(-MAX_ENTRIES);
+}
+
 function prepareRelationshipTurn(input = {}) {
   const root = path.resolve(String(input.root ?? ''));
   const agentId = safeId(input.agentId);
@@ -98,14 +114,14 @@ function prepareRelationshipTurn(input = {}) {
   const text = redactSecrets(input.text);
   const target = path.resolve(root, 'agents', agentId, 'journal', 'recent', `${actorId}.json`);
   const existing = readJson(root, target);
-  const entries = Array.isArray(existing?.entries)
-    ? existing.entries.filter((entry) => trustedTimestamp(entry?.occurred_at) && typeof entry?.text === 'string').slice(-MAX_ENTRIES)
-    : [];
-  const previous = entries.at(-1);
-  const recent = entries.slice(-MAX_RECENT_CONTEXT).map((entry) => ({
-    occurred_at: trustedTimestamp(entry.occurred_at),
-    text: redactSecrets(entry.text),
-  }));
+  const rawEntries = Array.isArray(existing?.entries) ? existing.entries.slice(-MAX_ENTRIES) : [];
+  const entries = normalizedJournalEntries(rawEntries);
+  const currentKey = text ? `${occurredAt}\0${text}` : '';
+  const historical = currentKey
+    ? entries.filter((entry) => `${entry.occurred_at}\0${entry.text}` !== currentKey)
+    : entries;
+  const previous = historical.at(-1);
+  const recent = historical.slice(-MAX_RECENT_CONTEXT);
   const attention = attentionForReturn({
     root,
     agentId,
@@ -115,8 +131,11 @@ function prepareRelationshipTurn(input = {}) {
   });
 
   if (text) {
-    const next = [...entries, { occurred_at: occurredAt, text }].slice(-MAX_ENTRIES);
-    writeJsonAtomic(root, target, { version: 1, actor_id: actorId, entries: next });
+    const alreadyStored = entries.some((entry) => `${entry.occurred_at}\0${entry.text}` === currentKey);
+    const next = alreadyStored ? entries : [...entries, { occurred_at: occurredAt, text }].slice(-MAX_ENTRIES);
+    if (JSON.stringify(next) !== JSON.stringify(rawEntries)) {
+      writeJsonAtomic(root, target, { version: 1, actor_id: actorId, entries: next });
+    }
   }
   return { recent, attention };
 }

package/bin/relationship-learning-policy.cjs

@@ -30,6 +30,7 @@ const CANDIDATE_PATTERNS = [
     kind: 'explicit_relationship_note',
     patterns: [
       /^(?:bitte\s+)?merk(?:e)?\s+dir\s*(?::|,|\s+dass\s+)?\s*(.+)$/iu,
+      /^(.+?)(?:\s*[,;:\u2014-]\s*|\s+)bitte\s+merken[.!?]*$/iu,
       /^(?:please\s+)?remember(?:\s+that)?\s*(?::|,)?\s*(.+)$/iu,
     ],
   },

package/bin/telegram-console-status-policy.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+const { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const STATUS_FILE = 'telegram-console-status.json';
+const MAX_STATUS_BYTES = 16_384;
+const MAX_TASK_CHARS = 240;
+
+function validInstant(value) {
+  if (typeof value !== 'string' || value.length === 0) return undefined;
+  return Number.isFinite(Date.parse(value)) ? value : undefined;
+}
+
+function boundedTask(value) {
+  if (typeof value !== 'string') return undefined;
+  const title = value.replace(/\s+/gu, ' ').trim();
+  return title.length > 0 ? title.slice(0, MAX_TASK_CHARS) : undefined;
+}
+
+function buildTelegramConsoleStatus(input = {}) {
+  const capturedAt = validInstant(input.capturedAt);
+  const processStartedAt = validInstant(input.processStartedAt);
+  const pid = Number.isSafeInteger(input.pid) && input.pid > 1 ? input.pid : undefined;
+  const step = Number.isSafeInteger(input.step) && input.step >= 0 ? input.step : 0;
+  if (capturedAt === undefined || processStartedAt === undefined || pid === undefined
+      || typeof input.turnActive !== 'boolean') {
+    throw new TypeError('invalid Telegram console status');
+  }
+  const activeTask = input.turnActive
+    ? boundedTask(input.todos?.find((todo) => todo?.status === 'in_progress')?.title)
+    : undefined;
+  return {
+    version: 1,
+    pid,
+    capturedAt,
+    processStartedAt,
+    turnActive: input.turnActive,
+    step,
+    ...(activeTask === undefined ? {} : { activeTask }),
+  };
+}
+
+function parseTelegramConsoleStatus(value, options = {}) {
+  try {
+    const text = typeof value === 'string' ? value : JSON.stringify(value);
+    if (text.length === 0 || Buffer.byteLength(text, 'utf8') > MAX_STATUS_BYTES) return undefined;
+    const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+    if (parsed?.version !== 1 || !Number.isSafeInteger(parsed.pid) || parsed.pid <= 1
+        || (options.expectedPid !== undefined && parsed.pid !== options.expectedPid)
+        || validInstant(parsed.capturedAt) === undefined
+        || validInstant(parsed.processStartedAt) === undefined
+        || typeof parsed.turnActive !== 'boolean'
+        || !Number.isSafeInteger(parsed.step) || parsed.step < 0) return undefined;
+    const activeTask = boundedTask(parsed.activeTask);
+    return {
+      version: 1,
+      pid: parsed.pid,
+      capturedAt: parsed.capturedAt,
+      processStartedAt: parsed.processStartedAt,
+      turnActive: parsed.turnActive,
+      step: parsed.step,
+      ...(parsed.turnActive && activeTask !== undefined ? { activeTask } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function writeTelegramConsoleStatus(input = {}) {
+  const status = buildTelegramConsoleStatus(input);
+  const directory = input.directory;
+  if (typeof directory !== 'string' || directory.length === 0) {
+    throw new TypeError('invalid Telegram console status directory');
+  }
+  mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const target = join(directory, STATUS_FILE);
+  const temporary = join(directory, `.telegram-console-status.${status.pid}.${Date.now()}.tmp`);
+  try {
+    writeFileSync(temporary, `${JSON.stringify(status)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(temporary, target);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+  return status;
+}
+
+function readTelegramConsoleStatus(directory, options = {}) {
+  try {
+    return parseTelegramConsoleStatus(readFileSync(join(directory, STATUS_FILE), 'utf8'), options);
+  } catch {
+    return undefined;
+  }
+}
+
+module.exports = {
+  STATUS_FILE,
+  buildTelegramConsoleStatus,
+  parseTelegramConsoleStatus,
+  readTelegramConsoleStatus,
+  writeTelegramConsoleStatus,
+};

package/bin/telegram-remote-status-policy.cjs

@@ -23,8 +23,35 @@ function formatDuration(seconds) {
 function formatBytes(bytes) {
   const value = Math.max(0, Number(bytes) || 0);
   if (value < 1024) return `${Math.round(value)} B`;
-  if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KB`;
-  return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+  if (value < 1024 * 1024) return `${(value / 1024).toFixed(1).replace('.', ',')} KB`;
+  return `${(value / (1024 * 1024)).toFixed(1).replace('.', ',')} MB`;
+}
+
+function formatAge(value, capturedAt) {
+  const then = Date.parse(value);
+  const now = Date.parse(capturedAt);
+  if (!Number.isFinite(then) || !Number.isFinite(now) || then > now) return undefined;
+  const seconds = Math.floor((now - then) / 1000);
+  return seconds < 60 ? `vor ${seconds} s` : `vor ${formatDuration(seconds)}`;
+}
+
+function resolveTelegramQueueSnapshot(input = {}) {
+  const totalBytes = Number.isSafeInteger(input.queueBytes) && input.queueBytes >= 0
+    ? input.queueBytes
+    : 0;
+  const checkpoint = input.checkpoint;
+  const checkpointValid = checkpoint?.version === 1
+    && typeof input.queueFileId === 'string'
+    && input.queueFileId.length > 0
+    && checkpoint.fileId === input.queueFileId
+    && Number.isSafeInteger(checkpoint.offset)
+    && checkpoint.offset >= 0
+    && checkpoint.offset <= totalBytes;
+  return {
+    totalBytes,
+    unreadBytes: checkpointValid ? totalBytes - checkpoint.offset : undefined,
+    checkpointValid,
+  };
 }
 
 function buildTelegramRemoteStatus(input) {
@@ -34,11 +61,23 @@ function buildTelegramRemoteStatus(input) {
 
   const username = input.username ? `@${String(input.username).replace(/^@/u, '')}` : 'verbundener Nutzer';
   const tui = input.tuiFresh
-    ? `verbunden${Number.isInteger(input.tuiPid) ? ` (PID ${input.tuiPid})` : ''}`
+    ? `verbunden${Number.isInteger(input.tuiPid) ? ` (PID ${input.tuiPid}${input.consoleStatus?.processStartedAt
+      ? `, ${formatDuration((Date.parse(input.capturedAt) - Date.parse(input.consoleStatus.processStartedAt)) / 1000)}`
+      : ''})` : ''}`
     : 'nicht verbunden';
   const delivery = input.deliveryTarget === 'tui'
     ? 'Konsolen-Warteschlange'
     : 'Brücke ohne Konsole';
+  const heartbeatAge = formatAge(input.tuiHeartbeatAt, input.capturedAt);
+  const checkpointAge = formatAge(input.queueCheckpointAt, input.capturedAt);
+  const workLines = input.consoleStatus === undefined
+    ? ['Arbeitsstatus: nicht verfügbar']
+    : input.consoleStatus.turnActive
+      ? [
+          `Arbeitsstatus: aktiv, Schritt ${input.consoleStatus.step}`,
+          ...(input.consoleStatus.activeTask === undefined ? [] : [`Aktive Aufgabe: ${input.consoleStatus.activeTask}`]),
+        ]
+      : ['Arbeitsstatus: Leerlauf'];
   return [
     `BLUN-Fernstatus für ${username}`,
     `Rechner: ${input.machineName || 'unbekannt'}`,
@@ -46,7 +85,10 @@ function buildTelegramRemoteStatus(input) {
     `Brücke: aktiv (PID ${input.bridgePid}, ${formatDuration(input.bridgeUptimeSeconds)})`,
     `Konsole: ${tui}`,
     `Zustellung: ${delivery}`,
-    `Warteschlange: ${formatBytes(input.queueBytes)}`,
+    `Warteschlange: ${input.queueUnreadBytes === undefined ? 'unbekannt' : `${formatBytes(input.queueUnreadBytes)} ungelesen`} (${formatBytes(input.queueBytes)} gesamt)`,
+    ...(heartbeatAge === undefined ? [] : [`Konsolen-Herzschlag: ${heartbeatAge}`]),
+    ...(checkpointAge === undefined ? [] : [`Warteschlangen-Fortschritt: ${checkpointAge}`]),
+    ...workLines,
     `Gemessen: ${input.capturedAt}`,
   ].join('\n');
 }
@@ -55,5 +97,6 @@ module.exports = {
   buildTelegramRemoteStatus,
   formatBytes,
   formatDuration,
+  resolveTelegramQueueSnapshot,
   resolveTelegramRemoteVersion,
 };

package/blun.mjs

@@ -5,6 +5,7 @@ import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
 import { createRequire } from "node:module";
+import telegramConsoleStatusPolicy from "./bin/telegram-console-status-policy.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs$16 from "node:fs";
 import Kt, { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, promises, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -34,6 +35,7 @@ import * as posixPath from "node:path/posix";
 import * as win32Path from "node:path/win32";
 import { createServer } from "node:http";
 import { pipeline as pipeline$1 } from "node:stream/promises";
+const { writeTelegramConsoleStatus } = telegramConsoleStatusPolicy;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -511029,6 +511031,8 @@ var StreamingUIController = class {
 	pendingToolCallFlushIds = /* @__PURE__ */ new Set();
 	_currentTurnId = void 0;
 	_currentStep = 0;
+	_remoteTodos = [];
+	_remoteProcessStartedAt = new Date(Date.now() - process.uptime() * 1e3).toISOString();
 	_liveTurnStartedAtMs = void 0;
 	_liveOutputTokens = new LiveOutputTokenCounter();
 	_countedToolCallIds = /* @__PURE__ */ new Set();
@@ -511054,9 +511058,25 @@ var StreamingUIController = class {
 	}
 	setTurnId(turnId) {
 		this._currentTurnId = turnId;
+		this.publishTelegramConsoleStatus();
 	}
 	setStep(step) {
 		this._currentStep = step;
+		this.publishTelegramConsoleStatus();
+	}
+	publishTelegramConsoleStatus() {
+		if (!telegramChannelAttachEnabled()) return;
+		try {
+			writeTelegramConsoleStatus({
+				directory: telegramStateDir(),
+				capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				pid: process.pid,
+				processStartedAt: this._remoteProcessStartedAt,
+				step: this._currentStep,
+				todos: this._remoteTodos,
+				turnActive: this._currentTurnId !== void 0
+			});
+		} catch {}
 	}
 	hasActiveTurn() {
 		return this._currentTurnId !== void 0;
@@ -511364,8 +511384,10 @@ var StreamingUIController = class {
 		this._pendingReadGroup = null;
 		this._currentTurnId = void 0;
 		this._currentStep = 0;
+		this._remoteTodos = [];
 		this._streamingToolCallArguments.clear();
 		this.pendingToolCallFlushIds.clear();
+		this.publishTelegramConsoleStatus();
 		this.host.state.ui.requestRender();
 	}
 	disposeActiveThinkingComponent() {
@@ -511627,9 +511649,11 @@ var StreamingUIController = class {
 	}
 	setTodoList(todos) {
 		const { state } = this.host;
+		this._remoteTodos = todos;
 		state.todoPanel.setTodos(todos);
 		state.todoPanelContainer.clear();
 		if (!state.todoPanel.isEmpty()) state.todoPanelContainer.addChild(state.todoPanel);
+		this.publishTelegramConsoleStatus();
 		state.ui.requestRender();
 	}
 	beginCompaction(instruction) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.404",
+  "version": "9.1.406",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {

package/telegram-plugin/dist/bridge.mjs

@@ -7,9 +7,11 @@ import { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { hostname } from "node:os";
 import remoteStatusPolicy from "../../bin/telegram-remote-status-policy.cjs";
+import consoleStatusPolicy from "../../bin/telegram-console-status-policy.cjs";
 import telegramApprovalRelay from "../../bin/telegram-approval-relay.cjs";
 import privateConversationPolicy from "../bin/telegram-private-conversation-policy.cjs";
-const { buildTelegramRemoteStatus, resolveTelegramRemoteVersion } = remoteStatusPolicy;
+const { buildTelegramRemoteStatus, resolveTelegramQueueSnapshot, resolveTelegramRemoteVersion } = remoteStatusPolicy;
+const { parseTelegramConsoleStatus } = consoleStatusPolicy;
 const { buildTelegramApprovalCard, isAuthorizedTelegramApprovalCallback, listPendingTelegramApprovals, markTelegramApprovalSent, parseTelegramApprovalCallback, resolveTelegramApprovalTarget, wasTelegramApprovalSent, writeTelegramApprovalResponse } = telegramApprovalRelay;
 const { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = privateConversationPolicy;
 //#region ../../node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
@@ -4759,26 +4761,49 @@ bot.command("status", async (ctx) => {
 	if (access.allowFrom.includes(senderId)) {
 		let version = "unbekannt";
 		let tuiPid;
-		let queueBytes = 0;
+		let tuiHeartbeatAt;
+		let queueStats;
+		let checkpoint;
+		let queueCheckpointAt;
+		let consoleStatus;
+		const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
 		try {
 			version = JSON.parse(readFileSync(join(dirname(KING_ENTRY), "package.json"), "utf8")).version ?? version;
 		} catch {}
 		try {
 			tuiPid = parseInt(readFileSync(tuiPidFile(), "utf8"), 10);
+			tuiHeartbeatAt = statSync(tuiPidFile()).mtime.toISOString();
 		} catch {}
 		try {
-			queueBytes = statSync(tuiInboundQueueFile()).size;
+			queueStats = statSync(tuiInboundQueueFile());
 		} catch {}
+		try {
+			const checkpointFile = join(stateDir(), "inbound-queue.checkpoint.json");
+			checkpoint = JSON.parse(readFileSync(checkpointFile, "utf8"));
+			queueCheckpointAt = statSync(checkpointFile).mtime.toISOString();
+		} catch {}
+		if (Number.isInteger(tuiPid)) try {
+			consoleStatus = parseTelegramConsoleStatus(readFileSync(join(stateDir(), "telegram-console-status.json"), "utf8"), { expectedPid: tuiPid });
+		} catch {}
+		const queueSnapshot = resolveTelegramQueueSnapshot({
+			checkpoint,
+			queueBytes: queueStats?.size,
+			queueFileId: queueStats === void 0 ? void 0 : `${queueStats.dev}:${queueStats.ino}:${queueStats.birthtimeMs}`
+		});
 		await ctx.reply(buildTelegramRemoteStatus({
 			access,
 			bridgePid: process.pid,
 			bridgeUptimeSeconds: process.uptime(),
-			capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			capturedAt,
+			consoleStatus,
 			deliveryTarget: deliveryTarget(),
 			machineName: hostname(),
-			queueBytes,
+			queueBytes: queueSnapshot.totalBytes,
+			queueCheckpointAt,
+			queueUnreadBytes: queueSnapshot.unreadBytes,
 			senderId,
 			tuiFresh: isTuiLeaseFresh(),
+			tuiHeartbeatAt,
 			tuiPid: Number.isInteger(tuiPid) ? tuiPid : void 0,
 			username: ctx.from?.username,
 			version: resolveTelegramRemoteVersion({