blun-king-cli 9.1.519 → 9.1.523

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # 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.
+- Keeps prompt, tool, compact, stop, and subagent hook budgets unchanged; only the full SessionStart briefing receives the larger allowance.
+- Extends the SessionStart regression with the packaged AgentSpine manifests and a real hook-process output probe instead of relying only on a simulated result.
+
 ## 9.1.519 - 2026-08-31
 
 - Persists successful `SessionStart` hook output before startup or reload returns, so AgentSpine readiness reaches the resumed model context automatically instead of waiting for the first user prompt.

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.519
+  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.519
+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": 15 },
+    { "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": 15 }]
+        "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.519",
+  "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

@@ -2,7 +2,9 @@
 'use strict';
 
 const fs = require('node:fs');
+const os = require('node:os');
 const path = require('node:path');
+const { spawnSync } = require('node:child_process');
 
 const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
   ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
@@ -31,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');
@@ -38,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',
@@ -56,16 +70,98 @@ 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, '..');
+const agentSpineRoot = path.join(packageRoot, 'agent-spine-plugin');
+const agentSpineManifest = JSON.parse(
+  fs.readFileSync(path.join(agentSpineRoot, 'blun.plugin.json'), 'utf8'),
+);
+const agentSpineCodexHooks = JSON.parse(
+  fs.readFileSync(path.join(agentSpineRoot, 'hooks', 'codex.json'), 'utf8'),
+);
+const blunSessionStart = agentSpineManifest.hooks.find(
+  (hook) => hook.event === 'SessionStart',
+);
+const codexSessionStart = agentSpineCodexHooks.hooks.SessionStart?.[0]?.hooks?.[0];
+
+assert(
+  blunSessionStart?.timeout >= 180,
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover the measured 123.6 s cold scan',
 );
+assert(
+  codexSessionStart?.timeout >= 180,
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: Codex AgentSpine SessionStart timeout must match the BLUN runtime budget',
+);
+
+const probeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-session-start-hook-'));
+try {
+  fs.mkdirSync(path.join(probeRoot, '.git'));
+  fs.writeFileSync(
+    path.join(probeRoot, 'AGENTS.md'),
+    '# SessionStart probe\n\nLoad this project instruction automatically.\n',
+  );
+  const stateRoot = path.join(probeRoot, '.agentspine-state');
+  const hookRun = spawnSync(process.execPath, [path.join(agentSpineRoot, 'src', 'hook.js')], {
+    cwd: agentSpineRoot,
+    input: JSON.stringify({
+      hook_event_name: 'SessionStart',
+      session_id: 'session-start-regression',
+      cwd: probeRoot,
+      source: 'resume',
+    }),
+    encoding: 'utf8',
+    timeout: 30_000,
+    env: {
+      ...process.env,
+      BLUN_HOME: probeRoot,
+      BLUN_PLUGIN_ROOT: agentSpineRoot,
+      AGENTSPINE_STATE_DIR: stateRoot,
+    },
+  });
+  assert(
+    hookRun.error === undefined && hookRun.status === 0,
+    `SESSION_START_HOOK_CONTEXT_REGRESSION: real AgentSpine hook failed: ${hookRun.error?.message || hookRun.stderr}`,
+  );
+  const hookOutput = JSON.parse(hookRun.stdout.trim());
+  assert(
+    hookOutput.hookSpecificOutput?.hookEventName === 'SessionStart'
+      && hookOutput.hookSpecificOutput?.message?.includes('AgentSpine'),
+    `SESSION_START_HOOK_CONTEXT_REGRESSION: real AgentSpine process output is not injectable: ${hookRun.stdout.trim()}`,
+  );
+} finally {
+  fs.rmSync(probeRoot, { recursive: true, force: true });
+}
 
 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 = [];
@@ -108,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,
 };
-

package/bin/tool-result-offload-policy.cjs.vor-historical-preview-20260831-210300

@@ -1,317 +0,0 @@
-'use strict';
-
-const TOOL_RESULT_MAX_CHARS = 12_000;
-const TOOL_RESULT_PREVIEW_CHARS = 2_000;
-const TOOL_RESULT_RECOVERY_PAGE_LINES = 20;
-const TOOL_RESULT_OFFLOAD_MARKER = '[Tool result offloaded]';
-const TOOL_RESULT_BATCH_MAX_CHARS = TOOL_RESULT_MAX_CHARS;
-const TOOL_RESULT_BATCH_MIN_ITEM_CHARS = 3_000;
-const TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS = 2_500;
-const TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES = 4;
-const TOOL_RESULT_HISTORICAL_MAX_CHARS = TOOL_RESULT_BATCH_MAX_CHARS;
-const TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS = 600;
-const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 600;
-const TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES = 12;
-const TOOL_RESULT_HISTORICAL_SUCCESS_MARKER = '[Old tool result content cleared]';
-const TOOL_RESULT_REPEAT_MARKER = '[Repeated tool result omitted]';
-const READ_CONTINUATION_LINE_OFFSET_RE = /^Continue reading with line_offset=(\d+)\. Do not assume you have reached the end of the file\.$/mu;
-
-function shouldOffloadToolResult(textLength) {
-  return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
-}
-
-function shouldKeepFreshToolResult(toolName) {
-  return toolName === 'Read';
-}
-
-function createToolResultPreview(text) {
-  if (text.length <= TOOL_RESULT_PREVIEW_CHARS) return text;
-
-  const headChars = Math.ceil(TOOL_RESULT_PREVIEW_CHARS / 2);
-  const tailChars = TOOL_RESULT_PREVIEW_CHARS - headChars;
-  const omittedChars = text.length - headChars - tailChars;
-  return `${text.slice(0, headChars)}\n\n[... ${String(omittedChars)} characters omitted ...]\n\n${text.slice(-tailChars)}`;
-}
-
-function readContinuationLineOffset(text) {
-  if (typeof text !== 'string') return undefined;
-  const value = Number(text.match(READ_CONTINUATION_LINE_OFFSET_RE)?.[1]);
-  return Number.isSafeInteger(value) && value >= 1 ? value : undefined;
-}
-
-function isPersistedToolResultReference(content) {
-  if (!Array.isArray(content)) return false;
-
-  return content.some((part) => {
-    if (part?.type !== 'text' || typeof part.text !== 'string') return false;
-    if (!part.text.includes('\noutput_path: ')) return false;
-    return part.text.startsWith(`${TOOL_RESULT_OFFLOAD_MARKER}\n`)
-      || /^Tool output exceeded \d+ characters; showing a preview only\.\n/u.test(part.text);
-  });
-}
-
-function freshToolResultIds(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return new Set();
-
-  let assistantIndex = -1;
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    if (messages[index]?.role !== 'assistant') continue;
-    assistantIndex = index;
-    break;
-  }
-  if (assistantIndex < 0 || !Array.isArray(messages[assistantIndex].toolCalls)) return new Set();
-
-  const requestedIds = new Set(messages[assistantIndex].toolCalls
-    .map((call) => call?.id ?? call?.toolCallId)
-    .filter((id) => typeof id === 'string' && id.length > 0));
-  if (requestedIds.size === 0) return new Set();
-
-  const resultIds = new Set();
-  for (let index = assistantIndex + 1; index < messages.length; index += 1) {
-    const message = messages[index];
-    if (message?.role === 'tool' && requestedIds.has(message.toolCallId)) {
-      resultIds.add(message.toolCallId);
-    }
-  }
-  return resultIds;
-}
-
-function compactPersistedToolResultReference(content) {
-  if (!isPersistedToolResultReference(content)) return content;
-
-  let changed = false;
-  const compacted = content.map((part) => {
-    if (part?.type !== 'text' || typeof part.text !== 'string') return part;
-    const previewIndex = part.text.indexOf('\n[preview: head and tail]\n');
-    const referenceText = previewIndex < 0
-      ? part.text
-      : part.text.slice(0, previewIndex).trimEnd();
-    if (!referenceText.startsWith(`${TOOL_RESULT_OFFLOAD_MARKER}\n`)) {
-      if (referenceText === part.text) return part;
-      changed = true;
-      return { ...part, text: referenceText };
-    }
-
-    const lines = referenceText.split(/\r?\n/u);
-    const outputPath = lines.find((line) => line.startsWith('output_path: '));
-    if (outputPath === undefined) return part;
-    const recoveryLines = [TOOL_RESULT_OFFLOAD_MARKER];
-    for (const prefix of ['tool_name: ', 'output_size_chars: ', 'next_line_offset: ']) {
-      const line = lines.find((candidate) => candidate.startsWith(prefix));
-      if (line !== undefined) recoveryLines.push(line);
-    }
-    if (recoveryLines.some((line) => line.startsWith('next_line_offset: '))) {
-      const nextStep = lines.find((line) => line.startsWith('next_step: '));
-      if (nextStep !== undefined) recoveryLines.push(nextStep);
-    }
-    recoveryLines.push(outputPath);
-    const text = recoveryLines.join('\n');
-    if (text === part.text) return part;
-    changed = true;
-    return {
-      ...part,
-      text,
-    };
-  });
-
-  return changed ? compacted : content;
-}
-
-function compactHistoricalSuccessfulToolResults(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-
-  const recentStart = Math.max(0, messages.length - TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES);
-  const freshIds = freshToolResultIds(messages);
-  let changed = false;
-  const projected = messages.map((message, index) => {
-    if (
-      index >= recentStart
-      || message?.role !== 'tool'
-      || freshIds.has(message.toolCallId)
-      || message.isError === true
-      || !Array.isArray(message.content)
-      || isPersistedToolResultReference(message.content)
-      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
-    ) return message;
-
-    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
-    if (textChars <= TOOL_RESULT_HISTORICAL_SUCCESS_MARKER.length) return message;
-    changed = true;
-    return {
-      ...message,
-      content: [{ type: 'text', text: TOOL_RESULT_HISTORICAL_SUCCESS_MARKER }],
-    };
-  });
-
-  return changed ? projected : messages;
-}
-
-function toolCallSignaturesById(messages) {
-  const signatures = new Map();
-
-  for (const message of messages) {
-    if (!Array.isArray(message?.toolCalls)) continue;
-    for (const call of message.toolCalls) {
-      const id = call?.id ?? call?.toolCallId;
-      if (typeof id !== 'string' || typeof call?.name !== 'string') continue;
-      const args = typeof call.arguments === 'string'
-        ? call.arguments
-        : JSON.stringify(call.arguments ?? null);
-      signatures.set(id, `${call.name}\n${args}`);
-    }
-  }
-
-  return signatures;
-}
-
-function repeatedToolResultReference(newestToolCallId) {
-  return [
-    TOOL_RESULT_REPEAT_MARKER,
-    `same_as_tool_call_id: ${newestToolCallId}`,
-    'reason: identical successful result for the same tool call arguments',
-  ].join('\n');
-}
-
-function dedupeRepeatedSuccessfulToolResults(sourceMessages, projectedMessages = sourceMessages) {
-  if (
-    !Array.isArray(sourceMessages)
-    || !Array.isArray(projectedMessages)
-    || sourceMessages.length === 0
-    || sourceMessages.length !== projectedMessages.length
-  ) return projectedMessages;
-
-  const callSignatures = toolCallSignaturesById(sourceMessages);
-  const seenResultsByCall = new Map();
-  let changed = false;
-  const projected = projectedMessages.slice();
-
-  for (let index = sourceMessages.length - 1; index >= 0; index -= 1) {
-    const message = sourceMessages[index];
-    const toolCallId = message?.toolCallId;
-    if (
-      message?.role !== 'tool'
-      || message.isError === true
-      || typeof toolCallId !== 'string'
-      || !Array.isArray(message.content)
-      || message.content.length === 0
-      || isPersistedToolResultReference(message.content)
-      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
-    ) continue;
-
-    const callSignature = callSignatures.get(toolCallId);
-    if (callSignature === undefined) continue;
-    const resultShape = message.content.length;
-    const resultSignature = resultShape === 1
-      ? message.content[0].text
-      : JSON.stringify(message.content.map((part) => part.text));
-    let seenResults = seenResultsByCall.get(callSignature);
-    if (seenResults === undefined) {
-      seenResults = new Map();
-      seenResultsByCall.set(callSignature, seenResults);
-    }
-    let seenResultsForShape = seenResults.get(resultShape);
-    if (seenResultsForShape === undefined) {
-      seenResultsForShape = new Map();
-      seenResults.set(resultShape, seenResultsForShape);
-    }
-    const newest = seenResultsForShape.get(resultSignature);
-    if (newest === undefined) {
-      seenResultsForShape.set(resultSignature, { toolCallId, index });
-      continue;
-    }
-
-    const reference = repeatedToolResultReference(newest.toolCallId);
-    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
-    const projectedMessage = projected[index];
-    if (
-      reference.length >= textChars
-      || projectedMessage?.role !== 'tool'
-      || projectedMessage.toolCallId !== toolCallId
-    ) continue;
-    projected[index] = {
-      ...projectedMessage,
-      content: [{ type: 'text', text: reference }],
-    };
-    projected[newest.index] = {
-      ...projected[newest.index],
-      content: sourceMessages[newest.index].content,
-    };
-    changed = true;
-  }
-
-  return changed ? projected : projectedMessages;
-}
-
-function selectToolResultBatchOffloads(textLengths) {
-  if (!Array.isArray(textLengths) || textLengths.length < 2) return [];
-
-  const normalized = textLengths.map((length) => (
-    Number.isFinite(length) && length > 0 ? Math.floor(length) : 0
-  ));
-  const totalChars = normalized.reduce((total, length) => total + length, 0);
-  if (totalChars <= TOOL_RESULT_BATCH_MAX_CHARS) return [];
-
-  let projectedChars = totalChars;
-  const selected = [];
-  const candidates = normalized
-    .map((length, index) => ({ index, length }))
-    .filter(({ length }) => (
-      length >= TOOL_RESULT_BATCH_MIN_ITEM_CHARS
-      && length <= TOOL_RESULT_MAX_CHARS
-      && length > TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS
-    ))
-    .sort((left, right) => right.length - left.length || left.index - right.index);
-
-  for (const candidate of candidates) {
-    if (projectedChars <= TOOL_RESULT_BATCH_MAX_CHARS) break;
-    projectedChars -= candidate.length - TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS;
-    selected.push(candidate.index);
-  }
-
-  return projectedChars <= TOOL_RESULT_BATCH_MAX_CHARS
-    ? selected.sort((left, right) => left - right)
-    : [];
-}
-
-function selectHistoricalToolResultOffloads(textLengths) {
-  if (!Array.isArray(textLengths) || textLengths.length === 0) return [];
-
-  const normalized = textLengths.map((length) => (
-    Number.isFinite(length) && length > 0 ? Math.floor(length) : 0
-  ));
-  return normalized
-    .map((length, index) => ({ index, length }))
-    .filter(({ length }) => (
-      length >= TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS
-      && length > TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS
-    ))
-    .map(({ index }) => index);
-}
-
-module.exports = {
-  TOOL_RESULT_BATCH_MAX_CHARS,
-  TOOL_RESULT_BATCH_MIN_ITEM_CHARS,
-  TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS,
-  TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES,
-  TOOL_RESULT_HISTORICAL_MAX_CHARS,
-  TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS,
-  TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS,
-  TOOL_RESULT_HISTORICAL_SUCCESS_MARKER,
-  TOOL_RESULT_REPEAT_MARKER,
-  TOOL_RESULT_MAX_CHARS,
-  TOOL_RESULT_PREVIEW_CHARS,
-  TOOL_RESULT_RECOVERY_PAGE_LINES,
-  TOOL_RESULT_OFFLOAD_MARKER,
-  TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES,
-  compactHistoricalSuccessfulToolResults,
-  compactPersistedToolResultReference,
-  createToolResultPreview,
-  dedupeRepeatedSuccessfulToolResults,
-  freshToolResultIds,
-  isPersistedToolResultReference,
-  readContinuationLineOffset,
-  selectHistoricalToolResultOffloads,
-  selectToolResultBatchOffloads,
-  shouldKeepFreshToolResult,
-  shouldOffloadToolResult,
-};