@xgent-ai/skills 0.7.5 → 0.7.7

package/skills/archify/test/animation.test.mjs

@@ -1,179 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillRoot = path.resolve(__dirname, '..');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-animation-'));
-
-const CASES = {
-  architecture: 'web-app.architecture.json',
-  workflow: 'agent-tool-call.workflow.json',
-  sequence: 'cache-miss-request.sequence.json',
-  dataflow: 'product-analytics.dataflow.json',
-  lifecycle: 'agent-run.lifecycle.json',
-};
-
-const NODE_COLLECTION = {
-  architecture: 'components',
-  workflow: 'nodes',
-  sequence: 'participants',
-  dataflow: 'nodes',
-  lifecycle: 'states',
-};
-
-function render(mode, example, animation = 'trace', visualPreset) {
-  const doc = JSON.parse(fs.readFileSync(path.join(skillRoot, 'examples', example), 'utf8'));
-  if (animation) doc.meta = { ...doc.meta, animation };
-  else delete doc.meta.animation;
-  if (visualPreset) doc.meta.visual_preset = visualPreset;
-  else if (visualPreset === null) delete doc.meta.visual_preset;
-  const suffix = `${animation || 'static'}-${visualPreset || 'default'}`;
-  const input = path.join(tmp, `${mode}-${suffix}.json`);
-  const output = path.join(tmp, `${mode}-${suffix}.html`);
-  fs.writeFileSync(input, JSON.stringify(doc));
-  execFileSync('node', [path.join(skillRoot, `renderers/${mode}/render-${mode}.mjs`), input, output], {
-    stdio: ['ignore', 'ignore', 'pipe'],
-  });
-  return fs.readFileSync(output, 'utf8');
-}
-
-function svgBlock(html) {
-  return html.match(/<svg\b[\s\S]*?<\/svg>/)?.[0] || '';
-}
-
-test('static output omits animation attributes', () => {
-  const svg = svgBlock(render('workflow', CASES.workflow, null, null));
-  assert.doesNotMatch(svg, /data-animation=/);
-  assert.doesNotMatch(svg, /data-animate=/);
-});
-
-test('classic preset remains the default for existing diagrams', () => {
-  const html = render('architecture', CASES.architecture, null, null);
-  assert.match(html, /<html lang="en" data-theme="dark" data-preset="classic">/);
-  assert.match(svgBlock(html), /data-preset="classic"/);
-});
-
-test('signal-flow preset reaches the page, SVG, and motion export surface', () => {
-  const html = render('workflow', CASES.workflow, 'trace', 'signal-flow');
-  assert.match(html, /<html lang="en" data-theme="dark" data-preset="signal-flow">/);
-  assert.match(svgBlock(html), /data-preset="signal-flow"/);
-  assert.match(html, /content: attr\(data-preset-badge-signal-flow\)/);
-  assert.match(html, /data-preset-badge-signal-flow="SIGNAL FLOW"/);
-  assert.match(html, /data-format="webm"/);
-  assert.match(html, /data-last-motion-bytes/);
-  assert.match(html, /Archify\.motion = \{ canRecord: canRecordMotion, recordWebm: recordWebm \}/);
-  assert.match(html, /recorder\.requestData\(\)/);
-  assert.match(html, /aria-label="Diagram view controls"/);
-  assert.match(html, /Archify\.focus = \(function \(\)/);
-  assert.match(html, /Archify\.view = \(function \(\)/);
-  assert.match(html, /clone\.style\.removeProperty\('transform'\)/);
-  assert.match(html, /clone\.removeAttribute\('data-view-scale'\)/);
-  assert.match(html, /data-last-export-canonical/);
-  assert.match(html, /data-last-export-error-format/);
-  assert.match(html, /data-last-export-error/);
-  assert.match(html, /WebM unavailable in this browser/);
-  assert.match(html, /Motion capture unavailable in this browser/);
-  assert.match(html, /canonicalStateClean: canonicalStateClean/);
-  assert.match(html, /recordExportReceipt\('svg', blob, d\.canonicalStateClean\)/);
-});
-
-test('webm renders an explicit time-varying canvas scene instead of replaying one cached SVG bitmap', () => {
-  const html = render('architecture', CASES.architecture, 'trace', 'signal-flow');
-  const recordBlock = html.match(/function recordWebm\(options\) \{[\s\S]*?\n      var menu =/)?.[0] || '';
-
-  assert.match(recordBlock, /var motionScene = createMotionScene\(svg\)/);
-  assert.match(recordBlock, /drawMotionFrame\(ctx, backgroundImage, motionScene, elapsed\)/);
-  assert.match(recordBlock, /getPointAtLength/);
-  assert.match(recordBlock, /performance\.now\(\)/);
-  assert.doesNotMatch(
-    recordBlock,
-    /function draw\(\) \{[\s\S]*?ctx\.drawImage\(img, 0, 0, canvas\.width, canvas\.height\);[\s\S]*?requestAnimationFrame\(draw\)/,
-  );
-});
-
-test('blueprint preset reaches every visual surface without changing the default', () => {
-  const html = render('architecture', CASES.architecture, null, 'blueprint');
-  assert.match(html, /<html lang="en" data-theme="dark" data-preset="blueprint">/);
-  assert.match(svgBlock(html), /data-preset="blueprint"/);
-  assert.match(html, /content: attr\(data-preset-badge-blueprint\)/);
-  assert.match(html, /data-preset-badge-blueprint="BLUEPRINT \/ REV 01"/);
-  assert.match(html, /\[data-preset="blueprint"\]\[data-theme="dark"\]/);
-  assert.match(html, /svg\[data-preset="blueprint"\] \.c-grid/);
-  assert.match(html, /html\[data-preset="blueprint"\] \.guided-views/);
-  assert.match(html, /html\[data-preset="blueprint"\] \.card/);
-});
-
-test('blueprint preset is accepted by all five typed renderers', () => {
-  for (const [mode, example] of Object.entries(CASES)) {
-    const html = render(mode, example, null, 'blueprint');
-    assert.match(html, /data-preset="blueprint"/, mode);
-    assert.match(svgBlock(html), /data-preset="blueprint"/, mode);
-  }
-});
-
-test('editorial preset reaches every visual surface and all five typed renderers', () => {
-  for (const [mode, example] of Object.entries(CASES)) {
-    const html = render(mode, example, null, 'editorial');
-    assert.match(html, /<html lang="en" data-theme="dark" data-preset="editorial">/, mode);
-    assert.match(svgBlock(html), /data-preset="editorial"/, mode);
-    assert.match(html, /content: attr\(data-preset-badge-editorial\)/, mode);
-    assert.match(html, /data-preset-badge-editorial="EDITORIAL \/ FIELD NOTE"/, mode);
-    assert.match(html, /content: attr\(data-preset-badge-editorial-plate\)/, mode);
-    assert.match(html, /data-preset-badge-editorial-plate="ARCHIFY \/ PLATE 04"/, mode);
-    assert.match(html, /\[data-preset="editorial"\]\[data-theme="dark"\]/, mode);
-    assert.match(html, /html\[data-preset="editorial"\] \.diagram-container/, mode);
-    assert.match(html, /svg\[data-preset="editorial"\] \.story-trail-flow/, mode);
-  }
-});
-
-test('all five renderers add one geometry-neutral semantic sigil per primary node', () => {
-  for (const [mode, example] of Object.entries(CASES)) {
-    const source = JSON.parse(fs.readFileSync(path.join(skillRoot, 'examples', example), 'utf8'));
-    const expected = source[NODE_COLLECTION[mode]].length;
-    const staticHtml = render(mode, example, null, 'classic');
-    const traceHtml = render(mode, example, 'trace', 'classic');
-    const staticSvg = svgBlock(staticHtml);
-    const traceSvg = svgBlock(traceHtml);
-    const sigils = (svg) => [...svg.matchAll(/<g aria-hidden="true" data-semantic-sigil="[^"]+"[\s\S]*?<\/g>/g)].map((match) => match[0]);
-
-    assert.equal(sigils(staticSvg).length, expected, mode);
-    assert.deepEqual(sigils(traceSvg), sigils(staticSvg), `${mode} trace must not change sigil geometry`);
-    assert.match(staticHtml, /svg \.semantic-sigil \{/i, mode);
-    assert.match(staticHtml, /svg \.s-database\s+\{ color: var\(--database-stroke\); \}/, mode);
-  }
-});
-
-test('unknown visual presets are rejected by schema validation', () => {
-  assert.throws(
-    () => render('architecture', CASES.architecture, null, 'hologram'),
-    /visual_preset/,
-  );
-});
-
-for (const [mode, example] of Object.entries(CASES)) {
-  test(`${mode}: trace animation annotates svg, edges, and nodes`, () => {
-    const svg = svgBlock(render(mode, example));
-    assert.match(svg, /<svg[^>]+data-animation="trace"/);
-    assert.match(svg, /data-animate="edge" style="--step:0"/);
-    assert.match(svg, /data-animate="node" style="--step:0"/);
-    assert.match(svg, /aria-labelledby="archify-diagram-title archify-diagram-description"/);
-    assert.match(svg, /<title id="archify-diagram-title">[^<]+<\/title>/);
-    assert.match(svg, /<desc id="archify-diagram-description">[^<]+<\/desc>/);
-    assert.match(svg, /id="node-[^"]+" data-node-id="[^"]+"[^>]+role="button"[^>]+aria-pressed="false"/);
-    assert.match(svg, /data-edge-from="[^"]+" data-edge-to="[^"]+"/);
-  });
-}
-
-test('semantic SVG identity is deterministic for unchanged input', () => {
-  const first = svgBlock(render('workflow', CASES.workflow));
-  const second = svgBlock(render('workflow', CASES.workflow));
-  const hooks = (svg) => [...svg.matchAll(/(?:id="node-|data-edge-from=")[^>]+/g)].map((match) => match[0]);
-  assert.deepEqual(hooks(first), hooks(second));
-});
-
-process.on('exit', () => fs.rmSync(tmp, { recursive: true, force: true }));

package/skills/archify/test/architecture-compare-recovery.test.mjs

@@ -1,157 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const skillRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const cli = path.join(skillRoot, 'bin/archify.mjs');
-const base = path.join(skillRoot, 'examples/checkout-platform.base.architecture.json');
-const head = path.join(skillRoot, 'examples/checkout-platform.head.architecture.json');
-const hash = (bytes) => createHash('sha256').update(bytes).digest('hex');
-const cases = [
-  { name: 'successful replacement cleans staging', failures: [] },
-  { name: 'receipt commit failure restores the entire old pair', failures: ['commit-receipt'] },
-  { name: 'HTML restore failure retains its old backup', failures: ['commit-receipt', 'restore-html'], retained: ['html'] },
-  { name: 'receipt restore failure retains its old backup', failures: ['commit-receipt', 'restore-receipt'], retained: ['receipt'] },
-  { name: 'both restore failures retain both old backups', failures: ['commit-receipt', 'restore-receipt', 'restore-html'], retained: ['html', 'receipt'] },
-  { name: 'second backup failure restores the first target', failures: ['backup-receipt'] },
-  { name: 'second backup and HTML restore failures retain only HTML', failures: ['backup-receipt', 'restore-html'], retained: ['html'] },
-  { name: 'transient removal failure leaves no backup after successful restoration', failures: ['commit-receipt', 'remove-html'] },
-];
-
-function fixture(t) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-compare-recovery-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const targets = { html: path.join(root, 'review.html'), receipt: path.join(root, 'review.receipt.json') };
-  const run = (preload, newHead = head, json = true) => spawnSync(process.execPath, [
-    ...(preload ? ['--require', preload] : []), cli, 'compare', 'architecture', base, newHead,
-    targets.html, '--receipt', targets.receipt, ...(json ? ['--json'] : []),
-  ], { cwd: skillRoot, encoding: 'utf8', timeout: 30000 });
-  // Establish a genuinely valid old pair, distinct from the candidate revision.
-  const initial = run(undefined, base);
-  assert.ifError(initial.error);
-  assert.equal(initial.status, 0, initial.stderr || initial.stdout);
-  const old = Object.fromEntries(Object.entries(targets).map(([key, file]) => [key, fs.readFileSync(file)]));
-  assert.equal(JSON.parse(old.receipt).artifact.sha256, hash(old.html));
-  return { root, targets, old, run };
-}
-
-test('compare recovery: human diagnostics identify the retained backup and target', { timeout: 70000 }, (t) => {
-  const data = fixture(t);
-  const { preload } = inject(data, ['commit-receipt', 'restore-html']);
-  const result = data.run(preload, head, false);
-  assert.ifError(result.error);
-  assert.equal(result.status, 1);
-  assert.equal(result.stdout.trim(), '');
-  const directories = fs.readdirSync(data.root).filter((name) => name.startsWith('.archify-compare-'));
-  assert.equal(directories.length, 1);
-  const recoveryDirectory = path.join(data.root, directories[0]);
-  const backup = path.join(recoveryDirectory, '.previous-output');
-  assert.ok(result.stderr.includes(recoveryDirectory));
-  assert.ok(result.stderr.includes(JSON.stringify(backup)));
-  assert.ok(result.stderr.includes(JSON.stringify(data.targets.html)));
-  assert.deepEqual(fs.readFileSync(backup), data.old.html);
-});
-
-function inject(data, failures) {
-  const preload = path.join(data.root, 'fail-compare-commit.cjs');
-  const log = path.join(data.root, 'injected.jsonl');
-  fs.writeFileSync(preload, `
-    const fs = require('node:fs');
-    const path = require('node:path');
-    const root = ${JSON.stringify(data.root)};
-    const targets = ${JSON.stringify(data.targets)};
-    const wanted = new Set(${JSON.stringify(failures)});
-    const fired = new Set();
-    const rename = fs.renameSync;
-    const remove = fs.rmSync;
-    const inside = value => typeof value === 'string' && value.startsWith(root + path.sep);
-    const staging = value => inside(value) && path.basename(path.dirname(value)).startsWith('.archify-compare-');
-    function failOnce(action) {
-      if (!wanted.has(action) || fired.has(action)) return;
-      fired.add(action);
-      fs.appendFileSync(${JSON.stringify(log)}, JSON.stringify(action) + '\\n');
-      const error = new Error('injected ' + action);
-      error.code = 'EACCES';
-      throw error;
-    }
-    fs.renameSync = function(source, target) {
-      if (inside(source) && inside(target)) {
-        if (source === targets.receipt && staging(target)) failOnce('backup-receipt');
-        if (staging(source) && target === targets.receipt && path.basename(source) === path.basename(target)) failOnce('commit-receipt');
-        if (staging(source) && path.basename(source) === '.previous-output' && target === targets.html) failOnce('restore-html');
-        if (staging(source) && path.basename(source) === '.previous-receipt' && target === targets.receipt) failOnce('restore-receipt');
-      }
-      return rename.apply(this, arguments);
-    };
-    fs.rmSync = function(target) {
-      if (target === targets.html && fired.has('commit-receipt')) failOnce('remove-html');
-      return remove.apply(this, arguments);
-    };
-  `);
-  return { preload, log };
-}
-
-for (const scenario of cases) {
-  test(`compare recovery: ${scenario.name}`, { timeout: 70000 }, (t) => {
-    const data = fixture(t);
-    const { preload, log } = inject(data, scenario.failures);
-    const result = data.run(preload);
-    assert.ifError(result.error);
-    const observed = fs.existsSync(log) ? fs.readFileSync(log, 'utf8').trim().split('\n').map(JSON.parse) : [];
-    assert.deepEqual(observed.sort(), [...scenario.failures].sort(), 'every requested fault must fire exactly once');
-    const staging = fs.readdirSync(data.root).filter((name) => name.startsWith('.archify-compare-'));
-    const response = JSON.parse(result.stdout);
-    if (!scenario.failures.length) {
-      assert.equal(result.status, 0, result.stderr || result.stdout);
-      assert.equal(response.ok, true);
-      const nextHtml = fs.readFileSync(data.targets.html);
-      assert.notEqual(hash(nextHtml), hash(data.old.html));
-      assert.equal(JSON.parse(fs.readFileSync(data.targets.receipt, 'utf8')).artifact.sha256, hash(nextHtml));
-      assert.deepEqual(staging, []);
-      return;
-    }
-
-    assert.notEqual(result.status, 0);
-    assert.equal(response.ok, false);
-    assert.equal(response.stage, 'commit');
-    const retained = scenario.retained || [];
-    const incompleteRollback = retained.length > 0 || scenario.failures.includes('remove-html');
-    const diagnostic = response.diagnostics[0];
-    assert.equal(diagnostic.code, incompleteRollback ? 'delta/commit-rollback-failed' : 'delta/commit-failed');
-    const evidence = diagnostic.evidence;
-    for (const key of ['html', 'receipt'].filter((key) => !retained.includes(key))) {
-      const restored = fs.readFileSync(data.targets[key]);
-      assert.deepEqual(restored, data.old[key], `${key} must be restored byte-for-byte`);
-      assert.equal(hash(restored), hash(data.old[key]));
-    }
-    if (!retained.length) {
-      assert.deepEqual(staging, [], 'clean up when no recovery material remains');
-      assert.equal(evidence.recoveryDirectory, undefined);
-      assert.deepEqual(evidence.recoveryFiles || [], []);
-      return;
-    }
-
-    assert.equal(typeof evidence.recoveryDirectory, 'string', 'report the surviving recovery directory');
-    assert.ok(path.isAbsolute(evidence.recoveryDirectory));
-    assert.equal(path.dirname(evidence.recoveryDirectory), data.root);
-    assert.deepEqual(staging, [path.basename(evidence.recoveryDirectory)]);
-    assert.ok(response.error.includes(evidence.recoveryDirectory), 'human-readable error must identify recovery location');
-    assert.ok(Array.isArray(evidence.recoveryFiles));
-    assert.equal(evidence.recoveryFiles.length, retained.length);
-    assert.deepEqual(evidence.recoveryFiles.map(({ target }) => target).sort(), retained.map((key) => data.targets[key]).sort());
-    for (const { backup, target } of evidence.recoveryFiles) {
-      assert.ok(path.isAbsolute(backup));
-      assert.equal(path.dirname(backup), evidence.recoveryDirectory);
-      const key = Object.keys(data.targets).find((key) => data.targets[key] === target);
-      const saved = fs.readFileSync(backup);
-      assert.deepEqual(saved, data.old[key], `${key} backup must remain recoverable byte-for-byte`);
-      assert.equal(hash(saved), hash(data.old[key]));
-      assert.equal(fs.existsSync(target), false, 'failed restoration must not be reported as a committed target');
-    }
-  });
-}

package/skills/archify/test/architecture-delta-markers.test.mjs

@@ -1,137 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { parse, serializeOuter } from 'parse5';
-
-const skillRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const variants = ['default', 'emphasis', 'security', 'dashed'];
-const attr = (node, name) => node.attrs?.find((entry) => entry.name === name)?.value;
-function descendants(node) {
-  return [node, ...(node.childNodes || []).flatMap(descendants)];
-}
-function svgIn(document) {
-  const svg = descendants(document).find((node) => node.tagName === 'svg');
-  assert.ok(svg, 'expected an SVG');
-  return svg;
-}
-function edgePaths(svg) {
-  return descendants(svg).filter((node) => node.tagName === 'path' && attr(node, 'data-edge-id'));
-}
-function markerId(node) {
-  const value = attr(node, 'marker-end');
-  assert.match(value || '', /^url\(#[^)]+\)$/);
-  return value.slice(5, -1);
-}
-function markerMap(svg) {
-  return new Map(descendants(svg).filter((node) => node.tagName === 'marker').map((node) => [attr(node, 'id'), node]));
-}
-function assertResolved(svg) {
-  const nodes = descendants(svg);
-  const ids = nodes.map((node) => attr(node, 'id')).filter(Boolean);
-  assert.equal(new Set(ids).size, ids.length, 'SVG IDs must be unique');
-  const markers = markerMap(svg);
-  const missing = [];
-  for (const node of nodes) {
-    for (const name of ['marker-start', 'marker-mid', 'marker-end']) {
-      const value = attr(node, name);
-      if (!value) continue;
-      const match = value.match(/^url\(#([^)]+)\)$/);
-      assert.ok(match, `expected a local marker reference: ${value}`);
-      if (!markers.has(match[1])) missing.push(`${attr(node, 'data-edge-id') || node.tagName}: ${match[1]}`);
-    }
-  }
-  assert.deepEqual(missing, [], 'every arrowhead must resolve within its own SVG');
-}
-function markerShape(marker) {
-  // Compare geometry and paint semantics independently of namespaced IDs.
-  return serializeOuter(marker).replace(/\sid="[^"]+"/, '');
-}
-function compare(t, base, head) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-delta-markers-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const inputs = [base, head].map((value, index) => {
-    if (typeof value === 'string') return value;
-    const file = path.join(root, `${index}.json`);
-    fs.writeFileSync(file, JSON.stringify(value));
-    return file;
-  });
-  const output = path.join(root, 'delta.html');
-  const result = spawnSync(process.execPath, [
-    path.join(skillRoot, 'bin/archify.mjs'), 'compare', 'architecture', ...inputs,
-    output, '--quality', 'standard', '--json',
-  ], { cwd: skillRoot, encoding: 'utf8', timeout: 30000 });
-  assert.ifError(result.error);
-  assert.equal(result.status, 0, result.stderr || result.stdout);
-  const html = fs.readFileSync(output, 'utf8');
-  const document = parse(html);
-  const section = descendants(document).find((node) => node.tagName === 'section' && attr(node, 'data-view') === 'delta');
-  assert.ok(section);
-  const frames = descendants(document).filter((node) => node.tagName === 'iframe');
-  assert.equal(frames.length, 2);
-  const snapshots = frames.map((frame) => svgIn(parse(attr(frame, 'srcdoc'))));
-  snapshots.forEach(assertResolved);
-  return { html, delta: svgIn(section), base: snapshots[0], head: snapshots[1] };
-}
-function assertPreserved(artifact, expectedOld) {
-  const paths = edgePaths(artifact.delta);
-  const oldPaths = paths.filter((node) => ['removed', 'moved-from'].includes(attr(node, 'data-delta-state')));
-  assert.equal(oldPaths.length, expectedOld);
-  for (const side of ['base', 'head']) {
-    const sourcePaths = edgePaths(artifact[side]);
-    const sourceMarkers = markerMap(artifact[side]);
-    const candidates = side === 'base' ? oldPaths : paths.filter((node) => !oldPaths.includes(node));
-    for (const candidate of candidates) {
-      const original = sourcePaths.find((node) => attr(node, 'data-edge-id') === attr(candidate, 'data-edge-id'));
-      assert.ok(original, 'Delta path must correspond to its source snapshot');
-      assert.equal(attr(candidate, 'd'), attr(original, 'd'), 'authored path geometry must survive composition');
-      assert.equal(attr(candidate, 'data-composition-points'), attr(original, 'data-composition-points'));
-      const marker = markerMap(artifact.delta).get(markerId(candidate));
-      assert.ok(marker, `${side} edge ${attr(candidate, 'data-edge-id')} has no arrowhead definition`);
-      assert.equal(markerShape(marker), markerShape(sourceMarkers.get(markerId(original))), `${side} arrowhead variant changed`);
-    }
-  }
-}
-
-test('checkout compare resolves all three baseline arrowheads and keeps snapshot markers', { timeout: 40000 }, (t) => {
-  const artifact = compare(t,
-    path.join(skillRoot, 'examples/checkout-platform.base.architecture.json'),
-    path.join(skillRoot, 'examples/checkout-platform.head.architecture.json'));
-  assertResolved(artifact.delta);
-  assertPreserved(artifact, 3);
-});
-
-function variantFixture(operation) {
-  const base = { schema_version: 1, diagram_type: 'architecture', meta: { title: 'Marker variants' }, components: [], connections: [] };
-  for (const [index, variant] of variants.entries()) {
-    const y = 100 + index * 260;
-    for (const [column, suffix] of ['a', 'b', 'c'].entries()) {
-      base.components.push({ id: `${variant}-${suffix}`, type: 'backend', label: `${variant} ${suffix}`, pos: [100 + column * 300, y], size: [140, 60] });
-    }
-    base.connections.push({ id: variant, from: `${variant}-a`, to: `${variant}-b`, variant });
-  }
-  const head = structuredClone(base);
-  if (operation === 'removed') head.connections = [];
-  else head.connections.forEach((edge, index) => {
-    const y = 200 + index * 260;
-    if (operation === 'topology') edge.to = `${edge.id}-c`;
-    edge.fromSide = 'bottom';
-    edge.toSide = 'bottom';
-    edge.via = [[170, y], [operation === 'topology' ? 770 : 470, y]];
-  });
-  return [base, head];
-}
-
-for (const operation of ['removed', 'rerouted', 'topology']) {
-  test(`compare preserves all four marker variants for ${operation} relationships`, { timeout: 40000 }, (t) => {
-    const artifact = compare(t, ...variantFixture(operation));
-    assertResolved(artifact.delta);
-    assertPreserved(artifact, 4);
-    const old = edgePaths(artifact.delta).filter((node) => ['removed', 'moved-from'].includes(attr(node, 'data-delta-state')));
-    assert.deepEqual(old.map((node) => attr(node, 'data-edge-id')).sort(), [...variants].sort());
-    assert.ok(old.every((node) => attr(node, 'data-delta-state') === (operation === 'rerouted' ? 'moved-from' : 'removed')));
-  });
-}