create-yss-spec 3.3.1 → 3.3.3

package/template/.trae/skills/archify/test/engineering-profile.test.mjs

@@ -1,209 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import {
-  deploymentOwnershipDiagnostics,
-  validateEngineeringProfile,
-} from '../renderers/shared/engineering-profiles.mjs';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillRoot = path.resolve(__dirname, '..');
-const cli = path.join(skillRoot, 'bin', 'archify.mjs');
-const examplePath = path.join(skillRoot, 'examples', 'production-deployment.architecture.json');
-const example = JSON.parse(fs.readFileSync(examplePath, 'utf8'));
-
-function clone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function validateJson(input, output) {
-  return spawnSync(process.execPath, [cli, 'validate', 'architecture', input, '--json'], {
-    cwd: path.dirname(output),
-    encoding: 'utf8',
-  });
-}
-
-test('deployment ownership profile passes the checked production example and stays opt-in', () => {
-  assert.equal(example.meta.engineering_profile, 'deployment-ownership');
-  assert.deepEqual(deploymentOwnershipDiagnostics(example), []);
-  assert.doesNotThrow(() => validateEngineeringProfile('architecture', example));
-
-  const ordinary = clone(example);
-  delete ordinary.meta.engineering_profile;
-  ordinary.boundaries = [];
-  ordinary.components.forEach((component) => { delete component.tag; });
-  assert.doesNotThrow(() => validateEngineeringProfile('architecture', ordinary));
-});
-
-test('deployment ownership profile reports exact owners, scopes, state, and crossing mechanisms', () => {
-  const candidate = clone(example);
-  delete candidate.components.find((component) => component.id === 'edge').tag;
-  candidate.boundaries.find((boundary) => boundary.label.includes('us-east-1')).wraps =
-    candidate.boundaries.find((boundary) => boundary.label.includes('us-east-1')).wraps.filter((id) => id !== 'edge');
-  candidate.boundaries.find((boundary) => boundary.label === 'private application network').wraps =
-    candidate.boundaries.find((boundary) => boundary.label === 'private application network').wraps.filter((id) => id !== 'redis');
-  const crossing = candidate.connections.find((connection) => connection.from === 'gateway' && connection.to === 'api_a');
-  crossing.label = '';
-
-  const diagnostics = deploymentOwnershipDiagnostics(candidate);
-  const codes = new Set(diagnostics.map((entry) => entry.code));
-  assert.ok(codes.has('engineering/deployment-owner-missing'));
-  assert.ok(codes.has('engineering/deployment-region-scope'));
-  assert.ok(codes.has('engineering/deployment-private-state'));
-  assert.ok(codes.has('engineering/deployment-crossing-mechanism'));
-
-  const boundaryDiagnostic = diagnostics.find((entry) => entry.code === 'engineering/deployment-crossing-mechanism');
-  assert.equal(boundaryDiagnostic.subject.collection, 'connections');
-  assert.equal(boundaryDiagnostic.evidence.from, 'gateway');
-  assert.equal(boundaryDiagnostic.evidence.to, 'api_a');
-  assert.ok(boundaryDiagnostic.evidence.crossedBoundaries.some((boundary) => boundary.kind === 'security-group'));
-  assert.deepEqual(boundaryDiagnostic.supportedFixes, [
-    `set /connections/${boundaryDiagnostic.subject.index}/label to the real cross-boundary mechanism`,
-  ]);
-});
-
-test('deployment ownership profile requires both region and private boundary kinds', () => {
-  const candidate = clone(example);
-  candidate.boundaries = candidate.boundaries.filter((boundary) => boundary.kind === 'region');
-  const diagnostics = deploymentOwnershipDiagnostics(candidate);
-  assert.ok(diagnostics.some((entry) => entry.code === 'engineering/deployment-boundary-kind'
-    && entry.evidence.requiredKind === 'security-group'));
-});
-
-test('deployment ownership profile rejects ambiguous regions and cross-region private groups', () => {
-  const candidate = clone(example);
-  const secondRegion = candidate.boundaries.find((boundary) => boundary.label.includes('eu-west-1'));
-  secondRegion.wraps.push('api_a');
-  const diagnostics = deploymentOwnershipDiagnostics(candidate);
-  assert.ok(diagnostics.some((entry) => entry.code === 'engineering/deployment-region-ambiguous'
-    && entry.subject.id === 'api_a'));
-  assert.ok(diagnostics.some((entry) => entry.code === 'engineering/deployment-private-region-consistency'
-    && entry.subject.collection === 'boundaries'));
-});
-
-test('deployment ownership crossing math follows authored membership instead of geometry or labels', () => {
-  const cases = [
-    ['outside to region', 'clients', 'edge'],
-    ['region to region', 'postgres', 'replica'],
-    ['public to private', 'gateway', 'api_a'],
-    ['private to public', 'worker', 'audit'],
-  ];
-  for (const [name, from, to] of cases) {
-    const candidate = clone(example);
-    candidate.connections.forEach((connection) => {
-      connection.label ||= 'same-scope relation';
-    });
-    const connection = candidate.connections.find((entry) => entry.from === from && entry.to === to);
-    connection.label = '';
-    const crossings = deploymentOwnershipDiagnostics(candidate)
-      .filter((diagnostic) => diagnostic.code === 'engineering/deployment-crossing-mechanism');
-    assert.equal(crossings.length, 1, name);
-    assert.equal(crossings[0].evidence.from, from, name);
-    assert.equal(crossings[0].evidence.to, to, name);
-  }
-
-  const sameScope = clone(example);
-  sameScope.connections.forEach((connection) => {
-    connection.label ||= 'same-scope relation';
-  });
-  sameScope.connections.find((connection) => connection.from === 'api_a' && connection.to === 'redis').label = '';
-  sameScope.connections.push({ from: 'api_a', to: 'api_a', label: '' });
-  assert.ok(!deploymentOwnershipDiagnostics(sameScope)
-    .some((diagnostic) => diagnostic.code === 'engineering/deployment-crossing-mechanism'));
-});
-
-test('other diagram modes reject the architecture-only engineering profile', () => {
-  const fixtures = [
-    ['workflow', 'agent-tool-call.workflow.json'],
-    ['sequence', 'cache-miss-request.sequence.json'],
-    ['dataflow', 'product-analytics.dataflow.json'],
-    ['lifecycle', 'agent-run.lifecycle.json'],
-  ];
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-engineering-schema-'));
-  try {
-    for (const [mode, fixture] of fixtures) {
-      const candidate = JSON.parse(fs.readFileSync(path.join(skillRoot, 'examples', fixture), 'utf8'));
-      candidate.meta.engineering_profile = 'deployment-ownership';
-      const input = path.join(tmp, `${mode}.json`);
-      fs.writeFileSync(input, JSON.stringify(candidate));
-      const result = spawnSync(process.execPath, [cli, 'validate', mode, input, '--json'], {
-        cwd: tmp,
-        encoding: 'utf8',
-      });
-      assert.notEqual(result.status, 0, mode);
-      const receipt = JSON.parse(result.stdout);
-      assert.ok(receipt.diagnostics.some((diagnostic) => diagnostic.code === 'schema/additionalProperties'), mode);
-    }
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test('validate and deliver expose one truthful engineering-profile receipt', () => {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-engineering-profile-'));
-  try {
-    const invalidPath = path.join(tmp, 'invalid.architecture.json');
-    const invalid = clone(example);
-    const crossing = invalid.connections.find((connection) => connection.from === 'gateway' && connection.to === 'api_a');
-    crossing.label = '';
-    fs.writeFileSync(invalidPath, JSON.stringify(invalid, null, 2));
-
-    const preservedOutput = path.join(tmp, 'preserved.html');
-    const preservedBytes = Buffer.from('last known good deployment');
-    fs.writeFileSync(preservedOutput, preservedBytes);
-    const failedDelivery = spawnSync(process.execPath, [
-      cli, 'deliver', 'architecture', invalidPath, preservedOutput, '--json',
-    ], { cwd: tmp, encoding: 'utf8' });
-    assert.notEqual(failedDelivery.status, 0);
-    assert.equal(fs.readFileSync(preservedOutput).equals(preservedBytes), true);
-
-    const failed = validateJson(invalidPath, path.join(tmp, 'unused.html'));
-    assert.notEqual(failed.status, 0);
-    assert.equal(failed.stderr, '');
-    const failure = JSON.parse(failed.stdout);
-    assert.equal(failure.ok, false);
-    assert.equal(failure.stage, 'render');
-    assert.ok(failure.diagnostics.some((entry) => entry.code === 'engineering/deployment-crossing-mechanism'));
-
-    const validated = spawnSync(process.execPath, [cli, 'validate', 'architecture', examplePath, '--json'], {
-      cwd: tmp,
-      encoding: 'utf8',
-    });
-    assert.equal(validated.status, 0, validated.stderr);
-    assert.equal(JSON.parse(validated.stdout).engineeringProfile, 'deployment-ownership');
-
-    const output = path.join(tmp, 'deployment.html');
-    const delivered = spawnSync(process.execPath, [cli, 'deliver', 'architecture', examplePath, output, '--json'], {
-      cwd: tmp,
-      encoding: 'utf8',
-    });
-    assert.equal(delivered.status, 0, delivered.stderr);
-    const receipt = JSON.parse(delivered.stdout);
-    assert.equal(receipt.validation.engineeringProfile, 'deployment-ownership');
-    assert.match(fs.readFileSync(output, 'utf8'), /data-engineering-profile="deployment-ownership"/);
-
-    const secondOutput = path.join(tmp, 'deployment-second.html');
-    const repeated = spawnSync(process.execPath, [
-      cli, 'deliver', 'architecture', examplePath, secondOutput, '--json',
-    ], { cwd: tmp, encoding: 'utf8' });
-    assert.equal(repeated.status, 0, repeated.stderr);
-    const digest = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
-    assert.equal(digest(output), digest(secondOutput));
-
-    const ordinaryInput = path.join(skillRoot, 'examples', 'web-app.architecture.json');
-    const ordinaryOutput = path.join(tmp, 'ordinary.html');
-    const ordinary = spawnSync(process.execPath, [
-      cli, 'render', 'architecture', ordinaryInput, ordinaryOutput,
-    ], { cwd: tmp, encoding: 'utf8' });
-    assert.equal(ordinary.status, 0, ordinary.stderr);
-    assert.doesNotMatch(fs.readFileSync(ordinaryOutput, 'utf8'), /data-engineering-profile=/);
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
-});

package/template/.trae/skills/archify/test/finder.test.mjs

@@ -1,104 +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-finder-'));
-
-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',
-};
-
-function render(mode, example) {
-  const output = path.join(tmp, `${mode}.html`);
-  execFileSync(process.execPath, [
-    path.join(skillRoot, `renderers/${mode}/render-${mode}.mjs`),
-    path.join(skillRoot, 'examples', example),
-    output,
-  ]);
-  return fs.readFileSync(output, 'utf8');
-}
-
-function svg(html) {
-  return html.match(/<svg\b[\s\S]*?<\/svg>/)?.[0] || '';
-}
-
-test('all typed renderers ship the same geometry-neutral node finder', () => {
-  for (const [mode, example] of Object.entries(CASES)) {
-    const html = render(mode, example);
-    assert.match(html, /id="btn-node-finder"[^>]+aria-label="Find a node"[^>]+aria-haspopup="dialog"/, mode);
-    assert.match(html, /id="node-finder" hidden role="dialog" aria-modal="false"/, mode);
-    assert.match(html, /id="node-finder-input" type="search"/, mode);
-    assert.match(html, /Archify\.finder = \(function \(\)/, mode);
-    assert.match(html, /svg\.querySelectorAll\('\[data-node-id\]'\)/, mode);
-    assert.doesNotMatch(svg(html), /node-finder|Archify\.finder|Find a node/, mode);
-  }
-});
-
-test('finder searches semantic ids and labels, then delegates to focus and reveal', () => {
-  const html = render('architecture', CASES.architecture);
-  assert.match(html, /search: \(id \+ ' ' \+ label \+ ' ' \+ type \+ ' ' \+ sublabel \+ ' ' \+ context \+ ' ' \+ tag \+ ' ' \+ sourceSearch \+ ' ' \+ text\)\.toLowerCase\(\)/);
-  assert.match(html, /item\.search\.indexOf\(query\) !== -1/);
-  assert.match(html, /Archify\.guidedViews\.showAll\(\{ clearFocus: false, updateUrl: false \}\)/);
-  assert.match(html, /Archify\.view\.reset\(\{ automatic: true \}\)/);
-  assert.match(html, /Archify\.focus\.set\(id, \{ toggle: false \}\)/);
-  assert.match(html, /Archify\.view\.reveal\(\[id\], \{ includeNeighbors: true, reason: 'finder' \}\)/);
-  assert.match(html, /item\.node\.focus\(\{ preventScroll: true \}\)/);
-  assert.match(html, /var key = from \+ '\\u0000' \+ to/);
-});
-
-test('finder presents one focused search control and a structured result list', () => {
-  const html = render('architecture', CASES.architecture);
-  assert.match(html, /id="node-finder-input"[^>]+aria-label="Search diagram nodes"/);
-  assert.match(html, /\.node-finder-search:focus-within\s*\{/);
-  assert.match(html, /\.node-finder-input:focus-visible\s*\{\s*outline:\s*none;/);
-  assert.match(html, /\.node-finder\s*\{[\s\S]*?display:\s*flex;[\s\S]*?max-height:\s*calc\(100% - 2rem\);/);
-  assert.match(html, /\.node-finder-results\s*\{[\s\S]*?flex:\s*1 1 auto;[\s\S]*?min-height:\s*0;/);
-  assert.match(html, /\.node-finder-result:not\(:last-child\)\s*\{/);
-  assert.match(html, /context\.kind === 'focus'\s*\? viewerCount\('viewer\.finder\.link', item\.links\)/);
-  assert.match(html, /\[viewerKindLabel\(item\.type\), item\.id, item\.sublabel, item\.tag\]/);
-  assert.doesNotMatch(html, /\[item\.type, item\.context, item\.sublabel, item\.tag, item\.id\]/);
-  assert.match(html, /viewerText\('viewer\.finder\.status\.filtered'/);
-});
-
-test('finder becomes a contextual Route Probe endpoint picker without changing semantic focus', () => {
-  const html = render('workflow', CASES.workflow);
-  assert.match(html, /function resolveContext\(options\)/);
-  assert.match(html, /Archify\.routeProbe\.finderContext\(\)/);
-  assert.match(html, /context\.allowedIds\.indexOf\(item\.id\) !== -1/);
-  assert.match(html, /context\.kind === 'route-source' \|\| context\.kind === 'route-target'/);
-  assert.match(html, /Archify\.routeProbe\.choose\(id\)/);
-  assert.match(html, /reason: 'route-pick'/);
-  assert.match(html, /data-context="route-source"/);
-  assert.match(html, /data-context="route-target"/);
-  assert.match(html, /viewerText\('viewer\.finder\.result\.routeTarget'/);
-  assert.match(html, /links: badge/);
-  assert.match(html, /viewerText\('viewer\.finder\.status\.all'/);
-});
-
-test('finder is keyboard accessible, mobile-pinned, and subordinate to embed mode', () => {
-  const html = render('workflow', CASES.workflow);
-  assert.match(html, /e\.key === '\/'/);
-  assert.match(html, /Archify\.finder\.open\(\)/);
-  assert.match(html, /event\.key === 'ArrowDown'/);
-  assert.match(html, /event\.key === 'ArrowUp'/);
-  assert.match(html, /event\.key === 'Escape'/);
-  assert.match(html, /event\.stopPropagation\(\)/);
-  assert.match(html, /Archify\.exportMenu\.isOpen\(\)\) Archify\.exportMenu\.close\(false\)/);
-  assert.match(html, /data-wide-diagram="true"\] \.node-finder/);
-  assert.match(html, /html\[data-embed="true"\] \.node-finder/);
-  assert.match(html, /html\.getAttribute\('data-embed'\) === 'true'/);
-  assert.match(html, /data-node-finder-trigger/);
-  assert.match(html, /!event\.target\.closest\('\[data-node-finder-trigger\]'\)/);
-});
-
-process.on('exit', () => fs.rmSync(tmp, { recursive: true, force: true }));

package/template/.trae/skills/archify/test/fixtures/automatic-routing-node-border-clearance.workflow.json

@@ -1,40 +0,0 @@
-{
-  "schema_version": 1,
-  "diagram_type": "workflow",
-  "meta": {
-    "title": "自动连线节点边框避让回归",
-    "quality_profile": "showcase",
-    "viewBox": [720, 360]
-  },
-  "lanes": [
-    { "id": "orchestrator", "label": "Orchestrator PTY" },
-    { "id": "runtime", "label": "Hive Runtime" }
-  ],
-  "nodes": [
-    {
-      "id": "team_send",
-      "lane": "orchestrator",
-      "col": 2,
-      "type": "backend",
-      "label": "team send 派单",
-      "sublabel": "选择目标 Worker"
-    },
-    {
-      "id": "inject",
-      "lane": "runtime",
-      "col": 1,
-      "type": "security",
-      "label": "校验并注入输入",
-      "sublabel": "UI token → PTY stdin"
-    }
-  ],
-  "edges": [
-    {
-      "id": "stdin",
-      "from": "inject",
-      "to": "team_send",
-      "label": "PTY stdin",
-      "variant": "emphasis"
-    }
-  ]
-}

package/template/.trae/skills/archify/test/fixtures/fail-migration-cleanup.mjs

@@ -1,17 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-const originalRmSync = fs.rmSync.bind(fs);
-let injectedFailure = false;
-
-fs.rmSync = function failMigrationCleanupOnce(target, options) {
-  const isMigrationStagingDirectory = path.basename(String(target)).startsWith('.archify-migration-');
-  if (!injectedFailure && isMigrationStagingDirectory) {
-    injectedFailure = true;
-    originalRmSync(target, options);
-    const error = new Error('simulated migration cleanup failure');
-    error.code = 'EPERM';
-    throw error;
-  }
-  return originalRmSync(target, options);
-};

package/template/.trae/skills/archify/test/fixtures/issue-126/custom-widths.workflow.json

@@ -1,18 +0,0 @@
-{
-  "schema_version": 2,
-  "diagram_type": "workflow",
-  "meta": {
-    "title": "Sanitized custom widths",
-    "legend": { "mode": "hidden" }
-  },
-  "lanes": [
-    { "id": "main", "label": "Main flow" }
-  ],
-  "nodes": [
-    { "id": "compact", "lane": "main", "col": 1, "type": "frontend", "label": "In", "width": 32 },
-    { "id": "wide", "lane": "main", "col": 2, "type": "database", "label": "Sanitized downstream service", "width": 240 }
-  ],
-  "edges": [
-    { "id": "compact-wide", "from": "compact", "to": "wide" }
-  ]
-}

package/template/.trae/skills/archify/test/fixtures/issue-126/explicit-route.workflow.json

@@ -1,28 +0,0 @@
-{
-  "schema_version": 2,
-  "diagram_type": "workflow",
-  "meta": {
-    "title": "Sanitized explicit route",
-    "viewBox": [900, 420],
-    "legend": { "mode": "hidden" }
-  },
-  "lanes": [
-    { "id": "source", "label": "Source" },
-    { "id": "target", "label": "Target" }
-  ],
-  "nodes": [
-    { "id": "producer", "lane": "source", "col": 1, "type": "backend", "label": "Producer" },
-    { "id": "consumer", "lane": "target", "col": 1, "type": "backend", "label": "Consumer" }
-  ],
-  "edges": [
-    {
-      "id": "producer-consumer",
-      "from": "producer",
-      "to": "consumer",
-      "fromSide": "right",
-      "toSide": "right",
-      "route": "outside-right",
-      "channelX": 720
-    }
-  ]
-}

package/template/.trae/skills/archify/test/fixtures/issue-126/explicit-viewbox.workflow.json

@@ -1,19 +0,0 @@
-{
-  "schema_version": 2,
-  "diagram_type": "workflow",
-  "meta": {
-    "title": "Sanitized explicit viewBox",
-    "viewBox": [1600, 520],
-    "legend": { "mode": "hidden" }
-  },
-  "lanes": [
-    { "id": "main", "label": "Main flow" }
-  ],
-  "nodes": [
-    { "id": "start", "lane": "main", "col": 0, "type": "frontend", "label": "Start" },
-    { "id": "finish", "lane": "main", "col": 5, "type": "backend", "label": "Finish" }
-  ],
-  "edges": [
-    { "id": "start-finish", "from": "start", "to": "finish", "label": "complete" }
-  ]
-}

package/template/.trae/skills/archify/test/fixtures/issue-126/labels.workflow.json

@@ -1,18 +0,0 @@
-{
-  "schema_version": 2,
-  "diagram_type": "workflow",
-  "meta": {
-    "title": "Sanitized semantic labels",
-    "legend": { "mode": "hidden" }
-  },
-  "lanes": [
-    { "id": "main", "label": "Main flow" }
-  ],
-  "nodes": [
-    { "id": "request", "lane": "main", "col": 3, "type": "frontend", "label": "Request" },
-    { "id": "result", "lane": "main", "col": 4, "type": "backend", "label": "Result" }
-  ],
-  "edges": [
-    { "id": "request-result", "from": "request", "to": "result", "label": "同步 ✅ ready" }
-  ]
-}

package/template/.trae/skills/archify/test/fixtures/v1-baseline/agent-run.lifecycle.json

@@ -1,64 +0,0 @@
-{
-  "schema_version": 1,
-  "diagram_type": "lifecycle",
-  "meta": {
-    "title": "Agent Run Lifecycle",
-    "subtitle": "State machine for planning, tool execution, human approval, retries, and terminal outcomes",
-    "output": "examples/lifecycle-agent-run.html",
-    "viewBox": [980, 660]
-  },
-  "lanes": [
-    { "id": "main", "label": "Lifecycle phases" },
-    { "id": "waiting", "label": "Interruptions" },
-    { "id": "exceptions", "label": "Recovery loop" },
-    { "id": "terminal", "label": "Terminal exits" }
-  ],
-  "states": [
-    { "id": "queued", "type": "start", "label": "Queued", "sublabel": "request accepted", "lane": "main", "col": 0, "step": "01", "tag": "entry" },
-    { "id": "planning", "type": "active", "label": "Planning", "sublabel": "build task graph", "lane": "main", "col": 1, "step": "02", "tag": "model" },
-    { "id": "executing", "type": "active", "label": "Executing", "sublabel": "tool calls", "lane": "main", "col": 2, "step": "03", "tag": "work" },
-    { "id": "reviewing", "type": "decision", "label": "Reviewing", "sublabel": "quality gate", "lane": "main", "col": 3, "step": "04", "tag": "check" },
-    { "id": "completed", "type": "success", "label": "Completed", "sublabel": "final response", "lane": "main", "col": 4, "step": "05", "tag": "done" },
-    { "id": "approval", "type": "waiting", "label": "Needs Approval", "sublabel": "human gate", "lane": "waiting", "col": 0, "tag": "pause" },
-    { "id": "blocked", "type": "waiting", "label": "Blocked", "sublabel": "missing input", "lane": "waiting", "col": 1, "tag": "wait" },
-    { "id": "failed", "type": "failure", "label": "Failed", "sublabel": "recoverable error", "lane": "exceptions", "col": 0, "yOffset": 78, "tag": "retryable" },
-    { "id": "cancelled", "type": "failure", "label": "Cancelled", "sublabel": "user stopped", "lane": "terminal", "col": 0, "tag": "terminal" },
-    { "id": "expired", "type": "failure", "label": "Expired", "sublabel": "timeout", "lane": "terminal", "col": 1, "tag": "terminal" }
-  ],
-  "transitions": [
-    { "from": "executing", "to": "approval", "variant": "security", "fromSide": "bottom", "toSide": "top", "route": "straight" },
-    { "from": "reviewing", "to": "blocked", "variant": "default", "route": "drop" },
-    { "from": "executing", "to": "failed", "variant": "security", "fromSide": "left", "toSide": "top", "via": [[320, 157], [320, 342], [402, 342]] },
-    { "from": "blocked", "to": "expired", "variant": "security", "fromSide": "bottom", "toSide": "top", "route": "straight" },
-    { "from": "approval", "to": "cancelled", "variant": "security", "fromSide": "bottom", "toSide": "top", "via": [[320, 336], [320, 430], [402, 430]] }
-  ],
-  "cards": [
-    {
-      "dot": "emerald",
-      "title": "Main Path",
-      "items": [
-        "The run has five ordered phases from queue to completion",
-        "The primary lifecycle is carried by one horizontal rail",
-        "Completion is a phase, not a detached side box"
-      ]
-    },
-    {
-      "dot": "amber",
-      "title": "Human + Input Gates",
-      "items": [
-        "Approval pauses execution without ending the run",
-        "Blocked waits for missing user input",
-        "Wait states can resume back into planning or execution"
-      ]
-    },
-    {
-      "dot": "rose",
-      "title": "Terminal + Recovery",
-      "items": [
-        "Failed loops back while retry budget remains",
-        "Cancelled and Expired are exits from the lifecycle",
-        "Terminal exits do not point back into active execution"
-      ]
-    }
-  ]
-}

package/template/.trae/skills/archify/test/fixtures/v1-baseline/agent-tool-call.workflow.json

@@ -1,88 +0,0 @@
-{
-  "schema_version": 1,
-  "diagram_type": "workflow",
-  "meta": {
-    "title": "Agent Tool Call Workflow",
-    "subtitle": "Renderer-driven workflow prototype with lanes, anchored nodes, and orthogonal edges",
-    "output": "examples/workflow-agent-tool-call-rendered.html",
-    "viewBox": [720, 900]
-  },
-  "lanes": [
-    { "id": "ui", "label": "User Interface" },
-    { "id": "agent", "label": "Agent Runtime" },
-    { "id": "policy", "label": "Policy Boundary" },
-    { "id": "exceptions", "label": "Exception Handling", "variant": "exception" },
-    { "id": "tools", "label": "Tool Execution" },
-    { "id": "trace", "label": "Observability" }
-  ],
-  "phases": [
-    { "id": "intake", "label": "Intake", "fromCol": 0, "toCol": 1 },
-    { "id": "reasoning", "label": "Plan + route", "fromCol": 2, "toCol": 3, "variant": "emphasis" },
-    { "id": "execution", "label": "Execute + report", "fromCol": 4, "toCol": 5, "variant": "dashed" }
-  ],
-  "groups": [
-    { "id": "agent_loop", "label": "Planning loop", "lane": "agent", "fromCol": 2, "toCol": 3, "variant": "emphasis" },
-    { "id": "tool_work", "label": "Tool work", "lane": "tools", "fromCol": 4, "toCol": 5, "variant": "dashed" },
-    { "id": "exception_path", "label": "Human or policy stop", "lane": "exceptions", "fromCol": 3, "toCol": 5, "variant": "security" }
-  ],
-  "mainPath": ["user", "chat", "planner", "router", "approval", "tool", "external", "final"],
-  "nodes": [
-    { "id": "user", "lane": "ui", "col": 0, "type": "external", "label": "User", "sublabel": "asks for work" },
-    { "id": "chat", "lane": "ui", "col": 1, "type": "frontend", "label": "Chat Surface", "sublabel": "thread + files" },
-    { "id": "final", "lane": "ui", "col": 5, "type": "backend", "label": "Final Reply", "sublabel": "answer + changes" },
-    { "id": "planner", "lane": "agent", "col": 2, "type": "backend", "label": "Agent Planner", "sublabel": "plan next step", "tag": "context aware" },
-    { "id": "router", "lane": "agent", "col": 3, "type": "backend", "label": "Tool Router", "sublabel": "choose capability" },
-    { "id": "approval", "lane": "policy", "col": 3, "type": "security", "label": "Approval Gate", "sublabel": "scope + consent", "tag": "block risky ops" },
-    { "id": "blocked", "lane": "exceptions", "col": 4, "type": "security", "label": "Blocked", "sublabel": "wait or reject" },
-    { "id": "retry", "lane": "exceptions", "col": 5, "type": "messagebus", "label": "Retry Path", "sublabel": "revise request" },
-    { "id": "tool", "lane": "tools", "col": 4, "type": "messagebus", "label": "Tool Call", "sublabel": "shell / browser / MCP", "tag": "structured result" },
-    { "id": "external", "lane": "tools", "col": 5, "type": "cloud", "label": "External API", "sublabel": "network service" },
-    { "id": "store", "lane": "trace", "col": 1, "type": "database", "label": "Context Store", "sublabel": "repo + memory" },
-    { "id": "trace", "lane": "trace", "col": 4, "type": "database", "label": "Trace Log", "sublabel": "events + output" }
-  ],
-  "edges": [
-    { "from": "user", "to": "chat", "variant": "default" },
-    { "from": "chat", "to": "planner", "label": "plan", "variant": "emphasis", "fromSide": "bottom", "toSide": "top", "route": "drop", "labelSegment": 1 },
-    { "from": "planner", "to": "router", "variant": "default" },
-    { "from": "router", "to": "approval", "label": "needs approval?", "variant": "security", "fromSide": "bottom", "toSide": "top", "route": "drop", "labelSegment": 0, "labelDx": 34, "labelDy": 18 },
-    { "from": "approval", "to": "tool", "variant": "emphasis", "fromSide": "left", "toSide": "left", "route": "return-left" },
-    { "from": "approval", "to": "blocked", "label": "denied", "variant": "security", "role": "error", "fromSide": "bottom", "toSide": "top", "route": "drop", "labelSegment": 1, "labelDy": 12 },
-    { "from": "blocked", "to": "retry", "variant": "dashed", "role": "branch" },
-    { "from": "tool", "to": "external", "variant": "default" },
-    { "from": "external", "to": "final", "variant": "emphasis", "role": "return", "fromSide": "right", "toSide": "right", "route": "outside-right", "width": 1.2 },
-    { "from": "external", "to": "trace", "label": "record result", "variant": "dashed", "fromSide": "bottom", "toSide": "bottom", "route": "bottom-channel", "labelSegment": 1 },
-    { "from": "store", "to": "trace", "label": "trace + memory", "variant": "dashed", "labelAt": [365, 735] }
-  ],
-  "cards": [
-    {
-      "dot": "cyan",
-      "title": "Renderer Rules",
-      "items": [
-        "Lanes and columns determine node placement",
-        "Edges attach to explicit node anchors",
-        "Cross-lane paths use orthogonal routing",
-        "Short adjacent links stay unlabeled"
-      ]
-    },
-    {
-      "dot": "rose",
-      "title": "Workflow Semantics",
-      "items": [
-        "Approval is a first-class policy step",
-        "Consent gates are visible in the main path",
-        "External calls stay inside the tool lane",
-        "Trace writes are separate from the hot path"
-      ]
-    },
-    {
-      "dot": "emerald",
-      "title": "Why It Matters",
-      "items": [
-        "This is closer to a diagram_type renderer",
-        "The graph can be edited without SVG surgery",
-        "Layout rules can be tested and improved",
-        "A future IR can reuse this shape directly"
-      ]
-    }
-  ]
-}