@dzhechkov/cloudru-hub 0.1.14 → 0.1.16

package/test/cost-compare.test.mjs

@@ -0,0 +1,280 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { after, test } from 'node:test';
+
+const pkg = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const cli = join(pkg, 'bin/cloudru-hub.js');
+const example = join(pkg, 'docs/cost-compare.example.json');
+const exampleText = readFileSync(example, 'utf8');
+const source = JSON.parse(exampleText);
+const dirs = [];
+after(() => { for (const dir of dirs) rmSync(dir, { recursive: true, force: true }); });
+function directory() { const dir = mkdtempSync(join(tmpdir(), 'cloudru-cost-test-')); dirs.push(dir); return dir; }
+function invoke(input, flags = [], env = {}) {
+  const dir = directory(), path = join(dir, 'input.json');
+  writeFileSync(path, JSON.stringify(input));
+  const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path, '--json', ...flags], {
+    cwd: dir, env: { ...process.env, CLOUDRU_VM_BIN: join(dir, 'no-engine'), CLOUDRU_HUB_CONFIG: join(dir, 'no-config'), ...env },
+    encoding: 'utf8', timeout: 5000, maxBuffer: 1024 * 1024,
+  });
+  assert.ifError(result.error);
+  return result;
+}
+function invokeRaw(raw) {
+  const dir = directory(), path = join(dir, 'input.json');
+  writeFileSync(path, raw);
+  const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path, '--json'], {
+    cwd: dir, encoding: 'utf8', timeout: 5000, maxBuffer: 1024 * 1024,
+  });
+  assert.ifError(result.error);
+  return result;
+}
+function editRaw(from, to) {
+  assert.ok(exampleText.includes(from), `missing fixture anchor ${from}`);
+  return exampleText.replace(from, to);
+}
+function run(input) {
+  const result = invoke(input);
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stderr, '');
+  return JSON.parse(result.stdout);
+}
+function reject(mutator, pattern) {
+  const input = structuredClone(source);
+  mutator(input);
+  const result = invoke(input);
+  assert.equal(result.status, 1, result.stdout + result.stderr);
+  assert.equal(result.stdout, '', 'invalid input must not emit partial success JSON');
+  assert.match(result.stderr, pattern);
+}
+function complete(input) {
+  input.equivalence = { status: 'assumed', assumptions: ['Only modeled infrastructure cost is compared; application equivalence is an operator assumption.'] };
+  for (const scenario of input.scenarios) {
+    scenario.resources.trafficGB = '7.5';
+    scenario.categories.traffic = { status: 'priced', items: [{
+      id: 'synthetic-traffic', description: 'Test-only invented traffic tariff', quantity: '7.5', unit: 'traffic-GB', rateRub: '0.12',
+      tariff: { url: 'https://example.invalid/test-only-rate', version: 'synthetic-test', asOf: '2026-10-21', vatBasis: 'included', pageOrRow: 'test fixture only' },
+    }] };
+  }
+  return input;
+}
+
+test('packaged official-rate example has independent 24h subtotals, capacity and no winner', () => {
+  const result = run(source);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), ['251.6616', '466.1376']);
+  assert.deepEqual(result.scenarios.map(item => item.categories.storage.totalRubExact), ['22.8384', '30.4512']);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.normalSlots), [6, 6]);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.survivingSlots), [4, 4]);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.feasible), [true, true]);
+  assert.deepEqual(result.scenarios.map(item => item.unpriced.map(entry => entry.category)), [['traffic'], ['traffic']]);
+  assert.equal(result.comparison.eligible, false);
+  assert.equal(result.comparison.winner, null);
+  assert.equal(result.comparison.savingsRubExact, null);
+  assert.match(result.scenarios[0].categories.compute.items[0].formula, /24 hours/);
+  assert.equal(result.scenarios[1].categories.compute.items[0].tariff.version, '260918');
+  assert.match(result.scenarios[0].categories.compute.items[0].formula, /3 instance × 2\.9707 RUB\/instance-hour × 24 hours/);
+});
+
+test('human output includes modeled formulas, tariff provenance, unknowns and assumptions', () => {
+  const dir = directory(), path = join(dir, 'input.json'); writeFileSync(path, JSON.stringify(source));
+  const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path], { cwd: dir, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /3 instance × 2\.9707 RUB\/instance-hour × 24 hours/);
+  assert.match(result.stdout, /evolution-compute\.pdf version 261014/);
+  assert.match(result.stdout, /unpriced traffic/);
+  assert.match(result.stdout, /assumption:/);
+  assert.match(result.stdout, /No winner/);
+});
+
+test('fractional horizon keeps exact sums and rounds display only at output', () => {
+  const input = structuredClone(source); input.horizonHours = '1.5';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), ['15.72885', '29.1336']);
+  assert.deepEqual(result.scenarios.map(item => item.categories.storage.totalRubExact), ['1.4274', '1.9032']);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubDisplay), ['15.73', '29.13']);
+});
+
+test('test-only traffic is charged once, then conditional lower modeled cost is identified', () => {
+  for (const [horizon, expected, savings] of [
+    ['24', ['252.5616', '467.0376'], '214.476'],
+    ['1.5', ['16.62885', '30.0336'], '13.40475'],
+  ]) {
+    const input = complete(structuredClone(source)); input.horizonHours = horizon;
+    const result = run(input);
+    assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), expected);
+    assert.deepEqual(result.scenarios.map(item => item.categories.traffic.totalRubExact), ['0.9', '0.9']);
+    assert.equal(result.comparison.eligible, true);
+    assert.equal(result.comparison.winner, 'vm');
+    assert.equal(result.comparison.savingsRubExact, savings);
+    assert.match(result.comparison.basis, /conditional/);
+    assert.deepEqual(result.equivalence.assumptions, input.equivalence.assumptions);
+  }
+});
+
+test('aggregate CPU cannot conceal per-node packing failure', () => {
+  const input = complete(structuredClone(source));
+  input.workload.replicas = 4;
+  input.workload.cpuPerReplica = '1.5';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.normalSlots), [3, 3]);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.feasible), [false, false]);
+  assert.equal(result.comparison.winner, null);
+});
+
+test('one-node failure capacity is distinct from normal capacity', () => {
+  const input = complete(structuredClone(source));
+  input.workload.replicas = 5;
+  input.workload.survivingReplicas = 5;
+  const failed = run(input);
+  assert.deepEqual(failed.scenarios.map(item => item.capacity.normalSlots), [6, 6]);
+  assert.deepEqual(failed.scenarios.map(item => item.capacity.survivingSlots), [4, 4]);
+  assert.equal(failed.comparison.winner, null);
+  input.workload.survivingReplicas = 4;
+  const fit = run(input);
+  assert.deepEqual(fit.scenarios.map(item => item.capacity.feasible), [true, true]);
+  assert.equal(fit.comparison.winner, 'vm');
+});
+
+test('guaranteed CPU share, reservation and exact decimal floor determine per-node slots', () => {
+  const input = complete(structuredClone(source));
+  for (const scenario of input.scenarios) {
+    scenario.nodes.cpu = '4'; scenario.nodes.cpuShare = '0.5'; scenario.nodes.reservedCpu = '0.5';
+  }
+  input.workload.cpuPerReplica = '0.5';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.perNodeCpuSlots), [3, 3]);
+  const tenth = complete(structuredClone(source));
+  for (const scenario of tenth.scenarios) { scenario.nodes.cpu = '0.3'; scenario.nodes.cpuShare = '1'; }
+  tenth.workload.cpuPerReplica = '0.1';
+  assert.deepEqual(run(tenth).scenarios.map(item => item.capacity.perNodeCpuSlots), [3, 3]);
+});
+
+test('a tie is explicit and carries no winner or savings', () => {
+  const input = complete(structuredClone(source));
+  const vm = input.scenarios[0];
+  const k8s = input.scenarios[1];
+  // Test-only unit rates: 66 VM hourly units versus 87 K8s hourly units,
+  // a 21 × 24 = 504 RUB difference, offset by 7.5 × (67.32 − 0.12).
+  vm.categories.compute.items[0].rateRub = '1';
+  vm.categories.storage.items[0].rateRub = '1';
+  vm.categories.publicIp.items[0].rateRub = '1';
+  k8s.categories.compute.items[0].rateRub = '1';
+  k8s.categories.controlPlane.items[0].rateRub = '1';
+  k8s.categories.storage.items[0].rateRub = '1';
+  k8s.categories.publicIp.items[0].rateRub = '1';
+  k8s.categories.snat.items[0].rateRub = '1';
+  // VM has 66 hourly units; K8s has 87. Add the same 7.5GB traffic to both; tie via VM traffic premium.
+  vm.categories.traffic.items[0].rateRub = '67.32';
+  k8s.categories.traffic.items[0].rateRub = '0.12';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), ['2088.9', '2088.9']);
+  assert.equal(result.comparison.eligible, true);
+  assert.equal(result.comparison.tie, true);
+  assert.equal(result.comparison.winner, null);
+  assert.equal(result.comparison.savingsRubExact, null);
+});
+
+test('unknown equivalence alone suppresses a winner even with complete prices', () => {
+  const input = complete(structuredClone(source));
+  input.equivalence = source.equivalence;
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.complete), [true, true]);
+  assert.equal(result.comparison.winner, null);
+});
+
+test('raw flags reject duplicates, missing values, unknown options and positionals', () => {
+  const dir = directory(), path = join(dir, 'input.json'); writeFileSync(path, JSON.stringify(source));
+  for (const flags of [[], ['--input'], ['--input', path, '--input', path], ['--input', path, '--json', '--json'], ['--input', path, '--rate', '1'], ['--input', path, 'extra']]) {
+    const result = spawnSync(process.execPath, [cli, 'cost-compare', ...flags], { cwd: dir, encoding: 'utf8' });
+    assert.equal(result.status, 1, JSON.stringify(flags)); assert.equal(result.stdout, ''); assert.match(result.stderr, /cost-compare/);
+  }
+});
+
+test('input must be a bounded regular file and cannot be a symlink', () => {
+  const dir = directory();
+  const large = join(dir, 'large.json'); writeFileSync(large, ' '.repeat(128 * 1024 + 1));
+  const link = join(dir, 'link.json'); symlinkSync(example, link);
+  for (const path of [large, link, '/dev/null']) {
+    const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path, '--json'], { encoding: 'utf8' });
+    assert.equal(result.status, 1, path); assert.equal(result.stdout, ''); assert.match(result.stderr, /cost-compare/);
+  }
+});
+
+for (const [name, raw, pattern] of [
+  ['top-level duplicate horizon', editRaw('"horizonHours": "24"', '"horizonHours": "8760", "horizonHours": "24"'), /duplicate decoded object member/],
+  ['nested duplicate CPU declaration', editRaw('"cpu": "2", "ramGB": "4"', '"cpu": "4", "cpu": "2", "ramGB": "4"'), /duplicate decoded object member/],
+  ['sibling scenario duplicate id', editRaw('"id": "k8s",', '"id": "other", "id": "k8s",'), /duplicate decoded object member/],
+  ['escaped-equivalent duplicate member', editRaw('"horizonHours": "24"', '"horizonHours": "8760", "horizon\\u0048ours": "24"'), /duplicate decoded object member/],
+  ['rounded fractional replica token', JSON.stringify(source).replace('"replicas":3', '"replicas":3.0000000000000001'), /numeric tokens must be canonical/],
+  ['unsafe integer replica token', JSON.stringify(source).replace('"replicas":3', '"replicas":9007199254740993'), /numeric tokens must be canonical/],
+  ['infinite exponent token', JSON.stringify(source).replace('"replicas":3', '"replicas":1e309'), /numeric tokens must be canonical/],
+  ['malformed exponent token', JSON.stringify(source).replace('"replicas":3', '"replicas":3e+'), /object member requires/],
+  ['excessive JSON nesting', `${'['.repeat(65)}0${']'.repeat(65)}`, /nesting exceeds/],
+  ['raw numeric value for decimal-string horizon', editRaw('"horizonHours": "24"', '"horizonHours": 24'), /horizonHours/],
+]) test(`raw JSON rejects ${name} before accepting a result`, () => {
+  const result = invokeRaw(raw);
+  assert.equal(result.status, 1, result.stdout + result.stderr);
+  assert.equal(result.stdout, '');
+  assert.match(result.stderr, pattern);
+});
+
+test('canonical safe integer tokens and quoted braces/commas remain accepted', () => {
+  const input = structuredClone(source);
+  input.workload.replicas = 3;
+  input.equivalence.reason = 'unknown: text contains "quotes", braces { } and comma, without object members';
+  const result = invokeRaw(JSON.stringify(input));
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(JSON.parse(result.stdout).workload.replicas, 3);
+});
+
+test('CLI path cannot resolve an engine, spawn, access network or require credentials', () => {
+  const dir = directory(), preload = join(dir, 'forbid.cjs');
+  writeFileSync(preload, `
+const Module = require('module'); const original = Module._load;
+Module._load = function(request, parent, main) {
+  if (parent?.filename.endsWith('/src/cli.js') && ['./resolve','./classification','./install','./safe-mcp','./deploy-approval','./k8s-approval','./dialects'].includes(request)) throw Error('legacy engine/auth module load forbidden');
+  if (request === 'yaml') throw Error('external dependency load forbidden');
+  return original.apply(this, arguments);
+};
+const child = require('child_process'); for (const name of ['spawn','spawnSync','exec','execFile']) child[name] = () => { throw Error('spawn forbidden'); };
+for (const name of ['http','https','net']) { const mod = require(name); for (const key of ['request','get','connect','createConnection']) if (key in mod) mod[key] = () => { throw Error('network forbidden'); }; }
+global.fetch = () => { throw Error('fetch forbidden'); };
+`);
+  const input = join(dir, 'input.json'); writeFileSync(input, JSON.stringify(source));
+  const result = spawnSync(process.execPath, ['--require', preload, cli, 'cost-compare', '--input', input, '--json'], {
+    cwd: dir, env: { PATH: '/nonexistent', CLOUDRU_VM_BIN: '/no-engine', CLOUDRU_HUB_CONFIG: '/no-config' }, encoding: 'utf8', timeout: 5000,
+  });
+  assert.ifError(result.error); assert.equal(result.status, 0, result.stderr);
+  assert.equal(JSON.parse(result.stdout).comparison.winner, null);
+});
+
+for (const [label, mutate, pattern] of [
+  ['unknown schema field', x => { x.hidden = true; }, /unknown field/],
+  ['non-RUB currency', x => { x.currency = 'USD'; }, /currency/],
+  ['different VAT basis', x => { x.vatBasis = 'excluded'; }, /vatBasis/],
+  ['scientific rate', x => { x.scenarios[0].categories.compute.items[0].rateRub = '1e3'; }, /rateRub/],
+  ['monthly unit', x => { x.scenarios[0].categories.compute.items[0].unit = 'instance-month'; }, /unit/],
+  ['wrong unit category', x => { x.scenarios[0].categories.storage.items[0].unit = 'instance-hour'; }, /unit/],
+  ['missing tariff version', x => { delete x.scenarios[0].categories.compute.items[0].tariff.version; }, /version/],
+  ['HTTP tariff URL', x => { x.scenarios[0].categories.compute.items[0].tariff.url = 'http://example.invalid'; }, /url/],
+  ['wrong tariff VAT basis', x => { x.scenarios[0].categories.compute.items[0].tariff.vatBasis = 'excluded'; }, /vatBasis/],
+  ['unbound worker quantity', x => { x.scenarios[0].categories.compute.items[0].quantity = '2'; }, /quantities must sum/],
+  ['unbound storage quantity', x => { x.scenarios[0].categories.storage.items[0].quantity = '59'; }, /quantities must sum/],
+  ['unbound IP quantity', x => { x.scenarios[0].categories.publicIp.items[0].quantity = '2'; }, /quantities must sum/],
+  ['noninteger service count', x => { x.scenarios[0].categories.compute.items[0].quantity = '3.5'; }, /integer service count/],
+  ['missing K8s control plane', x => { x.scenarios[1].controlPlaneCount = 0; }, /controlPlaneCount/],
+  ['unpriced compute with zero declaration', x => { x.scenarios[0].nodes.count = 0; }, /nodes.count/],
+  ['not-used positive storage', x => { x.scenarios[0].categories.storage = { status: 'not-used', reason: 'omitted' }; }, /not-used requires/],
+  ['unknown traffic silently zero', x => { x.scenarios[0].resources.trafficGB = '0'; }, /declared zero quantity/],
+  ['priced unknown traffic', x => { x.scenarios[0].categories.traffic = { status: 'priced', items: [] }; }, /priced requires/],
+  ['oversubscribed reservations', x => { x.scenarios[0].nodes.reservedCpu = '3'; }, /reservations exceed/],
+  ['declared node failure exceeds topology', x => { x.workload.failedNodes = 4; }, /failedNodes/],
+  ['bad CPU share', x => { x.scenarios[0].nodes.cpuShare = '1.1'; }, /cpuShare/],
+  ['survival above replicas', x => { x.workload.survivingReplicas = 4; }, /survivingReplicas/],
+  ['duplicate kinds', x => { x.scenarios[1].kind = 'vm'; x.scenarios[1].controlPlaneCount = 0; x.scenarios[1].categories.controlPlane = { status: 'not-used', reason: 'none' }; }, /one scenario of each kind/],
+  ['missing equivalence assumption', x => { x.equivalence = { status: 'assumed', assumptions: [] }; }, /assumptions/],
+]) test(`rejects ${label} without partial output`, () => reject(mutate, pattern));

package/test/deploy-approval.test.mjs

@@ -110,6 +110,18 @@ test('partial deploy preserves its VM UUID for recovery and redacts nested secre
   assert.ok(denied.responses[0].error);
 });
 
+test('unreadable apply result names the consumed plan and requires read-only reconciliation', () => {
+  const id = 'plan-555555555555';
+  fs.writeFileSync(path.join(path.dirname(planFile), `${id}.json`), JSON.stringify({ ...plan, plan_id: id }));
+  issueApproval(id, 50, env);
+  const out = run([rpc(1, 'deploy_apply', { plan_id: id })], { FAKE_DEPLOY_OUTCOME: JSON.stringify('unreadable') });
+  const result = JSON.parse(out.responses[0].result.content[0].text);
+  assert.equal(out.responses[0].result.isError, true);
+  assert.equal(result.plan_id, id);
+  assert.equal(result.verdict, 'unknown');
+  assert.match(result.next, /deploy_reconcile/);
+});
+
 test('static site requires the reviewed digest and never grants an SSH command session', () => {
   const id = 'plan-aabbccddeeff';
   const digest = 'a'.repeat(64);

package/test/k8s-approval.test.mjs

@@ -67,6 +67,46 @@ test('unexpected mutators, exposure, privilege, image and namespace are rejected
   }
 });
 
+test('web-image profile accepts a reviewed digest-pinned application and refuses privilege or exposure drift', () => {
+  const app = 'lesson-web';
+  const image = `registry.example.com/lesson-web@sha256:${'a'.repeat(64)}`;
+  const web = [
+    { apiVersion: 'apps/v1', kind: 'Deployment', metadata: { name: app, namespace: 'lesson-app' }, spec: {
+      replicas: 1, selector: { matchLabels: { app } }, template: { metadata: { labels: { app } }, spec: {
+        automountServiceAccountToken: false, securityContext: { runAsNonRoot: true },
+        containers: [{ name: app, image, ports: [{ containerPort: 8080 }], readinessProbe: { httpGet: { path: '/health', port: 8080 } },
+          resources: { requests: { cpu: '50m', memory: '64Mi' }, limits: { cpu: '200m', memory: '256Mi' } },
+          securityContext: { allowPrivilegeEscalation: false, readOnlyRootFilesystem: true, runAsUser: 10001,
+            runAsGroup: 10001, capabilities: { drop: ['ALL'] } } }],
+      } } } },
+    { apiVersion: 'v1', kind: 'Service', metadata: { name: app, namespace: 'lesson-app' },
+      spec: { type: 'ClusterIP', selector: { app }, ports: [{ port: 80, targetPort: 8080 }] } },
+  ];
+  const raw = serialize(web);
+  assert.equal(validateManifest(raw, 'lesson-app', 'web-image').image, image);
+  assert.throws(() => validateManifest(raw, 'lesson-app'), /three valid YAML documents/);
+  for (const mutate of [
+    (r) => { r[0].spec.template.spec.containers[0].image = 'registry.example.com/lesson-web:latest'; },
+    (r) => { r[0].spec.template.spec.containers[0].image = `https://registry.example.com/lesson-web@sha256:${'a'.repeat(64)}`; },
+    (r) => { r[0].spec.template.spec.hostNetwork = true; },
+    (r) => { r[0].spec.template.spec.containers[0].securityContext.privileged = true; },
+    (r) => { r[1].spec.type = 'LoadBalancer'; },
+    (r) => { r[0].metadata.namespace = 'default'; },
+    (r) => { r[0].metadata.name = r[1].metadata.name = '123'; r[0].spec.selector.matchLabels.app = r[0].spec.template.metadata.labels.app = r[1].spec.selector.app = '123'; r[0].spec.template.spec.containers[0].name = '123'; },
+  ]) {
+    const changed = structuredClone(web); mutate(changed);
+    assert.throws(() => validateManifest(serialize(changed), 'lesson-app', 'web-image'));
+  }
+  const source = path.join(scratch, 'lesson-app.yaml');
+  fs.writeFileSync(source, raw);
+  const reviewed = require('crypto').createHash('sha256').update(raw).digest('hex');
+  const approval = issueK8sApproval(clusterId, 'lesson-app', source, reviewed, env, Date.now(), 'web-image');
+  assert.equal(approval.profile, 'web-image');
+  assert.equal(consumeK8sApproval(approval.approvalId, env).manifest, raw);
+  fs.writeFileSync(source, serialize([{ ...web[0], metadata: { name: 'changed', namespace: 'lesson-app' } }, web[1]]));
+  assert.throws(() => issueK8sApproval(clusterId, 'lesson-app', source, reviewed, env, Date.now(), 'web-image'), /digest differs|must match/);
+});
+
 test('digest, project, expiry and single-use approval bind the exact manifest', () => {
   assert.throws(() => issueK8sApproval(clusterId, 'snake-pilot', manifestFile, '0'.repeat(64), env), /digest differs/);
   const a = issueK8sApproval(clusterId, 'snake-pilot', manifestFile, digest, env, 1000);

package/test/resolve.test.mjs

@@ -125,6 +125,6 @@ test('sha256File matches node crypto', () => {
 test('the pinned linux-x64 hash is the rebuilt private engine sha256', () => {
   assert.equal(
     PKG.cloudruHub.binaryHashes['linux-x64'],
-    '4463b09323c9dfe0c32d618d335734a947e7fab0a75d07a7bea089b97a97c9b6',
+    '94fdba4fe4d1a71e684be998c3d2f94f374ff4e4054db2683bcc04d72bfabc03',
   );
 });

package/test/safe-mcp.test.mjs

@@ -47,6 +47,26 @@ test('safe proxy filters listed tools and blocks ask, deny, unknown and other me
   assert.deepEqual(out.forwarded.filter((m) => m.method === 'tools/call').map((m) => m.params.name), ['vm_list']);
 });
 
+test('k8s_get recovery selectors pass existing read profiles while paid creates stay denied', () => {
+  const snapshot = JSON.parse(fs.readFileSync(path.join(pkg, 'data/tools-list-snapshot.json'), 'utf8'));
+  assert.equal(snapshot.toolCount, 146);
+  assert.equal(snapshot.tools.length, 146);
+  for (const profile of ['all', 'kubernetes', 'k8s-deploy']) {
+    const out = run([
+      msg(1, 'tools/call', { name: 'k8s_get', arguments: { receipts: true, limit: 10 } }),
+      msg(2, 'tools/call', { name: 'k8s_get', arguments: { receipt_id: 'a'.repeat(64) } }),
+      msg(3, 'tools/call', { name: 'k8s_create', arguments: { confirmed: true } }),
+      msg(4, 'tools/call', { name: 'k8s_add_nodepool', arguments: { confirmed: true } }),
+    ], profile);
+    const byId = Object.fromEntries(out.responses.map((r) => [r.id, r]));
+    assert.match(byId[1].result.content[0].text, /executed k8s_get/);
+    assert.match(byId[2].result.content[0].text, /executed k8s_get/);
+    assert.ok(byId[3].error, `${profile}: k8s_create must be denied`);
+    assert.ok(byId[4].error, `${profile}: k8s_add_nodepool must be denied`);
+    assert.deepEqual(out.forwarded.map((m) => m.params.name), ['k8s_get', 'k8s_get']);
+  }
+});
+
 test('Hermes keepalive gets the filtered tool list while the serial engine is busy', async () => {
   const serial = path.join(scratch, 'serial-engine');
   const serialLog = path.join(scratch, 'serial-forwarded.jsonl');