blun-king-cli 9.1.527 → 9.1.550

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

@@ -1,60 +0,0 @@
-#!/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-telegram-loop-exactly-once-regression.js

@@ -1,71 +0,0 @@
-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');
-const match = /async function handleLoopCommand\(host, args\) \{([\s\S]*?)\n\}\nfunction hasRunnableSession/.exec(bundle);
-assert(match, 'TELEGRAM_LOOP_EXACTLY_ONCE: handleLoopCommand is missing');
-
-const handleLoopCommand = Function(
-  'parseLoopCommand',
-  'hasRunnableSession',
-  'llmNotSetMessage',
-  'isStreaming',
-  `return async function handleLoopCommand(host, args) {${match[1]}\n};`,
-)(
-  () => ({ kind: 'create', interval: '*/5 * * * *', prompt: 'work once' }),
-  () => true,
-  () => 'missing model',
-  (host) => host.streaming,
-);
-
-function createHost({ telegram = false, streaming = true } = {}) {
-  const calls = { send: [], enqueue: [] };
-  const session = {
-    async createLoop({ interval, prompt }) {
-      return { interval, prompt, status: 'active' };
-    },
-  };
-  const host = {
-    streaming,
-    session,
-    telegramRemoteCommandContext: telegram ? { item: { telegramCommandName: 'loop' } } : undefined,
-    state: { appState: { isCompacting: false, model: 'blun/king' } },
-    requireSession() { return session; },
-    setAppState() {},
-    track() {},
-    showStatus() {},
-    showError(message) { throw new Error(message); },
-    sendNormalUserInput(text) { calls.send.push(text); },
-    enqueueNormalUserInput(text) { calls.enqueue.push(text); },
-  };
-  return { host, calls };
-}
-
-(async () => {
-  const telegram = createHost({ telegram: true, streaming: true });
-  await handleLoopCommand(telegram.host, '5 min work once');
-  assert.deepEqual(telegram.calls.send, ['work once']);
-  assert.deepEqual(
-    telegram.calls.enqueue,
-    [],
-    'TELEGRAM_LOOP_EXACTLY_ONCE: Telegram loop payload must not survive in the normal queue',
-  );
-
-  const local = createHost({ telegram: false, streaming: true });
-  await handleLoopCommand(local.host, '5 min work once');
-  assert.deepEqual(local.calls.send, []);
-  assert.deepEqual(
-    local.calls.enqueue,
-    ['work once'],
-    'TELEGRAM_LOOP_EXACTLY_ONCE: local busy-loop behavior must stay queued',
-  );
-
-  console.log('telegram-loop-exactly-once-regression PASS');
-})().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

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

@@ -1,78 +0,0 @@
-#!/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');

package/scripts/check-todo-recovery-catalog-regression.js

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-'use 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.resolve(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-const namesMatch = bundle.match(
-  /const TODO_MAINTENANCE_RECOVERY_TOOL_NAMES = new Set\(\[([\s\S]*?)\]\);/,
-);
-const functionMatch = bundle.match(
-  /function goalTodoMaintenanceTools\(eligibleTools, selectedTools\) \{[\s\S]*?\n\}/,
-);
-
-assert(
-  !/proactive TodoList maintenance step[\s\S]{0,900}tools:\s*\[todoTool\]/.test(bundle),
-  'TODO_RECOVERY_CATALOG_REGRESSION: proactive maintenance still switches to TodoList-only',
-);
-assert(namesMatch, 'TODO_RECOVERY_CATALOG_REGRESSION: recovery tool names are missing');
-assert(functionMatch, 'TODO_RECOVERY_CATALOG_REGRESSION: recovery catalogue selector is missing');
-assert(
-  /proactive TodoList maintenance step[\s\S]{0,1100}tools:\s*todoMaintenanceTools/.test(bundle),
-  'TODO_RECOVERY_CATALOG_REGRESSION: proactive maintenance is not wired to the recovery catalogue',
-);
-
-const selectMaintenanceTools = Function(
-  `const TODO_MAINTENANCE_RECOVERY_TOOL_NAMES = new Set([${namesMatch[1]}]); return (${functionMatch[0]});`,
-)();
-const tools = ['TodoList', 'Read', 'Write', 'Edit', 'Bash', 'WebSearch'].map((name) => ({ name }));
-const selected = [tools[5], tools[1]];
-const actual = selectMaintenanceTools(tools, selected).map((tool) => tool.name);
-
-assert(
-  actual.join(',') === 'WebSearch,Read,TodoList,Write,Edit,Bash',
-  `TODO_RECOVERY_CATALOG_REGRESSION: unexpected catalogue ${actual.join(',')}`,
-);
-assert(
-  new Set(actual).size === actual.length,
-  'TODO_RECOVERY_CATALOG_REGRESSION: recovery catalogue contains duplicates',
-);
-
-process.stdout.write('todo-recovery-catalog-regression PASS\n');