blun-king-cli 9.1.491 → 9.1.493

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 9.1.493 - 2026-08-30
+
+- Automatically authorizes every new Telegram user message for delivery at the next safe handoff, including messages from groups, instead of requiring Ctrl+S or Escape first.
+- Keeps private DMs ahead of group traffic while preserving FIFO order inside each priority class.
+- Keeps Ctrl+S as an immediate full-backlog release and Escape as one-message-at-a-time release or active-run cancellation when no message remains.
+
+## 9.1.492 - 2026-08-30
+
+- Keeps an authorized Telegram group message pending when an in-flight delivery temporarily blocks Ctrl+S or Escape, then retries it without requiring another key press.
+- Prevents unreleased group arrivals from arming the delivery controller before the user authorizes them.
+- Makes a current changelog entry mandatory before npm can pack or publish the package.
+- Adds an external release check that compares npm latest, npm package integrity, the public update manifest, and the public changelog before a release may be reported complete.
+
 ## 9.1.491 - 2026-08-30
 
 - Restores real-time private Telegram priority: a user DM now auto-authorizes delivery into active work instead of waiting behind the manual queue-release gate.

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.491
+  npm install -g blun-king-cli@9.1.493
 
 Start
 -----
@@ -54,15 +54,25 @@ stoppt die Aktualisierung, bevor die Plugin-Registry geändert wird. Dieser
 Lieferweg gilt unter macOS, Linux und Windows.
 
 Telegram-Nachrichten werden in Eingangsreihenfolge verarbeitet. Im Leerlauf
-startet die Warteschlange selbstständig. Während eines aktiven Laufs gibt
-Strg+S alle zu diesem Zeitpunkt wartenden Konsolen- und Chatnachrichten genau
-einmal frei. Jeder Druck auf Esc gibt genau eine weitere wartende Nachricht
-frei; erst bei leerer Warteschlange bricht Esc den aktuellen Lauf ab. Die
-Warteschlange wird dabei nicht gelöscht. Strg+C bricht den aktiven Zug direkt
-ab, ohne den geschriebenen Entwurf zu löschen. Das gilt auch bei
+und während eines aktiven Laufs merkt die Warteschlange jede User-Nachricht
+selbstständig für den nächsten sicheren Übergabepunkt vor. Sie wartet nicht auf
+einen Tastendruck; private Nachrichten bleiben vor Gruppenverkehr priorisiert.
+Strg+S gibt einen vorhandenen Rückstand sofort vollständig und genau einmal
+frei. Jeder Druck auf Esc gibt genau eine weitere wartende Nachricht frei; erst
+bei leerer Warteschlange bricht Esc den aktuellen Lauf ab. Die Warteschlange
+wird dabei nicht gelöscht. Strg+C bricht den aktiven Zug direkt ab, ohne den
+geschriebenen Entwurf zu löschen. Das gilt auch bei
 Autovervollständigung, Geistervorschlägen, Bash-Eingabe und einer offenen
 Mehrzeileneingabe.
 
+Version 9.1.493 stellt die automatische Zustellung von User-Nachrichten auch
+für Telegram-Gruppen wieder her. Version 9.1.492 schützt Veröffentlichungen
+zusätzlich mit einer verpflichtenden
+Metadatenprüfung. Packen und Veröffentlichen brechen ab, wenn Paketversion,
+erster Changelog-Eintrag oder Installationshinweise auseinanderlaufen. Die
+abschließende externe Prüfung vergleicht npm, Paketintegrität, öffentliches
+Update-Manifest und öffentliche Changelog-Seite.
+
 Version 9.1.491 stellt außerdem die interne Todo-Liste wieder her. Deutsche
 Aufgabenlisten-Befehle wählen wieder TodoList statt der getrennten TaskList für
 Hintergrundprozesse. Lesen, Ersetzen, Aktualisieren und Leeren funktionieren in

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.491
+npm install -g blun-king-cli@9.1.493
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -68,9 +68,11 @@ blun tools enable context7
 ```
 
 Telegram-Nachrichten werden in Eingangsreihenfolge verarbeitet. Trifft eine
-Nachricht im Leerlauf ein, startet die Warteschlange selbstständig. Während
-eines aktiven Laufs gibt Strg+S alle zu diesem Zeitpunkt wartenden Konsolen-
-und Chatnachrichten genau einmal frei. Jeder Druck auf Esc gibt genau eine
+Nachricht im Leerlauf oder während eines aktiven Laufs ein, merkt die
+Warteschlange sie selbstständig für den nächsten sicheren Übergabepunkt vor.
+Eine User-Nachricht wartet nicht auf einen Tastendruck. Private Nachrichten
+bleiben vor Gruppenverkehr priorisiert. Strg+S gibt einen vorhandenen Rückstand
+sofort vollständig und genau einmal frei. Jeder Druck auf Esc gibt genau eine
 weitere wartende Nachricht frei; erst bei leerer Warteschlange bricht Esc den
 aktuellen Lauf ab. Die Warteschlange wird dabei nicht gelöscht. Strg+C bricht
 den aktiven Zug direkt ab, ohne den geschriebenen Entwurf zu löschen.
@@ -79,6 +81,14 @@ konkurrierenden Start zurückgewiesen und bleiben an der Spitze der
 FIFO-Warteschlange. Für diesen normalen Wartestatus erscheint kein
 `turn.agent_busy`-Fehler.
 
+Version 9.1.493 stellt die automatische Zustellung von User-Nachrichten auch
+für Telegram-Gruppen wieder her. Version 9.1.492 schützt Veröffentlichungen
+zusätzlich mit einer verpflichtenden
+Metadatenprüfung. Packen und Veröffentlichen brechen ab, wenn Paketversion,
+erster Changelog-Eintrag oder Installationshinweise auseinanderlaufen. Die
+abschließende externe Prüfung vergleicht npm, Paketintegrität, öffentliches
+Update-Manifest und öffentliche Changelog-Seite.
+
 Version 9.1.491 stellt außerdem die interne Todo-Liste wieder her. Deutsche
 Aufgabenlisten-Befehle wählen wieder TodoList statt der getrennten TaskList für
 Hintergrundprozesse. Lesen, Ersetzen, Aktualisieren und Leeren funktionieren in

package/blun.mjs

@@ -504027,12 +504027,18 @@ var ChannelQueueDeadlineController = class {
 	}
 	requestDeliveryAtSafePoint() {
 		if (this.retainReleaseWhileDeliveryIsInFlight()) return;
-		if (this.host.hasWaitingWork() && !this.host.canDeliverWork()) return;
+		if (this.host.hasWaitingWork() && !this.host.canDeliverWork()) {
+			this.scheduleRetry();
+			return;
+		}
 		this.requestDelivery();
 	}
 	requestDeliveryNow() {
 		if (this.retainReleaseWhileDeliveryIsInFlight()) return;
-		if (this.host.hasWaitingWork() && !this.host.canDeliverWork()) return;
+		if (this.host.hasWaitingWork() && !this.host.canDeliverWork()) {
+			this.scheduleRetry();
+			return;
+		}
 		this.requestDelivery();
 	}
 	retainReleaseWhileDeliveryIsInFlight() {
@@ -518442,8 +518448,8 @@ var BlunTUI = class {
 				else if (addressed) enqueueTelegramAddressed(this.state.queuedMessages, item);
 				else this.state.queuedMessages.push(item);
 				const activeTurn = this.streamingUI.hasActiveTurn() || this.state.appState.streamingPhase !== "idle" && this.state.appState.streamingPhase !== "shell";
-				if (directEnvelope !== void 0 && activeTurn) this.releaseNextQueuedMessage();
-				this.channelQueueDeadline.requestDeliveryNow();
+				if (activeTurn) this.releaseNextQueuedMessage();
+				if (this.queueFlushBatchRemaining > 0) this.channelQueueDeadline.requestDeliveryNow();
 				this.scheduleQueueDrain();
 				this.track("input_queue");
 				this.updateQueueDisplay();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.491",
+  "version": "9.1.493",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -9,6 +9,8 @@
   },
   "scripts": {
     "test": "node --test test/*.test.js",
+    "prepack": "node scripts/check-release-metadata.js",
+    "release:verify": "node scripts/check-release-metadata.js --external",
     "postinstall": "node scripts/fix-node-pty-perms.js"
   },
   "engines": {
@@ -34,6 +36,7 @@
     "native/",
     "release-planned-removals.json",
     "scripts/check-package-regression.js",
+    "scripts/check-release-metadata.js",
     "scripts/fix-node-pty-perms.js",
     "standard-skills/",
     "standard-tools/",

package/scripts/check-release-metadata.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_MANIFEST_URL = 'https://chat.blun.ai/blun-code-version.json';
+const DEFAULT_DOCS_URL = 'https://docs.blun.ai/changelog.html';
+const DEFAULT_REGISTRY_URL = 'https://registry.npmjs.org';
+const MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function readUtf8(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function firstChangelogVersion(changelog) {
+  return /^##\s+(\d+\.\d+\.\d+)\b/mu.exec(changelog)?.[1] || null;
+}
+
+function checkLocalReleaseMetadata(root = path.resolve(__dirname, '..')) {
+  const packageJson = JSON.parse(readUtf8(path.join(root, 'package.json')));
+  const version = String(packageJson.version || '');
+  const packageName = String(packageJson.name || '');
+  assert(/^\d+\.\d+\.\d+$/u.test(version), 'RELEASE_VERSION_INVALID');
+  assert(packageName.length > 0, 'RELEASE_PACKAGE_NAME_MISSING');
+
+  const changelogVersion = firstChangelogVersion(readUtf8(path.join(root, 'CHANGELOG.md')));
+  assert(changelogVersion === version, `CHANGELOG_VERSION_MISMATCH:${changelogVersion || 'missing'}!=${version}`);
+
+  const installNeedle = `${packageName}@${version}`;
+  for (const fileName of ['README.md', 'LIESMICH.txt']) {
+    assert(readUtf8(path.join(root, fileName)).includes(installNeedle), `INSTALL_VERSION_MISMATCH:${fileName}`);
+  }
+  return { packageName, version };
+}
+
+async function fetchLimited(url, kind) {
+  const response = await fetch(url, {
+    headers: { accept: kind === 'json' ? 'application/json' : 'text/html' },
+    redirect: 'follow',
+    signal: AbortSignal.timeout(15_000),
+  });
+  assert(response.ok, `RELEASE_FETCH_FAILED:${response.status}:${url}`);
+  const declaredLength = Number(response.headers.get('content-length'));
+  assert(!Number.isFinite(declaredLength) || declaredLength <= MAX_RESPONSE_BYTES, `RELEASE_RESPONSE_TOO_LARGE:${url}`);
+  const body = await response.text();
+  assert(Buffer.byteLength(body, 'utf8') <= MAX_RESPONSE_BYTES, `RELEASE_RESPONSE_TOO_LARGE:${url}`);
+  return kind === 'json' ? JSON.parse(body) : body;
+}
+
+async function checkExternalReleaseMetadata(local, options = {}) {
+  const cacheBust = `cb=${Date.now()}`;
+  const registryUrl = options.registryUrl || DEFAULT_REGISTRY_URL;
+  const manifestUrl = `${options.manifestUrl || DEFAULT_MANIFEST_URL}?${cacheBust}`;
+  const docsUrl = `${options.docsUrl || DEFAULT_DOCS_URL}?${cacheBust}`;
+  const encodedName = encodeURIComponent(local.packageName);
+  const [tags, metadata, manifest, docs] = await Promise.all([
+    fetchLimited(`${registryUrl}/-/package/${encodedName}/dist-tags`, 'json'),
+    fetchLimited(`${registryUrl}/${encodedName}/${local.version}`, 'json'),
+    fetchLimited(manifestUrl, 'json'),
+    fetchLimited(docsUrl, 'html'),
+  ]);
+
+  assert(tags.latest === local.version, `NPM_LATEST_MISMATCH:${tags.latest || 'missing'}!=${local.version}`);
+  assert(metadata.version === local.version, `NPM_VERSION_MISMATCH:${metadata.version || 'missing'}!=${local.version}`);
+  assert(manifest.name === local.packageName, `MANIFEST_PACKAGE_MISMATCH:${manifest.name || 'missing'}!=${local.packageName}`);
+  assert(manifest.latest === local.version, `MANIFEST_VERSION_MISMATCH:${manifest.latest || 'missing'}!=${local.version}`);
+  assert(typeof metadata.dist?.integrity === 'string' && metadata.dist.integrity.length > 0, 'NPM_INTEGRITY_MISSING');
+  assert(manifest.integrity === metadata.dist.integrity, 'MANIFEST_INTEGRITY_MISMATCH');
+  assert(docs.includes(`<title>BLUN King ${local.version} `), `PUBLIC_CHANGELOG_VERSION_MISMATCH:${local.version}`);
+  return { ...local, integrity: metadata.dist.integrity };
+}
+
+function parseArgs(argv) {
+  const external = argv.includes('--external');
+  const rootArg = argv.find((arg) => arg.startsWith('--root='));
+  return { external, root: rootArg ? path.resolve(rootArg.slice('--root='.length)) : undefined };
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  const local = checkLocalReleaseMetadata(options.root);
+  const result = options.external ? await checkExternalReleaseMetadata(local) : local;
+  process.stdout.write(`release-metadata PASS ${JSON.stringify(result)}\n`);
+  return result;
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    process.stderr.write(`release-metadata BLOCK ${error.message}\n`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  checkExternalReleaseMetadata,
+  checkLocalReleaseMetadata,
+  firstChangelogVersion,
+  main,
+};