blun-king-cli 9.1.536 → 9.1.550

package/scripts/check-shell-terminal-isolation-regression.js

@@ -1,81 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const vm = require('node:vm');
-const { spawn } = require('node:child_process');
-
-const packageRoot = path.resolve(__dirname, '..');
-const bundlePath = process.argv[2] === undefined
-  ? path.join(packageRoot, 'blun.mjs')
-  : path.resolve(process.argv[2]);
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-const source = /function buildLocalSpawnOptions\(isWindows, cwd, env\) \{[\s\S]*?\n\}/.exec(bundle)?.[0];
-
-assert(source, 'SHELL_TERMINAL_ISOLATION: buildLocalSpawnOptions is missing');
-
-const context = {};
-vm.runInNewContext(`${source}; globalThis.buildLocalSpawnOptions = buildLocalSpawnOptions;`, context);
-const buildLocalSpawnOptions = context.buildLocalSpawnOptions;
-const cwd = packageRoot;
-const env = { ...process.env, BLUN_SHELL_ISOLATION_PROBE: '1' };
-
-for (const isWindows of [false, true]) {
-  const options = buildLocalSpawnOptions(isWindows, cwd, env);
-  assert.deepEqual(Array.from(options.stdio), ['pipe', 'pipe', 'pipe']);
-  assert.equal(options.detached, true,
-    `local shell must start in a separate process group when isWindows=${String(isWindows)}`);
-  assert.equal(options.windowsHide, true);
-  assert.equal(options.cwd, cwd);
-  assert.equal(options.env, env);
-}
-
-async function runCapturedProcessProbe() {
-  const options = buildLocalSpawnOptions(process.platform === 'win32', cwd, env);
-  const child = spawn(process.execPath, [
-    '-e',
-    [
-      "process.stdin.setEncoding('utf8')",
-      "process.stdin.on('data', () => { process.exitCode = 90 })",
-      "process.stdin.on('end', () => {",
-      "  process.stdout.write('stdout-ok')",
-      "  process.stderr.write('stderr-ok')",
-      '})',
-    ].join(';'),
-  ], options);
-
-  let stdout = '';
-  let stderr = '';
-  child.stdout.setEncoding('utf8');
-  child.stderr.setEncoding('utf8');
-  child.stdout.on('data', (chunk) => { stdout += chunk; });
-  child.stderr.on('data', (chunk) => { stderr += chunk; });
-  child.stdin.end();
-
-  const exit = await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      child.kill();
-      reject(new Error('captured child did not observe stdin EOF'));
-    }, 10_000);
-    child.once('error', (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-    child.once('close', (code, signal) => {
-      clearTimeout(timer);
-      resolve({ code, signal });
-    });
-  });
-
-  assert.deepEqual(exit, { code: 0, signal: null });
-  assert.equal(stdout, 'stdout-ok');
-  assert.equal(stderr, 'stderr-ok');
-}
-
-runCapturedProcessProbe().then(() => {
-  process.stdout.write('shell-terminal-isolation-regression PASS\n');
-}).catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

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

@@ -1,89 +0,0 @@
-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/scripts/check-startup-swarm-command-regression.js

@@ -1,24 +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 packageRoot = process.env.BLUN_PACKAGE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_PACKAGE_UNDER_TEST)
-  : path.resolve(__dirname, '..');
-const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
-
-for (const needle of [
-  '.option("--swarm", "Start in swarm mode.", false)',
-  'swarm: raw["swarm"] === true,',
-  'thinking: startup.effort,',
-  'if (startup.effort !== void 0) await session.setThinking(startup.effort);',
-  'if (startup.swarm && !(await session.getStatus()).swarmMode) await session.setSwarmMode(true, "effort");',
-  'if (startup.swarm) this.setAppState({ swarmMode: true, swarmModeEntry: "effort" });',
-]) {
-  assert.ok(bundle.includes(needle), `startup swarm command wiring missing: ${needle}`);
-}
-
-process.stdout.write('startup-swarm-command-regression PASS\n');

package/scripts/check-structured-subagent-output-regression.js

@@ -1,331 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const { spawnSync } = require('node:child_process');
-const { readFileSync } = require('node:fs');
-const { join } = require('node:path');
-
-const root = join(__dirname, '..');
-const bundlePath = join(root, 'blun.mjs');
-
-function extractBetween(source, startNeedle, endNeedle) {
-  const start = source.indexOf(startNeedle);
-  assert.notEqual(start, -1, `missing source start: ${startNeedle}`);
-  const end = source.indexOf(endNeedle, start + startNeedle.length);
-  assert.notEqual(end, -1, `missing source end: ${endNeedle}`);
-  return source.slice(start, end);
-}
-
-function assertBundleContract(source) {
-  assert.match(source, /response_format: object\(\{/u, 'Agent input must expose response_format');
-  assert.match(
-    source,
-    /prepareStructuredResponseFormat\(args\.response_format, compileToolArgsValidator\)/u,
-    'response_format must reuse BLUN AJV compilation',
-  );
-  const preparationIndex = source.indexOf('prepareStructuredResponseFormat(args.response_format, compileToolArgsValidator)');
-  const launchIndex = source.indexOf('await this.subagentHost.spawn({', preparationIndex);
-  assert.ok(preparationIndex >= 0 && launchIndex > preparationIndex, 'schema compilation must precede child creation');
-  assert.match(source, /response_format is supported for foreground Agent runs only/u, 'structured background runs must be rejected');
-  assert.match(
-    source,
-    /const runInBackground = responseFormat === void 0 \? resolvedRunMode\.runInBackground : false/u,
-    'structured output must select a foreground run',
-  );
-  assert.match(
-    source,
-    /appendSystemReminder\(buildStructuredResponseFormatReminder\(options\.responseFormat\)/u,
-    'the schema reminder must remain child-local',
-  );
-  assert.match(
-    source,
-    /completeStructuredSubagentResult\(child, childId, profileName, options\.responseFormat, options\.signal\)/u,
-    'structured completion must validate before returning',
-  );
-  assert.match(
-    source,
-    /buildStructuredResponseRepairPrompt\(responseFormat, validation\.error\)[\s\S]{0,500}completeChildTurnWithMaxTokensHandoff\(child, signal\)/u,
-    'one repair turn must use the normal child completion path',
-  );
-  assert.match(
-    source,
-    /signal\.throwIfAborted\(\);[\s\S]{0,180}buildStructuredResponseRepairPrompt/u,
-    'cancellation must be checked before repair',
-  );
-  assert.match(source, /responseFormat: this\.responseFormat/u, 'timeout continuation must preserve the response format');
-  assert.match(
-    source,
-    /responseFormat === void 0 \? formatForegroundAgentSuccess\(handle, output\) : output/u,
-    'validated structured output must not be wrapped in free-form text',
-  );
-  assert.match(
-    source,
-    /message\.includes\(STRUCTURED_SUBAGENT_OUTPUT_ERROR\)/u,
-    'a second invalid response must preserve the resume hint',
-  );
-  const swarmRegion = extractBetween(
-    source,
-    '//#region ../../packages/agent-core/src/tools/builtin/collaboration/agent-swarm.ts',
-    '//#region ../../packages/agent-core/src/tools/builtin/collaboration/ask-user.md?raw',
-  );
-  assert.doesNotMatch(swarmRegion, /response_format/u, 'AgentSwarm must not silently accept response_format');
-}
-
-function buildAgentToolClass(source) {
-  const assignment = extractBetween(source, 'AgentTool = class {', '\n\t};\n\tUSER_INTERRUPTED_SUBAGENT_MESSAGE');
-  const classSource = `${assignment.slice('AgentTool = '.length)}\n\t}`;
-  return Function(
-    'AgentToolInputSchema',
-    'toInputJsonSchema',
-    'buildSubagentDescriptions',
-    'agent_default',
-    'agent_background_enabled_default',
-    'agent_background_disabled_default',
-    'resolveSubagentRunMode',
-    'ToolAccesses',
-    'matchesGlobRuleSubject',
-    'prepareStructuredResponseFormat',
-    'compileToolArgsValidator',
-    'BACKGROUND_AGENT_UNAVAILABLE',
-    'formatForegroundAgentSuccess',
-    'formatForegroundAgentFailure',
-    'USER_INTERRUPTED_SUBAGENT_MESSAGE',
-    'launchErrorMessage',
-    `"use strict"; return (${classSource});`,
-  )(
-    {},
-    () => ({}),
-    () => '',
-    'agent',
-    'background enabled',
-    'background disabled',
-    ({ allowBackground }) => ({ runInBackground: allowBackground === true }),
-    { none: () => ({}) },
-    () => true,
-    require('../bin/structured-subagent-output.cjs').prepareStructuredResponseFormat,
-    () => () => true,
-    'background unavailable',
-    (handle, result) => [
-      `agent_id: ${handle.agentId}`,
-      `actual_subagent_type: ${handle.profileName}`,
-      'status: completed',
-      '',
-      '[summary]',
-      result,
-    ].join('\n'),
-    () => 'failed',
-    'interrupted',
-    (error) => String(error),
-  );
-}
-
-async function exerciseBundledAgentTool(source) {
-  const AgentTool = buildAgentToolClass(source);
-  const backgroundManager = {
-    getTask: () => ({ status: 'completed' }),
-    readOutput: async () => 'free text',
-  };
-  const tool = new AgentTool({}, backgroundManager, {}, { allowBackground: true });
-  const unstructured = await tool.resolveExecution({ prompt: 'x', description: 'free' });
-  assert.equal(unstructured.display.background, true);
-  const structuredArgs = {
-    prompt: 'x',
-    description: 'structured',
-    response_format: { name: 'answer', schema: { type: 'object' } },
-  };
-  const structured = await tool.resolveExecution(structuredArgs);
-  assert.equal(structured.display.background, false);
-
-  const handle = { agentId: 'agent-1', profileName: 'coder' };
-  assert.equal(
-    (await tool.formatForegroundResult('task-1', handle, undefined)).output,
-    'agent_id: agent-1\nactual_subagent_type: coder\nstatus: completed\n\n[summary]\nfree text',
-    'free-form output must remain byte-compatible',
-  );
-  backgroundManager.readOutput = async () => '{"status":"completed"}';
-  assert.equal(
-    (await tool.formatForegroundResult('task-2', handle, {})).output,
-    '{"status":"completed"}',
-    'structured output must remain canonical JSON without a text wrapper',
-  );
-
-  let spawned = false;
-  tool.subagentHost = { spawn: async () => { spawned = true; throw new Error('must not spawn'); } };
-  const invalid = await tool.execution({
-    ...structuredArgs,
-    response_format: { name: 'answer', schema: { type: 'array' } },
-  }, { toolCallId: 'call-1', signal: new AbortController().signal });
-  assert.equal(invalid.isError, true);
-  assert.match(invalid.output, /Invalid response_format/u);
-  assert.equal(spawned, false, 'invalid schema must fail before child creation');
-
-  const background = await tool.execution({ ...structuredArgs, run_in_background: true }, {
-    toolCallId: 'call-2',
-    signal: new AbortController().signal,
-  });
-  assert.equal(background.isError, true);
-  assert.match(background.output, /foreground Agent runs only/u);
-  assert.equal(spawned, false);
-}
-
-async function exerciseBundledRepairFlow(source) {
-  const functionSource = extractBetween(
-    source,
-    'async function completeStructuredSubagentResult(',
-    'function shouldSuppressQueuedAttemptFailureEvent(',
-  );
-  const runtime = require('../bin/structured-subagent-output.cjs');
-  let currentText = '';
-  let completionCalls = 0;
-  const completeStructuredSubagentResult = Function(
-    'validateStructuredSubagentOutput',
-    'buildStructuredResponseRepairPrompt',
-    'SUBAGENT_PROMPT_ORIGIN',
-    'completeChildTurnWithMaxTokensHandoff',
-    'lastAssistantText',
-    'STRUCTURED_SUBAGENT_OUTPUT_ERROR',
-    `"use strict"; ${functionSource}; return completeStructuredSubagentResult;`,
-  )(
-    runtime.validateStructuredSubagentOutput,
-    runtime.buildStructuredResponseRepairPrompt,
-    { kind: 'system_trigger', name: 'subagent' },
-    async () => { completionCalls += 1; },
-    () => currentText,
-    runtime.STRUCTURED_SUBAGENT_OUTPUT_ERROR,
-  );
-
-  const prepared = runtime.prepareStructuredResponseFormat({
-    name: 'answer',
-    schema: {
-      type: 'object',
-      properties: { value: { type: 'string' } },
-      required: ['value'],
-      additionalProperties: false,
-    },
-  }, () => {
-    const validator = (value) => {
-      const ok = value !== null && typeof value === 'object' && !Array.isArray(value)
-        && typeof value.value === 'string' && Object.keys(value).length === 1;
-      validator.errors = ok ? [] : [{ keyword: 'required', instancePath: '', params: { missingProperty: 'value' } }];
-      return ok;
-    };
-    return validator;
-  });
-
-  const prompts = [];
-  const child = { turn: { prompt: (parts) => {
-    prompts.push(parts[0].text);
-    currentText = '{"value":"repaired"}';
-    return 'turn-2';
-  } } };
-  currentText = '{"wrong":true}';
-  const repaired = await completeStructuredSubagentResult(
-    child,
-    'agent-2',
-    'coder',
-    prepared,
-    new AbortController().signal,
-  );
-  assert.deepEqual(repaired, { value: 'repaired' });
-  assert.equal(prompts.length, 1);
-  assert.equal(completionCalls, 1);
-
-  currentText = '{"wrong":true}';
-  child.turn.prompt = (parts) => {
-    prompts.push(parts[0].text);
-    currentText = '{"still_wrong":true}';
-    return 'turn-3';
-  };
-  await assert.rejects(
-    completeStructuredSubagentResult(child, 'agent-3', 'coder', prepared, new AbortController().signal),
-    /Structured subagent output invalid after one repair attempt[\s\S]*Resume with Agent/u,
-  );
-
-  const controller = new AbortController();
-  controller.abort(new Error('cancelled'));
-  currentText = '{"wrong":true}';
-  const promptCountBeforeCancel = prompts.length;
-  await assert.rejects(
-    completeStructuredSubagentResult(child, 'agent-4', 'coder', prepared, controller.signal),
-    /cancelled/u,
-  );
-  assert.equal(prompts.length, promptCountBeforeCancel, 'cancellation must prevent the repair turn');
-}
-
-function exerciseBundledStructuredFailure(source) {
-  const functionSource = extractBetween(
-    source,
-    'function formatForegroundAgentFailure(',
-    'function launchErrorMessage(',
-  );
-  const runtime = require('../bin/structured-subagent-output.cjs');
-  const formatForegroundAgentFailure = Function(
-    'SUBAGENT_MAX_TOKENS_ERROR',
-    'STRUCTURED_SUBAGENT_OUTPUT_ERROR',
-    `"use strict"; ${functionSource}; return formatForegroundAgentFailure;`,
-  )('SUBAGENT_MAX_TOKENS', runtime.STRUCTURED_SUBAGENT_OUTPUT_ERROR);
-  const output = formatForegroundAgentFailure(
-    { agentId: 'agent-failed', profileName: 'coder' },
-    `${runtime.STRUCTURED_SUBAGENT_OUTPUT_ERROR}: missing value`,
-    false,
-  );
-  assert.match(output, /agent_id: agent-failed/u);
-  assert.match(output, /actual_subagent_type: coder/u);
-  assert.match(output, /missing value/u);
-  assert.match(output, /resume_hint: Continue with Agent\(resume="agent-failed"/u);
-}
-
-async function main() {
-  const suite = spawnSync(process.execPath, ['--test', join(__dirname, 'structured-subagent-output.test.cjs')], {
-    stdio: 'inherit',
-  });
-  assert.equal(suite.status, 0, 'structured subagent helper tests must pass');
-  const source = readFileSync(bundlePath, 'utf8');
-  assertBundleContract(source);
-  await exerciseBundledAgentTool(source);
-  await exerciseBundledRepairFlow(source);
-  exerciseBundledStructuredFailure(source);
-
-  assert.throws(
-    () => assertBundleContract(source.replace(
-      'prepareStructuredResponseFormat(args.response_format, compileToolArgsValidator)',
-      'prepareStructuredResponseFormat(args.response_format, () => () => true)',
-    )),
-    /reuse BLUN AJV/u,
-  );
-  assert.throws(
-    () => assertBundleContract(source.replace(
-      'const runInBackground = responseFormat === void 0 ? resolvedRunMode.runInBackground : false',
-      'const runInBackground = resolvedRunMode.runInBackground',
-    )),
-    /foreground run/u,
-  );
-  assert.throws(
-    () => {
-      const region = extractBetween(
-        source,
-        'async function completeStructuredSubagentResult(',
-        'function shouldSuppressQueuedAttemptFailureEvent(',
-      );
-      const mutatedRegion = region.replace(
-        /\t\tsignal\.throwIfAborted\(\);\r?\n(?=\t\tif \(child\.turn\.prompt)/u,
-        '',
-      );
-      assertBundleContract(source.replace(region, mutatedRegion));
-    },
-    /cancellation/u,
-  );
-  assert.throws(
-    () => assertBundleContract(source.replace(
-      'responseFormat === void 0 ? formatForegroundAgentSuccess(handle, output) : output',
-      'formatForegroundAgentSuccess(handle, output)',
-    )),
-    /free-form text/u,
-  );
-  process.stdout.write('structured subagent output regression: ok\n');
-}
-
-main().catch((error) => {
-  console.error(error.stack || error);
-  process.exitCode = 1;
-});

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-direct-work-resume-regression.js

@@ -1,53 +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 packageRoot = path.resolve(process.env.BLUN_PACKAGE_ROOT || path.join(__dirname, '..'));
-const {
-  createDirectReplyTurnStop,
-  directMessageAllowsWorkContinuation,
-  directMessageStartsOrResumesWork,
-  directTelegramPayloadText,
-} = require(path.join(packageRoot, 'bin', 'telegram-direct-focus-policy.cjs'));
-
-const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
-const direct = (payload) => [
-  'A private Telegram DM has priority over background, group, and loop work.',
-  '<channel priority="direct" source="telegram" chat_id="1605241602">',
-  payload,
-  '</channel>',
-].join('\n');
-
-const status = direct('Wie weit bist du?');
-assert.equal(directTelegramPayloadText(status), 'Wie weit bist du?');
-assert.equal(directMessageAllowsWorkContinuation(status), true);
-assert.equal(directMessageStartsOrResumesWork(status), false);
-const statusStop = createDirectReplyTurnStop(status);
-assert.equal(statusStop.noteToolResult('mcp__plugin-telegram_telegram__reply', false), true);
-assert.equal(statusStop.shouldStop(), true, 'standalone DM chat should stop after its reply');
-
-for (const payload of [
-  'Auftrag: Lies die SPEC und baue die Datei.',
-  'Feuer frei',
-  'Bitte weiterarbeiten und danach melden.',
-]) {
-  const input = direct(payload);
-  assert.equal(directMessageAllowsWorkContinuation(input), true, payload);
-  assert.equal(directMessageStartsOrResumesWork(input), true, payload);
-  const stop = createDirectReplyTurnStop(input);
-  stop.noteToolResult('mcp__plugin-telegram_telegram__reply', false);
-  assert.equal(stop.shouldStop(), false, `work DM must continue after reply: ${payload}`);
-}
-
-const pause = direct('Bitte stop, warte auf mein Zeichen.');
-assert.equal(directMessageAllowsWorkContinuation(pause), false);
-assert.equal(directMessageStartsOrResumesWork(pause), false);
-
-assert.match(bundle, /let directSteerContinuationPending = false;/u);
-assert.match(bundle, /pendingSteers\.some\(\(steer\) => directMessageAllowsWorkContinuation/u);
-assert.match(bundle, /name: "telegram_direct_work_resume"/u);
-assert.match(bundle, /perform the next unfinished action now\./u);
-
-console.log('telegram-direct-work-resume-regression PASS');