blun-king-cli 9.1.520 → 9.1.523

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 9.1.523 - 2026-09-01
+
+- Makes `Escape` cancel an open slash-command menu and clear its slash draft in one action instead of leaving the command text behind.
+- Lets `Ctrl+S` pass a slash draft into the existing queue-and-drain path even when the surface currently reports idle, instead of silently returning before the flush.
+- Preserves ordinary drafts when `Escape` only dismisses non-slash autocomplete.
+- Adds red-to-green runtime regressions for both shortcuts against the exact 9.1.522 package behavior.
+
+## 9.1.522 - 2026-09-01
+
+- Writes `permission.approval_requested` to the session wire as soon as a tool approval opens, so an unattended King no longer looks like a silent model or provider stall while it is waiting for an operator.
+- Reuses the existing Telegram approval buttons automatically when the allowlist contains exactly one private chat plus any number of groups; ambiguous private recipients remain fail-closed unless `BLUN_TELEGRAM_APPROVAL_CHAT_ID` is set.
+- Adds a red-to-green regression for immediate wire visibility, unique-private-chat routing, explicit target precedence, and ambiguous-recipient rejection in both packaged relay copies.
+
+## 9.1.521 - 2026-09-01
+
+- Runs the AgentSpine `SessionStart` scan outside the interactive startup path, so a cold 123.6-second home-directory scan cannot hold the editor or prevent the first user prompt from reaching the wire.
+- Keeps successful SessionStart output automatic: the completed background hook still persists its scoped briefing into the session context.
+- Extends the cold-scan budget to 180 seconds and adds a red-to-green runtime regression proving that startup returns before a slow hook while the hook can still finish afterward.
+
 ## 9.1.520 - 2026-08-31
 
 - Gives AgentSpine's `SessionStart` hook a 60-second cold-project budget, so startup and `/reload` can persist the automatic briefing even when the measured source scan exceeds the former 15-second limit.

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.520
+  npm install -g blun-king-cli@9.1.523
 
 AgentSpine 0.10.1
 -----------------

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.520
+npm install -g blun-king-cli@9.1.523
 ```
 
 ## AgentSpine 0.10.1

package/agent-spine-plugin/blun.plugin.json

@@ -15,7 +15,7 @@
     }
   },
   "hooks": [
-    { "event": "SessionStart", "command": "node \"./src/hook.js\"", "timeout": 60 },
+    { "event": "SessionStart", "command": "node \"./src/hook.js\"", "timeout": 180 },
     { "event": "UserPromptSubmit", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "PreToolUse", "matcher": "Edit|Write|apply_patch|Bash|exec_command", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "PostToolUse", "command": "node \"./src/hook.js\"", "timeout": 15 },

package/agent-spine-plugin/hooks/codex.json

@@ -4,7 +4,7 @@
     "SessionStart": [
       {
         "matcher": "startup|resume|clear|compact",
-        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\"", "timeout": 60 }]
+        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\"", "timeout": 180 }]
       }
     ],
     "UserPromptSubmit": [

package/bin/telegram-approval-relay.cjs

@@ -68,6 +68,8 @@ function resolveTelegramApprovalTarget(allowFrom, configuredChatId) {
     : [];
   const configured = String(configuredChatId ?? '').trim();
   if (configured.length > 0) return allowed.includes(configured) ? configured : null;
+  const privateChats = allowed.filter((value) => /^[1-9]\d*$/u.test(value));
+  if (privateChats.length === 1) return privateChats[0];
   return allowed.length === 1 ? allowed[0] : null;
 }
 

package/blun.mjs

@@ -234150,6 +234150,15 @@ var init_permission = __esmMin((() => {
 			let requestedApproval = false;
 			if (this.agent.rpc?.requestApproval) {
 				requestedApproval = true;
+				this.agent.records.logRecord({
+					type: "permission.approval_requested",
+					turnId: Number(context.turnId),
+					toolCallId: id,
+					toolName: name,
+					action,
+					display,
+					policyName: policyName ?? null
+				});
 				this.agent.hooks?.fireAndForgetTrigger?.("PermissionRequest", {
 					matcherValue: name,
 					inputData: {
@@ -297952,7 +297961,7 @@ var init_session$1 = __esmMin((() => {
 			const { agent } = await this.createAgent({ type: "main" }, { profile: DEFAULT_AGENT_PROFILES["agent"] });
 			const mc = this.options.missionContract;
 			if (mc && Array.isArray(mc.acceptanceCriteria) && mc.acceptanceCriteria.length > 0) await agent.injection.setMissionContract(mc);
-			await this.triggerSessionStart("startup");
+			this.scheduleSessionStart("startup");
 			return agent;
 		}
 		async resume() {
@@ -297965,7 +297974,7 @@ var init_session$1 = __esmMin((() => {
 			const profile = DEFAULT_AGENT_PROFILES["agent"];
 			if (main !== void 0 && profile !== void 0 && main.config.systemPrompt === "") await this.bootstrapAgentProfile(main, profile);
 			if (main !== void 0) this.ensureBaselineSkill(main);
-			await this.triggerSessionStart("resume");
+			this.scheduleSessionStart("resume");
 			return { warning };
 		}
 		async close() {
@@ -298500,6 +298509,11 @@ var init_session$1 = __esmMin((() => {
 			if (agent === void 0) throw new BlunError(ErrorCodes.AGENT_NOT_FOUND, "Main agent was not found");
 			return agent;
 		}
+		scheduleSessionStart(source) {
+			void this.triggerSessionStart(source).catch((error) => {
+				this.log.warn("session start hook failed", { source, error });
+			});
+		}
 		async triggerSessionStart(source) {
 			const results = await this.hookEngine.trigger("SessionStart", {
 				matcherValue: source,
@@ -505909,6 +505923,7 @@ var EditorKeyboardController = class {
 				return;
 			}
 			if (autocompleteCancelled) {
+				if (editor.inputMode === "prompt" && editor.getText().trimStart().startsWith("/")) editor.setText("");
 				this.clearPendingUndoEsc();
 				return;
 			}
@@ -505949,8 +505964,9 @@ var EditorKeyboardController = class {
 			return true;
 		};
 		editor.onCtrlS = () => {
-			if (!host.streamingUI.hasActiveTurn() && host.state.appState.streamingPhase === "idle") return;
-			host.flushQueuedMessages(editor.getText().trim(), editor.inputMode);
+			const draft = editor.getText().trim();
+			if (!host.streamingUI.hasActiveTurn() && host.state.appState.streamingPhase === "idle" && !draft.trimStart().startsWith("/")) return;
+			host.flushQueuedMessages(draft, editor.inputMode);
 			host.updateQueueDisplay();
 			host.state.ui.requestRender();
 		};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.520",
+  "version": "9.1.523",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.js",
-    "prepack": "node scripts/check-release-metadata.js && node scripts/check-todo-loop-regression.js && node scripts/check-todo-recovery-catalog-regression.js && node scripts/check-historical-tool-result-preview-regression.js && node scripts/check-session-start-hook-context-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-approval-queue-shortcuts-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-session-cancel-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
+    "prepack": "node scripts/check-release-metadata.js && node scripts/check-todo-loop-regression.js && node scripts/check-todo-recovery-catalog-regression.js && node scripts/check-historical-tool-result-preview-regression.js && node scripts/check-session-start-hook-context-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-approval-queue-shortcuts-regression.js && node scripts/check-approval-observability-regression.js && node scripts/check-slash-escape-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-session-cancel-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
     "release:verify": "node scripts/check-release-metadata.js --external",
     "postinstall": "node scripts/fix-node-pty-perms.js"
   },
@@ -38,6 +38,8 @@
     "scripts/check-package-regression.js",
     "scripts/check-active-profile-plugin-startup.js",
     "scripts/check-approval-queue-shortcuts-regression.js",
+    "scripts/check-approval-observability-regression.js",
+    "scripts/check-slash-escape-regression.js",
     "scripts/check-mcp-startup-wait-budget.js",
     "scripts/check-plugin-startup-regression.js",
     "scripts/check-queue-controls-regression.js",

package/scripts/check-approval-observability-regression.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const packageRoot = path.resolve(__dirname, '..');
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.join(packageRoot, 'blun.mjs');
+const relayPath = process.env.BLUN_APPROVAL_RELAY_UNDER_TEST
+  ? path.resolve(process.env.BLUN_APPROVAL_RELAY_UNDER_TEST)
+  : path.join(packageRoot, 'bin', 'telegram-approval-relay.cjs');
+const pluginRelayPath = process.env.BLUN_PLUGIN_APPROVAL_RELAY_UNDER_TEST
+  ? path.resolve(process.env.BLUN_PLUGIN_APPROVAL_RELAY_UNDER_TEST)
+  : path.join(packageRoot, 'telegram-plugin', 'bin', 'telegram-approval-relay.cjs');
+
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+const requestToolApproval = bundle.match(
+  /async requestToolApproval\(context, result, policyName\) \{[\s\S]*?\n\t\t\}/,
+);
+assert(requestToolApproval, 'APPROVAL_OBSERVABILITY_REGRESSION: requestToolApproval is missing');
+assert.match(
+  requestToolApproval[0],
+  /this\.agent\.records\.logRecord\(\{[\s\S]*?type: "permission\.approval_requested"[\s\S]*?toolCallId: id[\s\S]*?toolName: name/,
+  'APPROVAL_OBSERVABILITY_REGRESSION: opening an approval is invisible in the wire',
+);
+assert(
+  requestToolApproval[0].indexOf('type: "permission.approval_requested"')
+    < requestToolApproval[0].indexOf('await this.agent.rpc.requestApproval'),
+  'APPROVAL_OBSERVABILITY_REGRESSION: approval wire event is emitted too late',
+);
+
+const ApprovalProbe = Function(`return class ApprovalProbe {${requestToolApproval[0]}};`)();
+const wireRecords = [];
+const probe = new ApprovalProbe();
+probe.agent = {
+  records: { logRecord(record) { wireRecords.push(record); } },
+  rpc: { async requestApproval() { return { decision: 'approved' }; } },
+  hooks: { fireAndForgetTrigger() {} },
+  telemetry: { track() {} },
+};
+probe.recordApprovalResult = () => {};
+probe.permissionPolicyResolutionToPrepare = () => undefined;
+probe.formatApprovalRejectionMessage = () => '';
+
+const approvalRun = probe.requestToolApproval({
+  signal: new AbortController().signal,
+  turnId: 7,
+  toolCall: { id: 'tool-7', name: 'Bash' },
+  execution: {
+    description: 'Run command',
+    display: { kind: 'command', command: 'echo ok' },
+  },
+  args: { command: 'echo ok' },
+}, {}, 'manual-approval');
+assert.equal(wireRecords.length, 1, 'approval request must be written before awaiting a response');
+assert.deepEqual(
+  wireRecords[0],
+  {
+    type: 'permission.approval_requested',
+    turnId: 7,
+    toolCallId: 'tool-7',
+    toolName: 'Bash',
+    action: 'Run command',
+    display: { kind: 'command', command: 'echo ok' },
+    policyName: 'manual-approval',
+  },
+  'approval wire record lost identifying fields',
+);
+
+function checkRelay(modulePath, label) {
+  delete require.cache[require.resolve(modulePath)];
+  const { resolveTelegramApprovalTarget } = require(modulePath);
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602', '-1003927574737']),
+    '1605241602',
+    `${label}: one authorized private chat must be selected even when groups are also allowed`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['0', '-1003927574737']),
+    null,
+    `${label}: zero is not a positive private Telegram chat ID`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602', '8711923962', '-1003927574737']),
+    null,
+    `${label}: multiple authorized private chats must remain fail-closed`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602', '8711923962'], '8711923962'),
+    '8711923962',
+    `${label}: an explicitly configured authorized chat must win`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602'], '-1003927574737'),
+    null,
+    `${label}: an unauthorized configured chat must be rejected`,
+  );
+}
+
+checkRelay(relayPath, 'package relay');
+checkRelay(pluginRelayPath, 'plugin relay');
+
+approvalRun.then(() => {
+  process.stdout.write('approval-observability-regression PASS\n');
+}).catch((error) => {
+  process.stderr.write(`${error.stack || error.message}\n`);
+  process.exitCode = 1;
+});

package/scripts/check-session-start-hook-context-regression.js

@@ -33,6 +33,15 @@ const stringPredicate = bundle.match(
 const trigger = bundle.match(
   /async triggerSessionStart\(source\) \{[\s\S]*?\n\t\t\}/,
 );
+const scheduler = bundle.match(
+  /scheduleSessionStart\(source\) \{[\s\S]*?\n\t\t\}/,
+);
+const createMain = bundle.match(
+  /async createMain\(\) \{[\s\S]*?\n\t\t\}/,
+);
+const resume = bundle.match(
+  /async resume\(\) \{[\s\S]*?\n\t\t\}/,
+);
 
 assert(renderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart renderer is missing');
 assert(allowRenderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: shared allow renderer is missing');
@@ -40,6 +49,9 @@ assert(wrapperRenderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook wrapper ren
 assert(messageSelector, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook message selector is missing');
 assert(stringPredicate, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook string predicate is missing');
 assert(trigger, 'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart trigger is missing');
+assert(scheduler, 'SESSION_START_HOOK_CONTEXT_REGRESSION: non-blocking SessionStart scheduler is missing');
+assert(createMain, 'SESSION_START_HOOK_CONTEXT_REGRESSION: createMain is missing');
+assert(resume, 'SESSION_START_HOOK_CONTEXT_REGRESSION: resume is missing');
 assert(
   /renderAllowHookResult\("SessionStart", results\)/.test(renderer[0]),
   'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart output is not rendered',
@@ -58,7 +70,21 @@ assert(
 );
 assert(
   /await mainAgent\.records\.flush\(\)/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart reminder is not flushed before reload returns',
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: completed SessionStart reminder is not flushed',
+);
+assert(
+  /this\.scheduleSessionStart\("startup"\)/.test(createMain[0])
+    && !/await this\.triggerSessionStart\("startup"\)/.test(createMain[0]),
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: fresh-session input is still blocked by SessionStart',
+);
+assert(
+  /this\.scheduleSessionStart\("resume"\)/.test(resume[0])
+    && !/await this\.triggerSessionStart\("resume"\)/.test(resume[0]),
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: resumed-session input is still blocked by SessionStart',
+);
+assert(
+  /void this\.triggerSessionStart\(source\)\.catch\(/.test(scheduler[0]),
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart is not detached from interactive startup',
 );
 
 const packageRoot = path.resolve(__dirname, '..');
@@ -75,11 +101,11 @@ const blunSessionStart = agentSpineManifest.hooks.find(
 const codexSessionStart = agentSpineCodexHooks.hooks.SessionStart?.[0]?.hooks?.[0];
 
 assert(
-  blunSessionStart?.timeout >= 60,
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover a cold project scan',
+  blunSessionStart?.timeout >= 180,
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover the measured 123.6 s cold scan',
 );
 assert(
-  codexSessionStart?.timeout >= 60,
+  codexSessionStart?.timeout >= 180,
   'SESSION_START_HOOK_CONTEXT_REGRESSION: Codex AgentSpine SessionStart timeout must match the BLUN runtime budget',
 );
 
@@ -126,9 +152,16 @@ const triggerFunction = trigger[0].replace(
   /^async triggerSessionStart/,
   'async function triggerSessionStart',
 );
+const schedulerFunction = scheduler[0].replace(
+  /^scheduleSessionStart/,
+  'function scheduleSessionStart',
+);
 const runTrigger = Function(
   `${wrapperRenderer[0]}\n${messageSelector[0]}\n${stringPredicate[0]}\n${allowRenderer[0]}\n${renderer[0]}\n${triggerFunction}\nreturn triggerSessionStart;`,
 )();
+const scheduleTrigger = Function(
+  `${schedulerFunction}\nreturn scheduleSessionStart;`,
+)();
 
 (async () => {
   const reminders = [];
@@ -171,6 +204,23 @@ const runTrigger = Function(
     'runtime probe used the wrong reminder origin',
   );
 
+  let detachedCompleted = false;
+  const detachedStartedAt = Date.now();
+  scheduleTrigger.call({
+    async triggerSessionStart(source) {
+      assert(source === 'startup', 'detached runtime probe lost the startup source');
+      await new Promise((resolve) => setTimeout(resolve, 75));
+      detachedCompleted = true;
+    },
+    log: { warn() {} },
+  }, 'startup');
+  assert(
+    Date.now() - detachedStartedAt < 50 && detachedCompleted === false,
+    'SessionStart scheduler still waits for the hook before returning',
+  );
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  assert(detachedCompleted, 'detached SessionStart hook did not finish in the background');
+
   process.stdout.write('session-start-hook-context-regression PASS\n');
 })().catch((error) => {
   process.stderr.write(`${error.stack || error.message}\n`);

package/scripts/check-slash-escape-regression.js

@@ -0,0 +1,89 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const packageRoot = path.resolve(__dirname, '..');
+const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
+const match = /editor\.onEscape = \(autocompleteCancelled = false\) => \{([\s\S]*?)\n\t\t\};\n\t\teditor\.onShiftTab =/.exec(bundle);
+assert(match, 'SLASH_ESCAPE_REGRESSION: editor.onEscape handler is missing');
+
+const runEscape = Function('host', 'editor', 'autocompleteCancelled', match[1]);
+const ctrlSMatch = /editor\.onCtrlS = \(\) => \{([\s\S]*?)\n\t\t\};\n\t\teditor\.onCtrlB =/.exec(bundle);
+assert(ctrlSMatch, 'SLASH_ESCAPE_REGRESSION: editor.onCtrlS handler is missing');
+const runCtrlS = Function('host', 'editor', ctrlSMatch[1]);
+
+function probe(initialText, autocompleteCancelled) {
+  let text = initialText;
+  const editor = {
+    inputMode: 'prompt',
+    getText: () => text,
+    setText: (value) => { text = value; },
+  };
+  const host = {
+    cancelInFlight: undefined,
+    queueSteerInFlight: undefined,
+    state: {
+      activeDialog: null,
+      appState: {
+        isCompacting: false,
+        streamingPhase: 'idle',
+      },
+    },
+    streamingUI: { hasActiveTurn: () => false },
+    btwPanelController: { closeOrCancel: () => false },
+  };
+  const controller = {
+    pendingExit: null,
+    pendingUndoEsc: null,
+    clearPendingExit() {},
+    clearPendingUndoEsc() {},
+    armPendingUndoEsc() {},
+  };
+
+  runEscape.call(controller, host, editor, autocompleteCancelled);
+  return text;
+}
+
+assert.equal(
+  probe('/reload', true),
+  '',
+  'SLASH_ESCAPE_REGRESSION: Escape must cancel the open slash-command draft together with its menu',
+);
+assert.equal(
+  probe('ordinary draft', true),
+  'ordinary draft',
+  'SLASH_ESCAPE_REGRESSION: cancelling ordinary autocomplete must preserve the draft',
+);
+
+let flushed = null;
+const idleHost = {
+  streamingUI: { hasActiveTurn: () => false },
+  state: {
+    appState: { streamingPhase: 'idle' },
+    ui: { requestRender() {} },
+  },
+  flushQueuedMessages: (draft, mode) => { flushed = { draft, mode }; },
+  updateQueueDisplay() {},
+};
+const slashEditor = {
+  inputMode: 'prompt',
+  getText: () => '/reload',
+};
+runCtrlS(idleHost, slashEditor);
+assert.deepEqual(
+  flushed,
+  { draft: '/reload', mode: 'prompt' },
+  'SLASH_ESCAPE_REGRESSION: Ctrl+S must hand an idle slash draft to the existing queue drain',
+);
+flushed = null;
+runCtrlS(idleHost, {
+  inputMode: 'prompt',
+  getText: () => 'ordinary draft',
+});
+assert.equal(
+  flushed,
+  null,
+  'SLASH_ESCAPE_REGRESSION: the existing idle behavior for ordinary drafts must stay unchanged',
+);
+
+console.log('slash-escape-regression PASS (Escape + Ctrl+S)');

package/telegram-plugin/bin/telegram-approval-relay.cjs

@@ -68,6 +68,8 @@ function resolveTelegramApprovalTarget(allowFrom, configuredChatId) {
     : [];
   const configured = String(configuredChatId ?? '').trim();
   if (configured.length > 0) return allowed.includes(configured) ? configured : null;
+  const privateChats = allowed.filter((value) => /^[1-9]\d*$/u.test(value));
+  if (privateChats.length === 1) return privateChats[0];
   return allowed.length === 1 ? allowed[0] : null;
 }
 
@@ -280,4 +282,3 @@ module.exports = {
   wasTelegramApprovalSent,
   writeTelegramApprovalResponse,
 };
-