blun-king-cli 9.1.514 → 9.1.516

package/scripts/check-queue-controls-regression.js

@@ -0,0 +1,189 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { enqueueTelegramAddressed } = require('../bin/telegram-addressed-priority.cjs');
+const { enqueueTelegramBotPriority } = require('../bin/telegram-bot-priority.cjs');
+const { enqueueTelegramDirect } = require('../bin/telegram-direct-focus-policy.cjs');
+const { enqueueTelegramUrgent } = require('../bin/telegram-urgent-policy.cjs');
+
+const bundle = fs.readFileSync(path.join(__dirname, '..', 'blun.mjs'), 'utf8');
+
+function between(start, end) {
+  const startIndex = bundle.indexOf(start);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+function method(name, nextName) {
+  const source = between(`\n\t${name}(`, `\n\t${nextName}(`).trim();
+  return Function(`"use strict"; return ({${source}}).${name};`)();
+}
+
+const ctrlS = between('\n\t\teditor.onCtrlS = () => {', '\n\t\teditor.onCtrlB =');
+assert.match(ctrlS, /host\.flushQueuedMessages\(/);
+assert.doesNotMatch(ctrlS, /toggleTodoPanelExpansion|shortcut_todo_expand/);
+
+const escape = between('\n\t\teditor.onEscape =', '\n\t\teditor.onShiftTab =');
+const releaseIndex = escape.indexOf('host.releaseNextQueuedMessage()');
+const cancelIndex = escape.indexOf('host.markCurrentRunCancelledByUser()');
+assert.ok(releaseIndex >= 0, 'Escape must release queued work');
+assert.ok(cancelIndex > releaseIndex, 'Escape must release queued work before cancelling the run');
+
+const releaseNextQueuedMessage = method('releaseNextQueuedMessage', 'markCurrentRunCancelledByUser');
+const releaseHost = {
+  queueSteerInFlight: undefined,
+  queueFlushBatchRemaining: 0,
+  state: {
+    queuedMessages: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
+    ui: { requestRender() {} },
+  },
+  steerQueueFlushPrefixCalls: 0,
+  updateQueueDisplayCalls: 0,
+  steerQueueFlushPrefix() { this.steerQueueFlushPrefixCalls += 1; },
+  updateQueueDisplay() { this.updateQueueDisplayCalls += 1; },
+};
+
+assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
+assert.equal(releaseHost.queueFlushBatchRemaining, 1);
+assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
+assert.equal(releaseHost.queueFlushBatchRemaining, 2);
+assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
+assert.equal(releaseHost.queueFlushBatchRemaining, 3);
+assert.equal(releaseNextQueuedMessage.call(releaseHost), false);
+assert.equal(releaseHost.queueFlushBatchRemaining, 3);
+assert.equal(releaseHost.steerQueueFlushPrefixCalls, 3);
+
+const flushQueuedMessages = method('flushQueuedMessages', 'steerQueueFlushPrefix');
+const flushHost = {
+  queueSteerInFlight: { items: [{ text: 'already accepted' }] },
+  queueFlushBatchRemaining: 0,
+  state: {
+    queuedMessages: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
+    editor: { setText() {}, inputMode: 'prompt' },
+  },
+  steerQueueFlushPrefixCalls: 0,
+  scheduleQueueDrainCalls: 0,
+  steerQueueFlushPrefix() { this.steerQueueFlushPrefixCalls += 1; },
+  scheduleQueueDrain() { this.scheduleQueueDrainCalls += 1; },
+};
+
+flushQueuedMessages.call(flushHost, '', 'prompt');
+assert.equal(flushHost.queueFlushBatchRemaining, 4);
+assert.equal(flushHost.steerQueueFlushPrefixCalls, 1);
+assert.equal(flushHost.scheduleQueueDrainCalls, 1);
+
+const commitQueuedSteer = method('commitQueuedSteer', 'recoverRejectedActiveSteer');
+let commits = 0;
+const inFlight = {
+  items: [{ text: 'telegram message' }],
+  confirmationTimer: undefined,
+  onCommit() { commits += 1; },
+};
+const commitHost = {
+  queueSteerInFlight: inFlight,
+  updateQueueDisplay() {},
+  state: { ui: { requestRender() {} } },
+  steerQueueFlushPrefix() {},
+  scheduleQueueDrain() {},
+};
+
+commitQueuedSteer.call(commitHost, inFlight);
+commitQueuedSteer.call(commitHost, inFlight);
+assert.equal(commits, 1);
+assert.equal(commitHost.queueSteerInFlight, undefined);
+
+const acceptQueuedSteer = method('acceptQueuedSteer', 'commitQueuedSteerIfReady');
+let acceptedCommits = 0;
+const acceptedInFlight = {
+  items: [{ channelDeliveryTrace: { messageId: '63508' } }],
+  accepted: false,
+  stepStarted: false,
+  turnEnded: false,
+  onCommit() { acceptedCommits += 1; },
+};
+const acceptedHost = {
+  queueSteerInFlight: acceptedInFlight,
+  traced: [],
+  traceTelegramDelivery(event) { this.traced.push(event); },
+  commitQueuedSteer(item) {
+    assert.equal(item, acceptedInFlight);
+    if (this.queueSteerInFlight !== item) return;
+    this.queueSteerInFlight = undefined;
+    item.onCommit();
+  },
+};
+
+assert.equal(acceptQueuedSteer.call(acceptedHost, acceptedInFlight, {
+  accepted: true,
+  duplicate: false,
+  turnId: 77,
+}, true), true);
+assert.equal(acceptedCommits, 1, 'durably accepted steer must commit before a delayed step event');
+assert.equal(acceptedHost.queueSteerInFlight, undefined);
+assert.equal(acceptedHost.traced.length, 1);
+assert.equal(acceptedHost.traced[0].stage, 'accepted');
+
+const recoverRejectedActiveSteer = method('recoverRejectedActiveSteer', 'quarantineQueuedSteer');
+let restored = 0;
+const rejectedInFlight = {
+  items: [{ text: 'keep me queued', channelDeliveryFailures: 2 }],
+  onRestore() { restored += 1; },
+};
+const rejectedHost = {
+  queueSteerInFlight: rejectedInFlight,
+  state: { queuedMessages: [], ui: { requestRender() {} } },
+  traced: [],
+  traceTelegramDelivery(event) { this.traced.push(event); },
+  updateQueueDisplay() {},
+  streamingUI: { hasActiveTurn() { return true; } },
+};
+
+assert.equal(recoverRejectedActiveSteer.call(rejectedHost, rejectedInFlight), false);
+assert.equal(restored, 1);
+assert.equal(rejectedHost.state.queuedMessages.length, 1, 'rejected steer must remain queued');
+assert.equal(rejectedHost.state.queuedMessages[0].text, 'keep me queued');
+assert.equal('channelDeliveryFailures' in rejectedHost.state.queuedMessages[0], false);
+
+const channelDelivery = between('\n\tasync deliverQueuedChannelHead() {', '\n\tinstallChannelReplyGuard(');
+assert.match(
+  channelDelivery,
+  /if \(!result\.accepted\) return this\.recoverRejectedActiveSteer\(inFlight\);[\s\S]*return this\.acceptQueuedSteer\(inFlight, result, true\);/,
+  'channel delivery must commit a durably accepted active steer',
+);
+assert.doesNotMatch(
+  channelDelivery,
+  /channel steer confirmation timed out|CHANNEL_STEER_CONFIRM_TIMEOUT_MS/,
+  'durably accepted channel messages must not be restored by a wall-clock timeout',
+);
+
+const ctrlSDelivery = between('\n\tsteerQueueFlushPrefix() {', '\n\tdrainOneQueuedMessage() {');
+assert.match(
+  ctrlSDelivery,
+  /if \(!result\.accepted\) this\.recoverRejectedActiveSteer\(inFlight\);[\s\S]*else this\.acceptQueuedSteer\(inFlight, result\);/,
+  'Ctrl+S delivery must use the same durable acceptance rule',
+);
+
+const priorityQueue = [{ id: 'normal-a' }, { id: 'normal-b' }];
+enqueueTelegramBotPriority(priorityQueue, { id: 'bot-a', channelBotPriority: true });
+enqueueTelegramBotPriority(priorityQueue, { id: 'bot-b', channelBotPriority: true });
+enqueueTelegramAddressed(priorityQueue, { id: 'addressed-a', channelAddressed: true });
+enqueueTelegramAddressed(priorityQueue, { id: 'addressed-b', channelAddressed: true });
+enqueueTelegramDirect(priorityQueue, { id: 'direct-a', channelDirect: true });
+enqueueTelegramDirect(priorityQueue, { id: 'direct-b', channelDirect: true });
+enqueueTelegramUrgent(priorityQueue, { id: 'urgent-a', channelUrgent: true });
+enqueueTelegramUrgent(priorityQueue, { id: 'urgent-b', channelUrgent: true });
+assert.deepEqual(
+  priorityQueue.map((item) => item.id),
+  [
+    'urgent-a', 'urgent-b',
+    'direct-a', 'direct-b',
+    'addressed-a', 'addressed-b',
+    'bot-a', 'bot-b',
+    'normal-a', 'normal-b',
+  ],
+  'Telegram queue priority must be urgent, direct, addressed, bot, normal with stable FIFO inside each class',
+);
+
+console.log('queue controls regression: PASS');

package/scripts/check-resume-replay-regression.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.join(__dirname, '..', 'blun.mjs');
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+
+function between(start, end) {
+  const startIndex = bundle.indexOf(start);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+function compileMethod(name, nextName, dependencies = {}) {
+  const source = between(`\n\t\t${name}(`, `\n\t\t${nextName}(`).trim();
+  const names = Object.keys(dependencies);
+  const values = Object.values(dependencies);
+  return Function(...names, `"use strict"; return ({${source}}).${name};`)(...values);
+}
+
+function resolveStepEventUuid(openSteps, event) {
+  if (event.stepUuid !== undefined) return event.stepUuid;
+  let latest;
+  for (const uuid of openSteps.keys()) latest = uuid;
+  return latest;
+}
+
+function resolveCompletedStepUuid(openSteps, event) {
+  if (event.uuid !== undefined) return event.uuid;
+  let latest;
+  for (const uuid of openSteps.keys()) latest = uuid;
+  return latest;
+}
+
+const recoverMissingOpenStep = compileMethod(
+  'recoverMissingOpenStep',
+  'appendLoopEvent',
+  { resolveStepEventUuid },
+);
+const appendLoopEvent = compileMethod(
+  'appendLoopEvent',
+  'appendMessage',
+  {
+    projectLoopEventForRecord: (event) => event,
+    resolveCompletedStepUuid,
+    createToolMessage: (toolCallId, content) => ({ toolCallId, content, toolCalls: [] }),
+    toolResultOutputForModel: (result) => result.output,
+    estimateTokensForMessages: () => 0,
+  },
+);
+
+const records = [];
+const warnings = [];
+const host = {
+  _history: [],
+  _tokenCount: 0,
+  tokenCountCoveredMessageCount: 0,
+  openSteps: new Map(),
+  pendingToolResultIds: new Set(),
+  agent: {
+    records: {
+      restoring: { time: Date.now() },
+      logRecord(record) { records.push(record); },
+    },
+    log: { warn(message, fields) { warnings.push({ message, fields }); } },
+  },
+  recoverMissingOpenStep,
+  pushHistory(...messages) { this._history.push(...messages); },
+  markPendingTokenEstimateDirty() {},
+  flushDeferredMessagesIfToolExchangeClosed() {},
+  closePendingToolResults() { return []; },
+};
+
+// Exact shape measured after context.apply_compaction: no step.begin survives,
+// then text, a tool call/result pair, and step.end continue the interrupted turn.
+appendLoopEvent.call(host, { type: 'content.part', part: { type: 'text', text: 'continued after compaction' } });
+appendLoopEvent.call(host, { type: 'tool.call', toolCallId: 'tool-1', name: 'Read', args: { path: 'SPEC.md' } });
+appendLoopEvent.call(host, { type: 'tool.result', toolCallId: 'tool-1', result: { output: 'ok', isError: false } });
+appendLoopEvent.call(host, { type: 'step.end', contextTokens: 100 });
+
+assert.equal(warnings.length, 1, 'one missing step must produce one bounded repair warning');
+assert.equal(warnings[0].fields.eventType, 'content.part');
+assert.equal(warnings[0].fields.restoring, true);
+assert.equal(host._history.length, 2, 'repair must retain the assistant continuation and its tool result');
+assert.deepEqual(host._history[0].content, [{ type: 'text', text: 'continued after compaction' }]);
+assert.equal(host._history[0].toolCalls.length, 1);
+assert.equal(host._history[0].toolCalls[0].id, 'tool-1');
+assert.equal(host._history[1].toolCallId, 'tool-1');
+assert.equal(host.pendingToolResultIds.size, 0);
+assert.equal(host.openSteps.size, 0);
+assert.equal(records.filter((record) => record.type === 'context.append_loop_event').length, 4);
+
+process.stdout.write('resume-replay-regression PASS\n');

package/scripts/check-telegram-bridge-watchdog.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundle = fs.readFileSync(path.join(__dirname, '..', 'blun.mjs'), 'utf8');
+
+function between(start, end) {
+  const startIndex = bundle.indexOf(start);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+function method(name, nextName) {
+  const source = between(`\n\t${name}(`, `\n\t${nextName}(`).trim();
+  return Function(`"use strict"; return ({${source}}).${name};`)();
+}
+
+async function main() {
+  const scheduleBridgeRestart = method('scheduleBridgeRestart', 'ensureBridgeRunning');
+  const host = {
+    stopped: false,
+    activeOwner: true,
+    bridgeRestartTimer: undefined,
+    bridgeRestartDelayMs: 5,
+    ownsChannel() { return true; },
+    starts: 0,
+    ensureBridgeRunning() { this.starts += 1; },
+  };
+
+  scheduleBridgeRestart.call(host);
+  const firstTimer = host.bridgeRestartTimer;
+  assert.notEqual(firstTimer, undefined);
+  scheduleBridgeRestart.call(host);
+  assert.equal(host.bridgeRestartTimer, firstTimer, 'restart scheduling must be deduplicated');
+  await new Promise((resolve) => setTimeout(resolve, 25));
+  assert.equal(host.starts, 1, 'a dead owned bridge must be restarted once');
+  assert.equal(host.bridgeRestartTimer, undefined);
+
+  host.stopped = true;
+  scheduleBridgeRestart.call(host);
+  assert.equal(host.bridgeRestartTimer, undefined, 'stopped controllers must not restart bridges');
+
+  const ensureBridgeRunning = between('\n\tensureBridgeRunning() {', '\n\tresolveBridgeEntry() {');
+  assert.match(ensureBridgeRunning, /child\.once\("exit",[\s\S]*this\.scheduleBridgeRestart\(\)/);
+  assert.match(ensureBridgeRunning, /child\.once\("error",[\s\S]*this\.scheduleBridgeRestart\(\)/);
+  const beginStop = between('\n\tbeginStop() {', '\n\tasync stopOwnedBridge(');
+  assert.match(beginStop, /clearTimeout\(this\.bridgeRestartTimer\)/);
+
+  process.stdout.write('telegram-bridge-watchdog PASS\n');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/check-todo-loop-regression.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { enforceSingleTodoWritePerStep } = require('../bin/todo-list-turn-policy.cjs');
+
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.resolve(__dirname, '..', 'blun.mjs');
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+assert(
+  !bundle.includes('TodoList is unchanged after extended work'),
+  'TODO_LOOP_REGRESSION: unchanged truthful TodoList refreshes must remain accepted',
+);
+assert(
+  !/isIdle:\s*\(task\)\s*=>[\s\S]{0,240}owner\s*!==\s*["']session-loop["']/.test(bundle),
+  'TODO_LOOP_REGRESSION: unfinished TodoList work must not suppress an idle session loop',
+);
+assert(
+  /isIdle:\s*\(\)\s*=>\s*!agent\.turn\.hasActiveTurn/.test(bundle),
+  'TODO_LOOP_REGRESSION: expected idle-only session loop scheduler wiring is missing',
+);
+assert(
+  /todos\.filter\(\(todo\)\s*=>\s*todo\.status\s*!==\s*["']done["']\)/.test(bundle),
+  'TODO_LIFECYCLE_REGRESSION: completed items must be pruned from the stored visible list',
+);
+assert(
+  /const PENDING_TEXT\s*=\s*["']#aeb8c6["']/.test(bundle)
+    && !/const PENDING_TEXT\s*=\s*["']#2a3550["']/.test(bundle),
+  'TODO_UI_REGRESSION: pending markers must remain visible on ANSI16 terminals',
+);
+assert(
+  /activeGoal\s*===\s*null\s*&&\s*!startsTrackedList/.test(bundle)
+    && /The first TodoList must contain at least one item, exactly one in_progress item/.test(bundle),
+  'TODO_INITIAL_STATE_REGRESSION: a new non-goal TodoList must not accept an all-pending list',
+);
+assert(
+  /enforceSingleTodoWritePerStep\(ctx\)/.test(bundle),
+  'TODO_PARALLEL_REGRESSION: per-step TodoList write guard is not wired',
+);
+
+const calls = [
+  { id: 'todo-first', name: 'TodoList' },
+  { id: 'todo-second', name: 'TodoList' },
+];
+assert(
+  enforceSingleTodoWritePerStep({
+    toolCall: calls[0],
+    toolCalls: calls,
+    args: { todos: [{ title: 'first', status: 'in_progress' }] },
+  }) === undefined,
+  'TODO_PARALLEL_REGRESSION: first TodoList write must remain executable',
+);
+const duplicateWrite = enforceSingleTodoWritePerStep({
+  toolCall: calls[1],
+  toolCalls: calls,
+  args: { todos: [{ title: 'second', status: 'in_progress' }] },
+});
+assert(
+  duplicateWrite?.block === true,
+  'TODO_PARALLEL_REGRESSION: later TodoList writes in the same step must be blocked',
+);
+assert(
+  enforceSingleTodoWritePerStep({
+    toolCall: { id: 'todo-read', name: 'TodoList' },
+    toolCalls: calls,
+    args: {},
+  }) === undefined,
+  'TODO_PARALLEL_REGRESSION: read-only TodoList queries must not be blocked',
+);
+
+process.stdout.write('todo-loop-regression PASS\n');