blun-king-cli 9.1.527 → 9.1.550

package/agent-spine-plugin/scripts/release-check.js

@@ -1,128 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-const REQUIRED_PACKAGE_FILES = [
-  "blun.plugin.json", ".claude-plugin/plugin.json", ".codex-plugin/plugin.json", ".mcp.json",
-  "CHANGELOG.md", "LICENSE", "README.md", "bin/agentspine.js", "bin/agentspine-mcp.js",
-  "docs/acceptance.md", "docs/source-roots.md", "docs/preflight-recall.md", "docs/preservation-contract.md", "scripts/run-acceptance.js",
-  "skills/agent-spine/SKILL.md", "src/index.js", "src/mcp.js", "src/worker.js",
-  "hooks/hooks.json", "hooks/codex.json", "hooks/version.json"
-];
-const FORBIDDEN_PACKAGE_PATHS = [
-  /(?:^|\/)\.env(?:\.|$)/i,
-  /(?:^|\/)\.git(?:$|\/)/i,
-  /(?:^|\/)\.agentspine(?:$|\/)/i,
-  /(?:^|\/)(?:AGENTS|CLAUDE|SOUL|MEMORY)\.md$/i,
-  /(?:^|\/)(?:test|\.github)(?:$|\/)/,
-  /\.(?:key|pem|p12|pfx)$/i,
-  /(?:^|\/)state\.json$/i,
-  /(?:^|\/)(?:catalog|graph|attention|learning|coordination|sharing|sharing-trust|delegation-policy)\.json$/
-];
-
-function parse(argv) {
-  const options = { root: process.cwd(), tag: null, allowDirty: false, skipPack: false, json: false };
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (token === "--root") options.root = argv[++index];
-    else if (token === "--tag") options.tag = argv[++index];
-    else if (token === "--allow-dirty") options.allowDirty = true;
-    else if (token === "--skip-pack") options.skipPack = true;
-    else if (token === "--json") options.json = true;
-    else throw new Error(`unknown release-check argument: ${token}`);
-  }
-  options.root = resolve(options.root);
-  return options;
-}
-
-async function json(root, path) {
-  return JSON.parse(await readFile(resolve(root, path), "utf8"));
-}
-
-function command(root, args) {
-  const npmCli = process.env.npm_execpath;
-  const executable = npmCli ? process.execPath : (process.platform === "win32" ? "npm.cmd" : "npm");
-  const commandArgs = npmCli ? [npmCli, ...args] : args;
-  return spawnSync(executable, commandArgs, { cwd: root, encoding: "utf8" });
-}
-
-function git(root, args) {
-  return spawnSync("git", args, { cwd: root, encoding: "utf8" });
-}
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-function validatePackageReport(report, version) {
-  assert(Array.isArray(report) && report.length === 1, "npm pack report must describe exactly one package");
-  const item = report[0];
-  assert(item.version === version, "npm pack version does not match package.json");
-  assert(typeof item.filename === "string" && item.filename.endsWith(`-${version}.tgz`), "npm pack filename is not versioned correctly");
-  assert(typeof item.integrity === "string" && item.integrity.startsWith("sha512-"), "npm pack did not report SHA-512 integrity");
-  assert(Number.isInteger(item.entryCount) && item.entryCount > 0 && item.entryCount <= 500, "npm package file count is outside the release limit");
-  assert(Number.isInteger(item.unpackedSize) && item.unpackedSize > 0 && item.unpackedSize <= 2 * 1024 * 1024, "npm package exceeds the 2 MiB unpacked release limit");
-  const paths = (item.files || []).map((file) => file.path);
-  assert(paths.length === new Set(paths).size, "npm package contains duplicate paths");
-  for (const path of REQUIRED_PACKAGE_FILES) assert(paths.includes(path), `npm package is missing required file: ${path}`);
-  for (const path of paths) {
-    assert(path && !path.startsWith("/") && !path.split("/").includes(".."), `npm package contains an unsafe path: ${path}`);
-    assert(!FORBIDDEN_PACKAGE_PATHS.some((pattern) => pattern.test(path)), `npm package contains forbidden state or source material: ${path}`);
-  }
-  return { filename: item.filename, integrity: item.integrity, files: paths.length, unpackedSize: item.unpackedSize };
-}
-
-export async function releaseCheck(options) {
-  const [pkg, lock, blun, claude, codex, marketplace, hookVersion, changelog] = await Promise.all([
-    json(options.root, "package.json"), json(options.root, "package-lock.json"),
-    json(options.root, "blun.plugin.json"),
-    json(options.root, ".claude-plugin/plugin.json"), json(options.root, ".codex-plugin/plugin.json"),
-    json(options.root, ".claude-plugin/marketplace.json"), json(options.root, "hooks/version.json"),
-    readFile(resolve(options.root, "CHANGELOG.md"), "utf8")
-  ]);
-  assert(SEMVER_RE.test(pkg.version || ""), "package version is not valid SemVer");
-  const versions = [lock.version, lock.packages?.[""]?.version, blun.version, claude.version, codex.version, marketplace.plugins?.[0]?.version, hookVersion.version];
-  assert(versions.every((version) => version === pkg.version), "release version differs across package and host manifests");
-  assert(pkg.name === lock.name && pkg.name === lock.packages?.[""]?.name, "package name differs from package-lock.json");
-  assert(pkg.repository?.url === "git+https://github.com/Maykbiletti/AgentSpine.git", "package repository must identify the public source repository exactly");
-  if (options.tag) {
-    assert(options.tag === `v${pkg.version}`, `release tag must be v${pkg.version}`);
-    const escaped = pkg.version.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    assert(new RegExp(`^## \\[${escaped}\\] - \\d{4}-\\d{2}-\\d{2}$`, "m").test(changelog), `CHANGELOG.md needs a dated ${pkg.version} section`);
-  }
-  if (!options.allowDirty) {
-    const status = git(options.root, ["status", "--porcelain"]);
-    assert(status.status === 0, status.stderr || "git status failed");
-    assert(status.stdout.trim() === "", "release worktree must be clean");
-  }
-  let packageReport = null;
-  if (!options.skipPack) {
-    const packed = command(options.root, ["pack", "--dry-run", "--ignore-scripts", "--json"]);
-    assert(packed.status === 0, packed.stderr || "npm pack --dry-run failed");
-    packageReport = validatePackageReport(JSON.parse(packed.stdout), pkg.version);
-  }
-  return {
-    ok: true,
-    version: pkg.version,
-    tag: options.tag,
-    cleanRequired: !options.allowDirty,
-    package: packageReport,
-    authority: "release-metadata-only"
-  };
-}
-
-async function main() {
-  const options = parse(process.argv.slice(2));
-  const result = await releaseCheck(options);
-  process.stdout.write(`${JSON.stringify(result, null, options.json ? 2 : 0)}\n`);
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
-  main().catch((error) => {
-    process.stderr.write(`AgentSpine release check failed: ${error.message}\n`);
-    process.exitCode = 1;
-  });
-}

package/agent-spine-plugin/scripts/run-acceptance.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { renderAcceptanceReport, runVisibleAcceptance } from "../src/lib/acceptance.js";
-
-export async function main(argv = process.argv.slice(2)) {
-  const unknown = argv.filter((item) => item !== "--json");
-  if (unknown.length) throw new Error(`unknown acceptance argument: ${unknown[0]}`);
-  const report = await runVisibleAcceptance();
-  process.stdout.write(argv.includes("--json") ? `${JSON.stringify(report, null, 2)}\n` : renderAcceptanceReport(report));
-  return report;
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
-  main().catch((error) => {
-    process.stderr.write(`AgentSpine acceptance failed: ${error.message}\n`);
-    process.exitCode = 1;
-  });
-}

package/agent-spine-plugin/scripts/run-checks.js

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { githubErrorCommand } from "./github-actions.js";
-
-const CHECKS = [
-  { title: "Syntax check", script: "lint" },
-  { title: "Hermetic test suite", script: "test" },
-  { title: "Host manifest check", script: "host:check" },
-  { title: "Installed bundle check", script: "host:install-check" },
-  { title: "Runtime smoke test", script: "smoke" },
-  { title: "Self audit", script: "audit:self" }
-];
-
-function runNpmScript(script) {
-  const npmExecPath = process.env.npm_execpath;
-  const executable = npmExecPath ? process.execPath : (process.platform === "win32" ? "npm.cmd" : "npm");
-  const args = npmExecPath ? [npmExecPath, "run", script] : ["run", script];
-  return new Promise((resolve, reject) => {
-    const child = spawn(executable, args, { stdio: "inherit", shell: false, windowsHide: true });
-    child.once("error", reject);
-    child.once("close", (code) => resolve(code ?? 1));
-  });
-}
-
-export async function runChecks({
-  checks = CHECKS, runCommand = runNpmScript, githubActions = process.env.GITHUB_ACTIONS === "true", output = process.stderr
-} = {}) {
-  for (const check of checks) {
-    let code;
-    try { code = await runCommand(check.script); }
-    catch (error) {
-      if (githubActions) output.write(githubErrorCommand(check.title, error.message) + "\n");
-      else output.write(`${check.title} failed: ${error.message}\n`);
-      return 1;
-    }
-    if (code !== 0) {
-      if (githubActions) output.write(githubErrorCommand(check.title, `npm run ${check.script} exited with code ${code}`) + "\n");
-      return code;
-    }
-  }
-  return 0;
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) process.exitCode = await runChecks();

package/agent-spine-plugin/scripts/run-tests-hermetic.js

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { cpus, tmpdir } from "node:os";
-import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { githubErrorCommand } from "./github-actions.js";
-
-const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
-const base = await mkdtemp(join(tmpdir(), "agentspine-hermetic-tests-"));
-const testFiles = (await readdir(join(root, "test"))).filter((name) => name.endsWith(".test.js")).sort();
-const concurrency = Math.max(1, Math.min(4, cpus().length));
-
-async function profileEnvironment(mode, index) {
-  const profile = join(base, mode, String(index));
-  const home = join(profile, "home"); const claude = join(profile, "claude"); const codex = join(profile, "codex");
-  const state = join(profile, "state"); const xdgState = join(profile, "xdg-state"); const temporary = join(profile, "tmp");
-  for (const directory of [home, claude, codex, state, xdgState, temporary]) await mkdir(directory, { recursive: true });
-  if (mode === "populated") {
-    await writeFile(join(claude, "CLAUDE.md"), "# Hermetic populated Claude profile\n\nSynthetic global source.\n");
-    await writeFile(join(codex, "AGENTS.md"), "# Hermetic populated Codex profile\n\nSynthetic global source.\n");
-  }
-  const inherited = Object.fromEntries(Object.entries(process.env).filter(([key]) =>
-    !/^(?:AGENTSPINE_|CLAUDE_|CODEX_|HOME$|USERPROFILE$|XDG_STATE_HOME$|TMPDIR$|TMP$|TEMP$|NODE_OPTIONS$|NODE_PATH$)/.test(key)));
-  return { ...inherited, HOME: home, USERPROFILE: home, CLAUDE_CONFIG_DIR: claude, CODEX_HOME: codex,
-    AGENTSPINE_STATE_DIR: state, XDG_STATE_HOME: xdgState, TMPDIR: temporary, TMP: temporary, TEMP: temporary,
-    AGENTSPINE_HERMETIC_ROOT: profile, AGENTSPINE_TEST_PROFILE: mode };
-}
-
-async function runOne(file, mode, index) {
-  const env = await profileEnvironment(mode, index);
-  return new Promise((resolvePromise) => {
-    const child = spawn(process.execPath, ["--test", join(root, "test", file)], { cwd: root, env, shell: false,
-      stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
-    let stdout = ""; let stderr = "";
-    child.stdout.on("data", (chunk) => { stdout += chunk; }); child.stderr.on("data", (chunk) => { stderr += chunk; });
-    child.on("close", (code) => resolvePromise({ file, mode, code, stdout, stderr }));
-    child.on("error", (error) => resolvePromise({ file, mode, code: 1, stdout, stderr: error.message }));
-  });
-}
-
-async function runMode(mode) {
-  const queue = testFiles.map((file, index) => ({ file, index })); const results = [];
-  async function worker() { while (queue.length) { const item = queue.shift(); results.push(await runOne(item.file, mode, item.index)); } }
-  await Promise.all(Array.from({ length: concurrency }, () => worker()));
-  for (const result of results.sort((a, b) => a.file.localeCompare(b.file))) {
-    if (result.code !== 0) {
-      if (process.env.GITHUB_ACTIONS === "true") {
-        process.stderr.write(githubErrorCommand(`${mode}: ${result.file}`, result.stdout + result.stderr) + "\n");
-      }
-      process.stderr.write("\n[" + mode + "] " + result.file + " failed\n" + result.stdout + result.stderr);
-    }
-  }
-  return results;
-}
-
-let failed = false; let runnerError = null;
-try {
-  for (const mode of ["empty", "populated"]) {
-    const results = await runMode(mode); const failures = results.filter((item) => item.code !== 0);
-    process.stdout.write("Hermetic " + mode + " profile: " + (results.length - failures.length) + "/" + results.length + " test files passed\n");
-    if (failures.length) failed = true;
-  }
-} catch (error) { runnerError = error; }
-try { await rm(base, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); }
-catch (error) { runnerError = runnerError ? new AggregateError([runnerError, error], "Hermetic test run and cleanup failed") : error; }
-if (runnerError) {
-  if (process.env.GITHUB_ACTIONS === "true") {
-    process.stderr.write(githubErrorCommand("Hermetic test runner", runnerError.stack || runnerError.message) + "\n");
-  }
-  throw runnerError;
-}
-if (failed) process.exitCode = 1;

package/agent-spine-plugin/spine-example/1-identity.md

@@ -1,12 +0,0 @@
-# Layer 1 — Identity
-
-I am <AgentName>, the <role> of <Owner>. <Owner> is my owner; their word is
-final.
-
-My purpose: <one sentence — what this agent exists to do>.
-
-Principles that no later layer may override:
-
-- I am honest before I am impressive. "Not verified yet" beats a wrong "done".
-- I claim only what a real result has shown me.
-- What my owner teaches me about myself becomes part of me (layer 4).

package/agent-spine-plugin/spine-example/2-voice.md

@@ -1,6 +0,0 @@
-# Layer 2 — Voice
-
-- Language: <language the owner prefers>.
-- Tone: warm, direct, like a colleague — not a manual, not a servant.
-- Length: short by default; detail only on request.
-- Never: invented certainty, filler praise, jargon the owner did not use.

package/agent-spine-plugin/spine-example/3-conduct.md

@@ -1,8 +0,0 @@
-# Layer 3 — Conduct
-
-- Measure before acting; re-measure before reporting.
-- A claim carries its evidence: the command, the number, the file.
-- Errors are reported at once, with what I did and what I will do.
-- Escalate to the owner only for decisions that are truly theirs;
-  everything reversible I do myself.
-- Tasks, credentials and permissions do not live in this spine.

package/agent-spine-plugin/spine-example/4-history.md

@@ -1,4 +0,0 @@
-# Layer 4 — Grown history (append-only)
-
-## 2026-08-27
-Spine created.

package/bin/package-regression-policy.cjs

@@ -1,77 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const zlib = require('node:zlib');
-
-function tarText(buffer, start, length) {
-  return buffer.subarray(start, start + length).toString('utf8').replace(/\0.*$/s, '').trim();
-}
-
-function listTarGzPaths(tarballPath) {
-  const archive = zlib.gunzipSync(fs.readFileSync(tarballPath));
-  const paths = [];
-  let offset = 0;
-  while (offset + 512 <= archive.length) {
-    const header = archive.subarray(offset, offset + 512);
-    if (header.every((byte) => byte === 0)) break;
-    const name = tarText(header, 0, 100);
-    const prefix = tarText(header, 345, 155);
-    const sizeText = tarText(header, 124, 12);
-    const size = sizeText ? Number.parseInt(sizeText, 8) : 0;
-    if (!Number.isFinite(size)) throw new Error(`Ungueltige TAR-Groesse bei ${name || '[ohne Namen]'}`);
-    const fullName = [prefix, name].filter(Boolean).join('/').replaceAll('\\', '/');
-    if (fullName) paths.push(fullName);
-    offset += 512 + Math.ceil(size / 512) * 512;
-  }
-  return paths;
-}
-
-function isStablePackagePath(filePath) {
-  const normalized = String(filePath || '').replaceAll('\\', '/');
-  if (!normalized || normalized.endsWith('/')) return false;
-  if (normalized.startsWith('package/dist-web/assets/')) return false;
-  if (normalized.startsWith('package/dist-web/vis/')) return false;
-  return normalized.startsWith('package/');
-}
-
-function validatePlannedRemovals(document) {
-  const removals = Array.isArray(document?.removals) ? document.removals : [];
-  for (const removal of removals) {
-    if (!isStablePackagePath(removal?.path)) throw new Error(`Ungueltiger Entfernungspfad: ${removal?.path || '[leer]'}`);
-    if (!String(removal?.reason || '').trim()) throw new Error(`Entfernungsgrund fehlt: ${removal.path}`);
-    if (!String(removal?.decisionRef || '').trim()) throw new Error(`Entscheidungsreferenz fehlt: ${removal.path}`);
-  }
-  return new Set(removals.map((removal) => removal.path.replaceAll('\\', '/')));
-}
-
-function findUnexpectedRemovals(previousPaths, currentPaths, plannedDocument = { removals: [] }) {
-  const current = new Set(currentPaths.map((entry) => String(entry).replaceAll('\\', '/')));
-  const planned = validatePlannedRemovals(plannedDocument);
-  return [...new Set(previousPaths
-    .map((entry) => String(entry).replaceAll('\\', '/'))
-    .filter(isStablePackagePath)
-    .filter((entry) => !current.has(entry) && !planned.has(entry)))]
-    .sort();
-}
-
-function comparePackagePaths(previousPaths, currentPaths, plannedDocument = { removals: [] }) {
-  const previousStablePaths = [...new Set(previousPaths
-    .map((entry) => String(entry).replaceAll('\\', '/'))
-    .filter(isStablePackagePath))];
-  const currentStablePaths = [...new Set(currentPaths
-    .map((entry) => String(entry).replaceAll('\\', '/'))
-    .filter(isStablePackagePath))];
-  return {
-    checkedStablePaths: previousStablePaths.length,
-    currentStablePaths: currentStablePaths.length,
-    unexpectedRemovals: findUnexpectedRemovals(previousStablePaths, currentStablePaths, plannedDocument),
-  };
-}
-
-module.exports = {
-  comparePackagePaths,
-  findUnexpectedRemovals,
-  isStablePackagePath,
-  listTarGzPaths,
-  validatePlannedRemovals,
-};

package/release-planned-removals.json

@@ -1,15 +0,0 @@
-{
-  "version": "9.1.393",
-  "removals": [
-    {
-      "path": "package/bin/running-update.cjs",
-      "reason": "Background updater removed by owner decision; the visible manual startup picker remains.",
-      "decisionRef": "Telegram DM 5597, 5603, 5610, 5614 and 5619, 2026-08-28"
-    },
-    {
-      "path": "package/bin/running-update-preference.cjs",
-      "reason": "Background updater preference removed with the background updater; manual startup choices remain.",
-      "decisionRef": "Telegram DM 5597, 5603, 5610, 5614 and 5619, 2026-08-28"
-    }
-  ]
-}

package/scripts/check-active-profile-plugin-startup.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const { installAgentSpineForExistingProfiles } = require('../bin/launcher-runtime');
-
-const packageRoot = path.resolve(__dirname, '..');
-const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-active-profile-plugin-'));
-const sharedHome = path.join(temporaryRoot, '.blun');
-const currentProfile = path.join(sharedHome, 'profile', 'current');
-const dormantProfile = path.join(sharedHome, 'profile', 'dormant');
-
-try {
-  fs.mkdirSync(currentProfile, { recursive: true });
-  fs.mkdirSync(dormantProfile, { recursive: true });
-
-  installAgentSpineForExistingProfiles(packageRoot, sharedHome, currentProfile);
-
-  assert.equal(
-    fs.existsSync(path.join(currentProfile, 'plugins', 'installed.json')),
-    true,
-    'the active profile must receive the managed AgentSpine plugin',
-  );
-  assert.equal(
-    fs.existsSync(path.join(dormantProfile, 'plugins', 'installed.json')),
-    false,
-    'startup must not rescan or mutate dormant profiles',
-  );
-
-  process.stdout.write('active profile plugin startup regression: PASS\n');
-} finally {
-  fs.rmSync(temporaryRoot, { recursive: true, force: true });
-}

package/scripts/check-approval-observability-regression.js

@@ -1,111 +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(__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-approval-queue-shortcuts-regression.js

@@ -1,65 +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.join(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-function between(start, end, from = 0) {
-  const startIndex = bundle.indexOf(start, from);
-  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);
-}
-
-const panelStart = bundle.indexOf('var ApprovalPanelComponent = class extends Container {');
-assert.notEqual(panelStart, -1, 'ApprovalPanelComponent must exist');
-const handleSource = between('\n\thandleInput(data) {', '\n\trender(width) {', panelStart).trim();
-
-const Key = {
-  escape: 'escape',
-  ctrl(key) { return `ctrl+${key}`; },
-};
-const matchesKey = (data, expected) => {
-  if (expected === 'escape') return data === '\x1b';
-  if (expected === 'ctrl+s') return data === '\x13';
-  return data === expected;
-};
-const handleInput = Function(
-  'matchesKey',
-  'Key',
-  `"use strict"; return ({${handleSource}}).handleInput;`,
-)(matchesKey, Key);
-
-let responses = 0;
-let flushed = 0;
-let released = 0;
-const panel = {
-  choiceCount() { return 0; },
-  onResponse(response) {
-    responses += 1;
-    assert.equal(response.response, 'rejected');
-  },
-  onCtrlS() { flushed += 1; },
-  onEscape() { released += 1; return true; },
-};
-
-handleInput.call(panel, '\x13');
-assert.equal(flushed, 1, 'Ctrl+S must reach the global queue flush while approval is open');
-assert.equal(responses, 0);
-
-handleInput.call(panel, '\x1b');
-assert.equal(released, 1, 'Escape must first release one queued message while approval is open');
-assert.equal(responses, 0, 'a released queued message must not reject the approval');
-
-panel.onEscape = () => false;
-handleInput.call(panel, '\x1b');
-assert.equal(responses, 1, 'Escape must reject the approval when no queued message waits');
-
-const showApprovalPanel = between('\n\tshowApprovalPanel(payload) {', '\n\thideApprovalPanel() {');
-assert.match(showApprovalPanel, /this\.flushQueuedMessages\(this\.state\.editor\.getText\(\)\.trim\(\), this\.state\.editor\.inputMode\)/);
-assert.match(showApprovalPanel, /return this\.releaseNextQueuedMessage\(\)/);
-
-console.log('approval queue shortcuts regression: PASS');

package/scripts/check-bundled-agent-spine-regression.js

@@ -1,48 +0,0 @@
-const assert = require('node:assert/strict');
-const { execFileSync } = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const expectedVersion = '0.11.4';
-const pluginRoot = process.env.BLUN_AGENT_SPINE_ROOT_UNDER_TEST
-  ? path.resolve(process.env.BLUN_AGENT_SPINE_ROOT_UNDER_TEST)
-  : path.resolve(__dirname, '..', 'agent-spine-plugin');
-
-function readJson(relativePath) {
-  return JSON.parse(fs.readFileSync(path.join(pluginRoot, relativePath), 'utf8'));
-}
-
-for (const relativePath of [
-  'package.json',
-  'hooks/version.json',
-  '.claude-plugin/plugin.json',
-  '.codex-plugin/plugin.json',
-  'blun.plugin.json',
-]) {
-  assert.equal(
-    readJson(relativePath).version,
-    expectedVersion,
-    `BUNDLED_AGENT_SPINE_REGRESSION: ${relativePath} must declare ${expectedVersion}`,
-  );
-}
-
-const runtimeVersion = execFileSync(
-  process.execPath,
-  [path.join(pluginRoot, 'bin', 'agentspine.js'), '--version'],
-  { encoding: 'utf8' },
-).trim();
-assert.equal(
-  runtimeVersion,
-  expectedVersion,
-  'BUNDLED_AGENT_SPINE_REGRESSION: packaged runtime version is stale',
-);
-
-for (const relativePath of ['CONTRIBUTING.md', 'SECURITY.md']) {
-  assert.equal(
-    fs.existsSync(path.join(pluginRoot, relativePath)),
-    true,
-    `BUNDLED_AGENT_SPINE_REGRESSION: README link target ${relativePath} is missing`,
-  );
-}
-
-console.log(`bundled-agent-spine-regression PASS (${expectedVersion})`);