blun-king-cli 9.1.536 → 9.1.550

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-progress-regression.js

@@ -1,416 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const assert = require('node:assert/strict');
-const { spawnSync } = require('node:child_process');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const packageRoot = path.resolve(__dirname, '..');
-const bundlePath = process.env.BLUN_TODO_PROGRESS_BUNDLE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_TODO_PROGRESS_BUNDLE_UNDER_TEST)
-  : path.join(packageRoot, 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-const policyPath = process.env.BLUN_TODO_PROGRESS_POLICY_UNDER_TEST
-  ? path.resolve(process.env.BLUN_TODO_PROGRESS_POLICY_UNDER_TEST)
-  : path.join(packageRoot, 'bin', 'todo-list-turn-policy.cjs');
-
-const {
-  MAX_TODO_ITEMS,
-  assessTodoListBounds,
-  assessTodoMaintenanceUpdate,
-  canonicalStoredTodos,
-} = require(policyPath);
-const { normalizeTodoProgressState } = require(path.join(
-  packageRoot,
-  'bin',
-  'agent-resume-snapshot.cjs',
-));
-
-function todos(count, status = 'pending') {
-  return Array.from({ length: count }, (_, index) => ({
-    title: `Task ${String(index + 1)}`,
-    status: index === 0 && status === 'pending' ? 'in_progress' : status,
-  }));
-}
-
-function between(startNeedle, endNeedle) {
-  const start = bundle.indexOf(startNeedle);
-  assert.notEqual(start, -1, `TODO_PROGRESS: missing bundle start ${startNeedle}`);
-  const end = bundle.indexOf(endNeedle, start + startNeedle.length);
-  assert.notEqual(end, -1, `TODO_PROGRESS: missing bundle end ${endNeedle}`);
-  return bundle.slice(start, end);
-}
-
-function extractFunction(name) {
-  const start = bundle.indexOf(`function ${name}(`);
-  assert.notEqual(start, -1, `TODO_PROGRESS: missing function ${name}`);
-  const open = bundle.indexOf('{', start);
-  let depth = 0;
-  for (let index = open; index < bundle.length; index += 1) {
-    if (bundle[index] === '{') depth += 1;
-    if (bundle[index] === '}') depth -= 1;
-    if (depth === 0) return bundle.slice(start, index + 1);
-  }
-  assert.fail(`TODO_PROGRESS: incomplete function ${name}`);
-}
-
-function assertBundleContract() {
-  assert.match(
-    bundle,
-    /\(\{ assessTodoListBounds, assessTodoMaintenanceUpdate, enforceSingleTodoWritePerStep, todoRefreshWorkCallLimit \} = createRequire\(import\.meta\.url\)\("\.\/bin\/todo-list-turn-policy\.cjs"\)\);/u,
-    'TODO_PROGRESS: bundle must import every progress-policy helper',
-  );
-  const prepare = between('prepareToolExecution: async (ctx) => {', 'authorizeToolExecution: async (ctx) => {');
-  const boundsIndex = prepare.indexOf('enforceTodoListBounds(this.agent, ctx)');
-  const goalIndex = prepare.indexOf('enforceGoalTodoPolicy(this.agent, ctx)');
-  assert.ok(boundsIndex >= 0 && goalIndex > boundsIndex, 'TODO_PROGRESS: bounds must run before goal/idea exceptions');
-
-  const evidence = between('function recordGoalTodoEvidence(', 'function goalTodoMaintenanceMode(');
-  assert.doesNotMatch(
-    evidence,
-    /name === "TodoList"[\s\S]*recentEvidence = \[\]/u,
-    'TODO_PROGRESS: a successful unchanged refresh must not erase its evidence in finalize',
-  );
-  assert.match(evidence, /progress\.evidenceRevision = \(Number\(progress\.evidenceRevision\) \|\| 0\) \+ 1/u);
-
-  const mode = between('function goalTodoMaintenanceMode(', 'function goalTodoMaintenanceTools(');
-  assert.match(mode, /todoRefreshWorkCallLimit\(progress\.unchangedRefreshStreak\)/u);
-
-  const enforcement = between('function enforceGoalTodoPolicy(', 'function ideaOutboundChannel(');
-  assert.match(enforcement, /assessTodoMaintenanceUpdate\(\{/u);
-  assert.match(enforcement, /code: "todo-maintenance-stalled"/u);
-  assert.match(enforcement, /if \(!maintenanceUpdate\.preserveRecentEvidence\) progress\.recentEvidence = \[\]/u);
-  assert.match(enforcement, /todoRefreshWorkCallLimit\(progress\.unchangedRefreshStreak\)/u);
-  assert.doesNotMatch(bundle, /const GOAL_TODO_REFRESH_WORK_CALL_LIMIT = 8/u);
-  assert.doesNotMatch(bundle, /TodoList is unchanged after extended work/u);
-  assert.match(bundle, /If no boundary is proven, preserve the list unchanged; never invent progress\./u);
-
-  const resumeSource = fs.readFileSync(
-    path.join(packageRoot, 'bin', 'agent-resume-snapshot.cjs'),
-    'utf8',
-  );
-  assert.match(resumeSource, /todoProgress: normalizeTodoProgressState\(agent\.goalTodoPolicyState\) \?\? null/u);
-  assert.match(resumeSource, /agent\.goalTodoPolicyState = normalizeTodoProgressState\(snapshot\.todoProgress\)/u);
-}
-
-function exerciseBundledPolicy() {
-  const ideaTodos = (agent) => agent.tools.store.todo ?? [];
-  const goalTodoProgressState = Function(
-    `"use strict"; return (${extractFunction('goalTodoProgressState')});`,
-  )();
-  const enforceTodoListBounds = Function(
-    'assessTodoListBounds',
-    'ideaTodos',
-    `"use strict"; return (${extractFunction('enforceTodoListBounds')});`,
-  )(assessTodoListBounds, ideaTodos);
-  const enforceGoalTodoPolicy = Function(
-    'isIdeaGoal',
-    'TELEGRAM_DELIVERY_TOOL_RE',
-    'ideaTodos',
-    'goalTodoProgressState',
-    'validInitialIdeaPlan',
-    'IDEA_TERMINAL_TODO_STATUSES',
-    'assessTodoMaintenanceUpdate',
-    'todoRefreshWorkCallLimit',
-    `"use strict"; return (${extractFunction('enforceGoalTodoPolicy')});`,
-  )(
-    () => false,
-    /^mcp__[^\s]*telegram[^\s]*__(?:reply|edit_message)$/iu,
-    ideaTodos,
-    goalTodoProgressState,
-    () => true,
-    Object.freeze(['done', 'blocked', 'waiting_approval', 'aborted']),
-    assessTodoMaintenanceUpdate,
-    require(policyPath).todoRefreshWorkCallLimit,
-  );
-  const goalTodoMaintenanceMode = Function(
-    'isIdeaGoal',
-    'ideaTodos',
-    'goalTodoProgressState',
-    'todoRefreshWorkCallLimit',
-    `"use strict"; return (${extractFunction('goalTodoMaintenanceMode')});`,
-  )(
-    () => false,
-    ideaTodos,
-    goalTodoProgressState,
-    require(policyPath).todoRefreshWorkCallLimit,
-  );
-
-  const emitted = [];
-  const agent = {
-    tools: { store: { todo: current.map((todo) => ({ ...todo })) } },
-    goal: { getActiveGoal: () => ({ objective: 'exercise policy' }) },
-    goalTodoPolicyState: {
-      workCallsSinceRefresh: 8,
-      refreshRequired: true,
-      unchangedRefreshStreak: 2,
-      recentEvidence: ['Bash succeeded: candidate.js'],
-      evidenceRevision: 4,
-      lastMaintenanceEvidenceRevision: 3,
-    },
-    emitEvent(event) { emitted.push(event); },
-  };
-  const unchangedContext = {
-    toolCall: { id: 'todo-1', name: 'TodoList' },
-    toolCalls: [{ id: 'todo-1', name: 'TodoList' }],
-    args: { todos: current.map((todo) => ({ ...todo })) },
-  };
-  assert.equal(enforceTodoListBounds(agent, unchangedContext), undefined);
-  assert.equal(enforceGoalTodoPolicy(agent, unchangedContext), undefined);
-  assert.equal(agent.goalTodoPolicyState.unchangedRefreshStreak, 3);
-  assert.deepEqual(agent.goalTodoPolicyState.recentEvidence, ['Bash succeeded: candidate.js']);
-  assert.equal(agent.goalTodoPolicyState.workCallsSinceRefresh, 0);
-  assert.equal(agent.goalTodoPolicyState.refreshRequired, false);
-  assert.equal(emitted.length, 1);
-  assert.equal(emitted[0].code, 'todo-maintenance-stalled');
-  assert.equal(emitted[0].blocked, false);
-
-  agent.goalTodoPolicyState.workCallsSinceRefresh = 63;
-  assert.equal(goalTodoMaintenanceMode(agent), null, '64-call backoff must leave work available');
-  agent.goalTodoPolicyState.workCallsSinceRefresh = 64;
-  assert.equal(goalTodoMaintenanceMode(agent), 'refresh');
-
-  agent.goalTodoPolicyState.recentEvidence = ['Write succeeded: candidate.js'];
-  agent.goalTodoPolicyState.evidenceRevision = 5;
-  const changedContext = {
-    ...unchangedContext,
-    toolCall: { id: 'todo-2', name: 'TodoList' },
-    toolCalls: [{ id: 'todo-2', name: 'TodoList' }],
-    args: {
-      todos: [
-        { title: 'Measure source', status: 'done' },
-        { title: 'Write candidate', status: 'in_progress' },
-      ],
-    },
-  };
-  assert.equal(enforceGoalTodoPolicy(agent, changedContext), undefined);
-  assert.equal(agent.goalTodoPolicyState.unchangedRefreshStreak, 0);
-  assert.deepEqual(agent.goalTodoPolicyState.recentEvidence, []);
-
-  const oversizedAgent = {
-    tools: { store: { todo: [] } },
-  };
-  const oversized = enforceTodoListBounds(oversizedAgent, {
-    toolCall: { name: 'TodoList' },
-    args: { todos: todos(33) },
-  });
-  assert.equal(oversized.block, true);
-  assert.match(oversized.reason, /at most 32 visible items/u);
-}
-
-assert.equal(MAX_TODO_ITEMS, 32, 'TODO_PROGRESS: visible list cap must be 32');
-
-const current = [
-  { title: 'Measure source', status: 'in_progress' },
-  { title: 'Write candidate', status: 'pending' },
-];
-
-const unchangedOne = assessTodoMaintenanceUpdate({
-  currentTodos: current,
-  nextTodos: current,
-  unchangedRefreshStreak: 0,
-  recentEvidenceCount: 8,
-});
-assert.deepEqual(unchangedOne, {
-  changed: false,
-  unchangedRefreshStreak: 1,
-  refreshWorkCallLimit: 16,
-  preserveRecentEvidence: true,
-  requireConcreteProgress: false,
-  emitStalledWarning: false,
-});
-
-const unchangedTwo = assessTodoMaintenanceUpdate({
-  currentTodos: current,
-  nextTodos: current,
-  unchangedRefreshStreak: unchangedOne.unchangedRefreshStreak,
-  recentEvidenceCount: 8,
-});
-assert.equal(unchangedTwo.changed, false);
-assert.equal(unchangedTwo.unchangedRefreshStreak, 2);
-assert.equal(unchangedTwo.refreshWorkCallLimit, 32);
-assert.equal(unchangedTwo.preserveRecentEvidence, true);
-assert.equal(unchangedTwo.requireConcreteProgress, true);
-assert.equal(unchangedTwo.emitStalledWarning, false);
-
-const unchangedThree = assessTodoMaintenanceUpdate({
-  currentTodos: current,
-  nextTodos: current,
-  unchangedRefreshStreak: unchangedTwo.unchangedRefreshStreak,
-  recentEvidenceCount: 8,
-});
-assert.equal(unchangedThree.unchangedRefreshStreak, 3);
-assert.equal(unchangedThree.refreshWorkCallLimit, 64);
-assert.equal(unchangedThree.requireConcreteProgress, true);
-assert.equal(unchangedThree.emitStalledWarning, true);
-
-const unchangedWithoutEvidence = assessTodoMaintenanceUpdate({
-  currentTodos: current,
-  nextTodos: current,
-  unchangedRefreshStreak: 2,
-  recentEvidenceCount: 0,
-});
-assert.equal(unchangedWithoutEvidence.unchangedRefreshStreak, 2);
-assert.equal(unchangedWithoutEvidence.preserveRecentEvidence, true);
-assert.equal(unchangedWithoutEvidence.emitStalledWarning, false);
-
-const changed = assessTodoMaintenanceUpdate({
-  currentTodos: current,
-  nextTodos: [
-    { title: 'Measure source', status: 'done' },
-    { title: 'Write candidate', status: 'in_progress' },
-  ],
-  unchangedRefreshStreak: 3,
-  recentEvidenceCount: 8,
-});
-assert.deepEqual(changed, {
-  changed: true,
-  unchangedRefreshStreak: 0,
-  refreshWorkCallLimit: 8,
-  preserveRecentEvidence: false,
-  requireConcreteProgress: false,
-  emitStalledWarning: false,
-});
-assert.deepEqual(canonicalStoredTodos([
-  { title: 'Measure source', status: 'done' },
-  { title: 'Write candidate', status: 'in_progress' },
-]), [{ title: 'Write candidate', status: 'in_progress' }]);
-
-assert.equal(assessTodoListBounds({ currentTodos: [], nextTodos: todos(32) }), undefined);
-assert.match(
-  assessTodoListBounds({ currentTodos: [], nextTodos: todos(33) }).reason,
-  /at most 32 visible items/,
-);
-
-const legacy = todos(47);
-assert.equal(
-  assessTodoListBounds({ currentTodos: legacy, nextTodos: legacy }),
-  undefined,
-  'TODO_PROGRESS: unchanged legacy lists must not deadlock',
-);
-assert.match(
-  assessTodoListBounds({ currentTodos: legacy, nextTodos: legacy.slice(0, 46) }).reason,
-  /may remove an unresolved legacy item only by submitting it as done/,
-);
-const legacyWithDone = legacy.map((todo, index) => index === 46
-  ? { ...todo, status: 'done' }
-  : todo);
-assert.equal(
-  assessTodoListBounds({ currentTodos: legacy, nextTodos: legacyWithDone }),
-  undefined,
-  'TODO_PROGRESS: explicit done pruning must shrink an oversized legacy list',
-);
-const legacyShrunkAndRenamed = legacyWithDone.map((todo, index) => index === 0
-  ? { ...todo, title: 'Replacement task' }
-  : todo);
-assert.match(
-  assessTodoListBounds({ currentTodos: legacy, nextTodos: legacyShrunkAndRenamed }).reason,
-  /Do not add, omit, or rename items/,
-  'TODO_PROGRESS: crossing the cap must not bypass legacy identity checks',
-);
-
-assertBundleContract();
-exerciseBundledPolicy();
-
-assert.deepEqual(normalizeTodoProgressState({
-  workCallsSinceRefresh: 64,
-  refreshRequired: true,
-  unchangedRefreshStreak: 3,
-  recentEvidence: Array.from({ length: 10 }, (_, index) => `evidence-${String(index)}`),
-  evidenceRevision: 12,
-  lastMaintenanceEvidenceRevision: 11,
-  allVisibleWorkCompleted: false,
-}), {
-  workCallsSinceRefresh: 64,
-  refreshRequired: true,
-  unchangedRefreshStreak: 3,
-  recentEvidence: Array.from({ length: 8 }, (_, index) => `evidence-${String(index + 2)}`),
-  evidenceRevision: 12,
-  lastMaintenanceEvidenceRevision: 11,
-  allVisibleWorkCompleted: false,
-});
-assert.equal(normalizeTodoProgressState(undefined), undefined);
-
-if (process.env.BLUN_TODO_PROGRESS_SKIP_MUTATIONS !== '1') {
-  const originalPolicy = fs.readFileSync(policyPath, 'utf8');
-  const policyMutations = [
-    ['cap', 'const MAX_TODO_ITEMS = 32;', 'const MAX_TODO_ITEMS = 33;'],
-    ['unchanged-progress', ')\n    !== semanticTodoFingerprint(input?.nextTodos);', ')\n    === semanticTodoFingerprint(input?.nextTodos);'],
-    ['concrete-progress', 'requireConcreteProgress: unchangedRefreshStreak >= 2,', 'requireConcreteProgress: unchangedRefreshStreak >= 99,'],
-    ['stalled-warning', 'unchangedRefreshStreak === TODO_STALLED_WARNING_STREAK,', 'unchangedRefreshStreak === 99,'],
-  ];
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-todo-progress-mutations-'));
-  try {
-    for (const [name, needle, replacement] of policyMutations) {
-      assert.ok(originalPolicy.includes(needle), `TODO_PROGRESS: mutation anchor missing: ${name}`);
-      const mutatedPath = path.join(tempRoot, `${name}.cjs`);
-      fs.writeFileSync(mutatedPath, originalPolicy.replace(needle, replacement), 'utf8');
-      const result = spawnSync(process.execPath, [__filename], {
-        encoding: 'utf8',
-        env: {
-          ...process.env,
-          BLUN_TODO_PROGRESS_POLICY_UNDER_TEST: mutatedPath,
-          BLUN_TODO_PROGRESS_SKIP_MUTATIONS: '1',
-        },
-        windowsHide: true,
-      });
-      assert.notEqual(
-        result.status,
-        0,
-        `TODO_PROGRESS: ${name} mutation survived the regression gate`,
-      );
-    }
-
-    const bundleMutations = [
-      [
-        'bounds-wiring',
-        '\t\t\t\t\t\t\t\tconst todoBoundsPolicy = enforceTodoListBounds(this.agent, ctx);\n\t\t\t\t\t\t\t\tif (todoBoundsPolicy !== void 0) return todoBoundsPolicy;\n',
-        '',
-        __filename,
-      ],
-      [
-        'done-pruning',
-        'todos.filter((todo) => todo.status !== "done")',
-        'todos.filter((todo) => todo.status !== "never_done")',
-        path.join(__dirname, 'check-todo-loop-regression.js'),
-      ],
-      [
-        'recovery-catalog',
-        '\t"Bash"\n]);',
-        '\t"WebSearch"\n]);',
-        path.join(__dirname, 'check-todo-recovery-catalog-regression.js'),
-      ],
-    ];
-    for (const [name, needle, replacement, gatePath] of bundleMutations) {
-      assert.ok(bundle.includes(needle), `TODO_PROGRESS: bundle mutation anchor missing: ${name}`);
-      const mutatedPath = path.join(tempRoot, `${name}.mjs`);
-      fs.writeFileSync(mutatedPath, bundle.replace(needle, replacement), 'utf8');
-      const gateIsSelf = gatePath === __filename;
-      const result = spawnSync(process.execPath, [gatePath], {
-        encoding: 'utf8',
-        env: {
-          ...process.env,
-          ...(gateIsSelf
-            ? {
-              BLUN_TODO_PROGRESS_BUNDLE_UNDER_TEST: mutatedPath,
-              BLUN_TODO_PROGRESS_SKIP_MUTATIONS: '1',
-            }
-            : { BLUN_BUNDLE_UNDER_TEST: mutatedPath }),
-        },
-        windowsHide: true,
-      });
-      assert.notEqual(
-        result.status,
-        0,
-        `TODO_PROGRESS: ${name} bundle mutation survived its regression gate`,
-      );
-    }
-  } finally {
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-  }
-}
-
-process.stdout.write('todo-progress-regression PASS (bundle + 7 mutations)\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');

package/scripts/check-tool-schema-capacity-regression.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const assert = require('node:assert/strict');
-const path = require('node:path');
-
-const packageRoot = process.env.BLUN_PACKAGE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_PACKAGE_UNDER_TEST)
-  : path.resolve(__dirname, '..');
-const policy = require(path.join(packageRoot, 'bin', 'turn-tool-performance-policy.cjs'));
-
-assert.equal(policy.TOOL_SCHEMA_BUDGET_RATIO, 0.35);
-assert.equal(policy.TOOL_SCHEMA_MAX_TOKENS, 64_000);
-assert.equal(policy.MAX_PERSISTENT_DEFERRED_TOOLS, 12);
-assert.equal(policy.MAX_AUTO_RANKED_TOOLS, 6);
-assert.equal(policy.toolSchemaBudgetTokens(1_048_576), 64_000);
-assert.equal(policy.toolSchemaBudgetTokens(100_000), 35_000);
-
-const tools = Array.from({ length: 20 }, (_, index) => ({
-  name: `DeferredTool${String(index + 1)}`,
-  description: `Deferred tool ${String(index + 1)}`,
-  parameters: { type: 'object', properties: {} },
-}));
-const selected = [];
-const loaded = new Set();
-const loader = policy.createDeferredToolLoader(selected, tools, loaded);
-
-(async () => {
-  for (let index = 0; index < tools.length; index += 1) {
-    const execution = loader.resolveExecution({ query: `select:${tools[index].name}` });
-    const result = await execution.execute();
-    assert.equal(result.isError, false);
-  }
-  assert.equal(loaded.size, 12, 'the twelve most recently loaded schemas must persist');
-  assert.deepEqual([...loaded], tools.slice(-12).map((tool) => tool.name));
-  process.stdout.write('tool-schema-capacity-regression PASS\n');
-})().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});