@dzhechkov/cloudru-hub 0.1.4

package/sbom.json

@@ -0,0 +1,253 @@
+{
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.5",
+  "version": 1,
+  "metadata": {
+    "component": {
+      "type": "library",
+      "name": "cloudru-hub"
+    }
+  },
+  "components": [
+    {
+      "type": "file",
+      "name": "CHANGELOG.md",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "106646f93a18c0335ff739c61df9432b9a79b743b53941f15e9bcc64b35504a4"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "LICENSE",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "68da42b10dcc095cdfd7249557cee30285664e5dea00dc85475ff047d975616a"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "README.md",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "38e29682c26399d930823f68ff35febfc2e0045e3912e1665ed071c9b73c084c"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "THIRD_PARTY_NOTICES.md",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "109cffdaaf9402e88f6cc35a0497ba49db015b329fce87ba20762f34dc95c051"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "bin/cloudru-hub.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "fcdb6806036feff444611483f4216477c83bc53d28ebca4736370c671f7f72db"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "data/dialects.json",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8007dd5da843074d497617bdf3709cc3dc516a138171781b5ef0aa3ff596fa4d"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "data/pointer-section.md",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6f4557d97b90936ef153dc90eac4bdceb6846b6d08d8aec45c86baac328cca60"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "data/tools-classification.json",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "13d6a3e87d767d0015f6b2af0223633fa99e49c69c9a8adcec8f6fce6e46d36e"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "data/tools-list-snapshot.json",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "56221fa8170f2b32ab6d3a907261badc07695f47ae9ac4adca4e43d2ea5ee06f"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "docs/LOCAL-TESTING.md",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "092142c00295c54866330f2159a13284d04e2f35a749b32dff0ca4f2ab28ea54"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "package.json",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "24333e792a9cbdbc5d23f10d47969f3d3e984a2acc000c903b4003ffcf42d02f"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "src/classification.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8c1096273d2a2c9c6336c476096cb1e064184c6876d5466470fb69705ba3f265"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "src/cli.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "db981ad0078c80ba7a859057638a2576d7f02d87ca2891f8083a92a8147742dd"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "src/dialects.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a826cea19ff38e24ad7fd36c6ec85a51e2cd1d985d1fa92941f77bcf353db1de"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "src/install.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "5d087b289aaf8cd2e1b4cffbd2227eb3bdc7264cddc0877561e08bc0ea6d6fd2"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "src/resolve.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "5cbd0861c2973fab62271269b10f748b9638e74f40e8ea034f78ac63bed58001"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "templates/.claude/hooks/cloudru-ssh-guard.cjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ad8c4ea89b28a366fa72e3507dbef9f774f4f2777e6bd2289a429329ab94cc0c"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "test/classification.test.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "25290e9a8715d13670d617e23cb47c4c2d71b1506a8d98e5b682733b626a18b8"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "test/dialects.test.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9b83b2e2cbbee4ead33af61db840833ce4aa2dd0cf5a4448d72d5886098639c6"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "test/hook.test.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d53b58e853b6a37342a3a0fade782bced6283ea2ec376e2ac954b23f9ec68c17"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "test/install.test.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e986b29346672bf75b384ab6d8657265b8ecb8f62df6563dca317c1fc63fc8fc"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "test/mutation-registry.json",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "23baf0c1c20afc5bbbfcd72ae9c553ce8a774c25328609e33f43e11cf4ca5581"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "test/pack-holds.test.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a083ff619f1d97b3e0e1b95dec6e98b56c4296da5171e2eb41c713dd983c8d69"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "test/resolve.test.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6b524f69c5ed03aaafab67e734e58092033423b86feade28ad03f516feba2380"
+        }
+      ]
+    }
+  ]
+}

package/src/classification.js

@@ -0,0 +1,66 @@
+'use strict';
+// Golden tool classification (ADR-004 Confirmation, layer 1) — loads
+// data/tools-classification.json and derives the permission rule sets the installer
+// emits. Deny-by-default: a live tool absent from the classification is a DRIFT
+// FINDING, never silently allowed.
+
+const fs = require('fs');
+const path = require('path');
+
+const CLASSIFICATION_FILE = path.join(__dirname, '..', 'data', 'tools-classification.json');
+const SNAPSHOT_FILE = path.join(__dirname, '..', 'data', 'tools-list-snapshot.json');
+
+// The MCP tool-name prefix normalization (`mcp__cloudru-vm__*` vs `mcp__cloudru_vm__*`)
+// is ❌ NOT VERIFIED until a live Claude Code probe (feature README, open blocker 3).
+// Until then we emit BOTH spellings — an unmatched permission rule is inert, and the
+// deny-by-default direction stays safe regardless of which spelling the runtime uses.
+const SERVER_PREFIXES = ['mcp__cloudru-vm__', 'mcp__cloudru_vm__'];
+
+function loadClassification() {
+  return JSON.parse(fs.readFileSync(CLASSIFICATION_FILE, 'utf8'));
+}
+
+function loadSnapshot() {
+  return JSON.parse(fs.readFileSync(SNAPSHOT_FILE, 'utf8'));
+}
+
+/** Names by permission action, from the golden file. */
+function namesByPermission(cls = loadClassification()) {
+  const out = { allow: [], ask: [], deny: [] };
+  for (const [name, c] of Object.entries(cls.tools)) out[c.permission].push(name);
+  return out;
+}
+
+/** Full permission rule strings (both prefix spellings) the installer writes. */
+function permissionRules(cls = loadClassification()) {
+  const by = namesByPermission(cls);
+  const expand = (names) => names.flatMap((n) => SERVER_PREFIXES.map((p) => p + n)).sort();
+  return { allow: expand(by.allow), ask: expand(by.ask), deny: expand(by.deny) };
+}
+
+/**
+ * Drift check against a LIVE tools/list (ADR-004 Confirmation: "падает, если появился
+ * тул, неизвестный классификатору ИЛИ мутирующий тул отсутствует в шаблоне").
+ * @param {string[]} liveNames
+ * @returns {{unknown:string[], missing:string[]}} unknown = live tool not classified;
+ *          missing = classified tool absent from the live list (engine drift the other way).
+ */
+function coverageGaps(liveNames, cls = loadClassification()) {
+  const classified = new Set(Object.keys(cls.tools));
+  const live = new Set(liveNames);
+  return {
+    unknown: liveNames.filter((n) => !classified.has(n)).sort(),
+    missing: [...classified].filter((n) => !live.has(n)).sort(),
+  };
+}
+
+module.exports = {
+  CLASSIFICATION_FILE,
+  SNAPSHOT_FILE,
+  SERVER_PREFIXES,
+  loadClassification,
+  loadSnapshot,
+  namesByPermission,
+  permissionRules,
+  coverageGaps,
+};

package/src/cli.js

@@ -0,0 +1,174 @@
+'use strict';
+// cloudru-hub CLI — thin npm launcher for the cloudru-vm MCP engine (ADR-002).
+// Zero dependencies, CommonJS, boots from any cwd (dz release smoke contract).
+
+const { spawn, spawnSync } = require('child_process');
+const { resolveEngine } = require('./resolve');
+const { loadClassification, loadSnapshot, coverageGaps } = require('./classification');
+const { install } = require('./install');
+const { compileSkill, writeCompiled } = require('./dialects');
+const PKG = require('../package.json');
+
+function showHelp(write) {
+  write(`cloudru-hub ${PKG.version} — unofficial Cloud.ru Evolution launcher (NOT affiliated with Cloud.ru)
+
+The cloudru-vm engine binary is resolved at RUNTIME, never bundled in this package.
+Engine additions authored by Тимур (publication approved — grant record in LICENSE Part 2);
+launcher, adapters and CLI foundation by Dmitry Zhechkov (MIT).
+
+Usage: cloudru-hub <command> [options]
+
+Commands:
+  resolve [--json]         Locate the engine binary (env CLOUDRU_VM_BIN → ~/.cloudru-hub/config.json
+                           enginePath → optional platform package) and verify its sha256 pin.
+  self-test [--json]       End-to-end local check: resolve → sha256 → engine version → live
+                           tools/list probe → golden-classification coverage. Exit 0 = all green.
+  mcp                      Run the resolved engine as an MCP stdio server (what .mcp.json points at).
+  install --target <t>     Emit the per-target integration per ADR-005 tiering:
+                           claude-code (full: .mcp.json + permission brake + PreToolUse veto, with an
+                           EXECUTED veto probe), codex (plan-only), agents-md|gemini (pointer-only),
+                           openclaude|opencode|cursor|windsurf|copilot (refused: DEGRADED until live probe).
+           [--dir <path>]  Project directory (default: cwd).  [--npx] use the npx form in .mcp.json.
+  compile-skill --canonical <dir> --target <t> --out <dir>
+                           Generate a target dialect of the canonical skill tree (ADR-006). The
+                           canonical corpus is NOT shipped here; point --canonical at the skill/
+                           directory of an engine distribution.
+  version                  Print launcher version and pinned engine hashes.
+  help                     This text.
+
+Local testing (this server, no publish): docs/LOCAL-TESTING.md`);
+}
+
+function parseArgs(argv) {
+  const flags = new Set();
+  const opts = new Map();
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--json' || a === '--npx' || a === '--help' || a === '-h') flags.add(a.replace(/^-+/, ''));
+    else if (a.startsWith('--')) { opts.set(a.slice(2), argv[i + 1]); i++; }
+    else positional.push(a);
+  }
+  return { flags, opts, positional };
+}
+
+function jsonRpcProbe(binPath, timeoutMs = 20_000) {
+  const req = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' }) + '\n';
+  const r = spawnSync(binPath, ['mcp'], { input: req, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+  if (r.error) return { error: String(r.error.message || r.error) };
+  const line = String(r.stdout || '').split('\n').find((l) => l.trim().startsWith('{'));
+  if (!line) return { error: 'engine produced no JSON-RPC response line' };
+  try {
+    const parsed = JSON.parse(line);
+    const tools = parsed && parsed.result && Array.isArray(parsed.result.tools) ? parsed.result.tools : null;
+    if (!tools) return { error: 'tools/list response carries no result.tools' };
+    return { tools };
+  } catch (e) {
+    return { error: 'unparseable tools/list response: ' + e.message };
+  }
+}
+
+function cmdResolve(flags, write) {
+  const r = resolveEngine();
+  if (r.error) { write(r.error); return 1; }
+  if (flags.has('json')) { write(JSON.stringify(r, null, 2)); return 0; }
+  write(`engine   ${r.path}`);
+  write(`source   ${r.source}`);
+  write(`sha256   ${r.sha256}`);
+  write(`pinned   ${r.pinned || '<no pin for ' + r.key + '>'}`);
+  write(`verified ${r.verified ? 'yes — matches the pinned baseline' : 'NO — not the pinned baseline (tolerated for env/config paths)'}`);
+  return 0;
+}
+
+function cmdSelfTest(flags, write) {
+  const out = { steps: [], ok: false };
+  const step = (name, ok, detail) => { out.steps.push({ name, ok, detail }); if (!flags.has('json')) write(`${ok ? '✓' : '✗'} ${name}: ${detail}`); return ok; };
+
+  const r = resolveEngine();
+  if (r.error) { step('resolve', false, r.error.split('\n')[0]); if (flags.has('json')) write(JSON.stringify(out, null, 2)); return 1; }
+  step('resolve', true, `${r.path} (source: ${r.source})`);
+  step('sha256', true, `${r.sha256}${r.verified ? ' — MATCHES pinned baseline' : ' — no pin match (dev build?)'}`);
+
+  const ver = spawnSync(r.path, ['version'], { encoding: 'utf8', timeout: 10_000 });
+  const verOk = ver.status === 0;
+  step('engine-version', verOk, verOk ? String(ver.stdout || '').trim() : `exit ${ver.status}`);
+
+  const probe = jsonRpcProbe(r.path);
+  if (probe.error) { step('tools-list', false, probe.error); if (flags.has('json')) write(JSON.stringify(out, null, 2)); return 1; }
+  const names = probe.tools.map((t) => t.name);
+  const snap = loadSnapshot();
+  step('tools-list', true, `${names.length} tools live (snapshot: ${snap.toolCount})`);
+
+  const gaps = coverageGaps(names);
+  const gapsOk = gaps.unknown.length === 0;
+  step('classification-coverage', gapsOk, gapsOk
+    ? `every live tool is classified (${Object.keys(loadClassification().tools).length} golden entries)${gaps.missing.length ? `; ${gaps.missing.length} classified tool(s) absent live: ${gaps.missing.join(', ')}` : ''}`
+    : `UNCLASSIFIED live tools (deny-by-default — update data/tools-classification.json): ${gaps.unknown.join(', ')}`);
+
+  out.ok = out.steps.every((s) => s.ok);
+  if (flags.has('json')) write(JSON.stringify(out, null, 2));
+  else write(out.ok ? 'self-test: ALL GREEN' : 'self-test: FAILED');
+  return out.ok ? 0 : 1;
+}
+
+function cmdMcp() {
+  const r = resolveEngine();
+  if (r.error) { process.stderr.write(r.error + '\n'); return 1; }
+  const child = spawn(r.path, ['mcp'], { stdio: 'inherit' });
+  child.on('exit', (code, signal) => process.exit(signal ? 1 : code === null ? 1 : code));
+  child.on('error', (e) => { process.stderr.write('cloudru-hub mcp: ' + e.message + '\n'); process.exit(1); });
+  return null; // async — exit via child
+}
+
+function main(argv, write = (s) => process.stdout.write(s + '\n')) {
+  const { flags, opts, positional } = parseArgs(argv);
+  const cmd = positional[0] || 'help';
+  if (flags.has('help') || flags.has('h') || cmd === 'help') { showHelp(write); return 0; }
+
+  switch (cmd) {
+    case 'version':
+      write(`cloudru-hub ${PKG.version}`);
+      write(`pinned engine: ${PKG.cloudruHub.engineVersion}`);
+      for (const [k, v] of Object.entries(PKG.cloudruHub.binaryHashes)) write(`  ${k}  sha256 ${v}`);
+      return 0;
+    case 'resolve':
+      return cmdResolve(flags, write);
+    case 'self-test':
+      return cmdSelfTest(flags, write);
+    case 'mcp': {
+      const rc = cmdMcp();
+      return rc === null ? null : rc;
+    }
+    case 'install': {
+      const target = opts.get('target');
+      if (!target) { write('cloudru-hub install: --target is required (claude-code|codex|agents-md|gemini|…)'); return 1; }
+      const res = install(target, opts.get('dir') || process.cwd(), { npx: flags.has('npx') });
+      for (const line of res.lines) write(line);
+      return res.code;
+    }
+    case 'compile-skill': {
+      const canonical = opts.get('canonical');
+      const target = opts.get('target');
+      const outDir = opts.get('out');
+      if (!canonical || !target || !outDir) { write('cloudru-hub compile-skill: --canonical <dir> --target <t> --out <dir> are all required'); return 1; }
+      const result = compileSkill(canonical, target);
+      write(`compile-skill ${target}: ${Object.keys(result.files).length} file(s), router ${result.report.routerChars} chars, ${result.report.dangling.length} dangling link(s) unlinked`);
+      for (const d of result.report.dangling) write(`  dangling: ${d}`);
+      if (!result.ok) { for (const e of result.report.errors) write(`  ERROR: ${e}`); return 1; }
+      writeCompiled(result, outDir);
+      write(`compile-skill: wrote ${outDir}`);
+      return 0;
+    }
+    default:
+      write(`cloudru-hub: unknown command "${cmd}"`);
+      showHelp(write);
+      return 1;
+  }
+}
+
+if (require.main === module) {
+  const rc = main(process.argv.slice(2));
+  if (rc !== null) process.exitCode = rc;
+}
+
+module.exports = { main, jsonRpcProbe };

package/src/dialects.js

@@ -0,0 +1,172 @@
+'use strict';
+// Skill dialect compiler — ADR-006: one canonical source, per-target variants are
+// GENERATED from data/dialects.json, never hand-forked. The canonical corpus is
+// UPSTREAM CONTENT and is NOT shipped in this package (ADR-001 guardrail: zero
+// upstream bytes); the compiler reads it from a directory the caller points at
+// (typically `skill/cloudru-hub/` next to the runtime-resolved engine).
+//
+// Layer-1 guarantees enforced HERE, not by reviewer judgment (ADR-006 Confirmation):
+//   - dialect: no forbidden Hermes token survives in any emitted variant (hard fail);
+//   - links:   a dangling relative .md link is UNLINKED (text kept) and counted —
+//              "инструкция указывает в пустоту" is closed for all targets at once;
+//   - size:    router ≤ routerMaxChars for lossy layouts (hard fail), reported for all;
+//   - determinism: compilation is a pure function of (canonical bytes, config) — the
+//              test compiles twice and requires byte-identity.
+
+const fs = require('fs');
+const path = require('path');
+
+const DIALECTS_FILE = path.join(__dirname, '..', 'data', 'dialects.json');
+
+function loadDialects() {
+  return JSON.parse(fs.readFileSync(DIALECTS_FILE, 'utf8'));
+}
+
+function listFiles(dir, base = dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...listFiles(full, base));
+    else out.push(path.relative(base, full));
+  }
+  return out;
+}
+
+function applyReplacements(text, replacements) {
+  let out = text;
+  for (const r of replacements) out = out.replace(new RegExp(r.find, r.flags || 'g'), r.replace);
+  return out;
+}
+
+/** Keep only `name:`/`description:` (with indented continuations) in the frontmatter —
+ *  ADR-006 Consequences: `metadata.hermes` and friends do not travel. */
+function filterFrontmatter(text) {
+  if (!text.startsWith('---\n')) return text;
+  const end = text.indexOf('\n---', 4);
+  if (end === -1) return text;
+  const head = text.slice(4, end).split('\n');
+  const kept = [];
+  let keeping = false;
+  for (const line of head) {
+    if (/^(name|description):/.test(line)) { keeping = true; kept.push(line); continue; }
+    if (/^\S/.test(line)) { keeping = false; continue; }
+    if (keeping) kept.push(line); // indented continuation of a kept key
+  }
+  return '---\n' + kept.join('\n') + text.slice(end);
+}
+
+const LINK_RE = /\[([^\]]*)\]\(([^)#\s]+[^)]*)\)/g;
+
+/** Escape a literal string for use inside a RegExp. */
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Unlink dangling relative links against the EMITTED layout; return {text, dangling[]}. */
+function resolveLinks(text, fileRel, emittedFiles) {
+  const have = new Set(emittedFiles.map((f) => f.split(path.sep).join('/')));
+  const dangling = [];
+  const out = text.replace(LINK_RE, (m, label, target) => {
+    if (/^[a-z]+:\/\//i.test(target) || target.startsWith('mailto:')) return m;
+    const clean = target.split('#')[0];
+    if (clean === '') return m;
+    const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(fileRel.split(path.sep).join('/')), clean));
+    if (have.has(resolved)) return m;
+    dangling.push(`${fileRel}: (${target})`);
+    return label; // keep the words, drop the pointer into the void
+  });
+  return { text: out, dangling };
+}
+
+/**
+ * Compile the canonical skill tree for one target.
+ * @returns {{ok:boolean, files:Record<string,string>, report:{dangling:string[],
+ *            forbidden:string[], routerChars:number, errors:string[]}}}
+ * `files` maps relative path -> emitted content (caller writes them; keeps this pure).
+ */
+function compileSkill(canonicalDir, target, config = loadDialects()) {
+  const targetCfg = config.targets[target];
+  const errors = [];
+  if (!targetCfg) {
+    return { ok: false, files: {}, report: { dangling: [], forbidden: [], routerChars: 0, errors: [`unknown dialect target "${target}" (known: ${Object.keys(config.targets).join(', ')})`] } };
+  }
+  const rels = listFiles(canonicalDir);
+  const emitted = {};
+  for (const rel of rels) {
+    const full = path.join(canonicalDir, rel);
+    if (rel.endsWith('.md')) {
+      let text = fs.readFileSync(full, 'utf8');
+      text = applyReplacements(text, targetCfg.replacements);
+      if (rel === 'SKILL.md') text = filterFrontmatter(text);
+      emitted[rel] = text;
+    } else {
+      emitted[rel] = fs.readFileSync(full, 'utf8');
+    }
+  }
+
+  // link resolution against the emitted layout
+  const emittedList = Object.keys(emitted);
+  const dangling = [];
+  for (const rel of emittedList) {
+    if (!rel.endsWith('.md')) continue;
+    const r = resolveLinks(emitted[rel], rel, emittedList);
+    emitted[rel] = r.text;
+    dangling.push(...r.dangling);
+  }
+
+  // dialect gate: forbidden tokens must be GONE (hard fail — a lying variant never ships)
+  const forbidden = [];
+  for (const rel of emittedList) {
+    if (!rel.endsWith('.md')) continue;
+    for (const token of config.forbiddenHermesTokens) {
+      if (emitted[rel].includes(token)) forbidden.push(`${rel}: "${token}"`);
+    }
+  }
+  // codename gate (2026-08-10, cross-model QE MEDIUM; token set expanded AM-2): the token
+  // DENYLIST above only catches the 8 enumerated dialect constructs — compiling the real
+  // corpus returned ok=true while the bare codename survived 5× (MEASURED). This is the
+  // POSITIVE invariant instead: NO occurrence of an engine-IDENTITY codename, in ANY case,
+  // in ANY emitted file (not just .md) — so the next unknown leak spelling is caught too.
+  // The set now covers the full engine identity: `hermes`, plus the go-module owner
+  // `dzhechko`, the CLI name `cloudru-vm-cli`, and `captainkeys` (captainkeys.go).
+  // WORD-BOUNDARY (\b…\b), not raw substring: NECESSARY because a substring `dzhechko`
+  // over-blocks the legitimately-shipped published scope `@dzhechkov` (dzhechko + v) — a
+  // must-ship token, MEASURED. Word boundaries also drop harmless false positives like
+  // "thermes"/"arithmetic" WITHOUT weakening the net against any OBSERVED real leak shape
+  // (`~/.hermes/`, `hermes-agent`, prose "Hermes", Cyrillic-suffixed `hermesовский` — all
+  // word-bounded; \b treats Cyrillic/`.`/`-`/`/` as non-word, so those still hard-fail).
+  // Trade-off: a codename embedded inside a longer ALL-Latin word (e.g. `hermesbot`) is
+  // NOT caught — but no such spelling has been observed and the compile fails LOUD at
+  // build time on the maintainer's controlled corpus. The denylist is kept for the
+  // construct-level tokens (tool_search, hermes cron, …) whose value is the precise
+  // per-construct report; the codename scan is the net under it. New legitimate upstream
+  // mentions must gain a scrub replacement in data/dialects.json — the compile fails
+  // loudly until they do (never ships a leak).
+  for (const rel of emittedList) {
+    for (const codename of config.forbiddenCodenames || []) {
+      const hits = (emitted[rel].match(new RegExp('\\b' + escapeRegExp(codename) + '\\b', 'gi')) || []).length;
+      if (hits > 0) forbidden.push(`${rel}: codename "${codename}" x${hits} (case-insensitive, word-boundary)`);
+    }
+  }
+  if (forbidden.length > 0) errors.push(`forbidden Hermes-dialect tokens survive: ${forbidden.join('; ')}`);
+
+  // size gate
+  const routerChars = (emitted['SKILL.md'] || '').length;
+  if (targetCfg.layout !== 'lossless' && routerChars > config.routerMaxChars) {
+    errors.push(`router SKILL.md is ${routerChars} chars > ${config.routerMaxChars} cap for lossy target ${target}`);
+  }
+
+  return { ok: errors.length === 0, files: emitted, report: { dangling, forbidden, routerChars, errors } };
+}
+
+/** Write a compile result to disk (only when ok). */
+function writeCompiled(result, outDir) {
+  if (!result.ok) throw new Error('refusing to write a failed compile: ' + result.report.errors.join('; '));
+  for (const [rel, content] of Object.entries(result.files)) {
+    const dest = path.join(outDir, rel);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, content);
+  }
+}
+
+module.exports = { DIALECTS_FILE, loadDialects, compileSkill, writeCompiled, filterFrontmatter, resolveLinks };