feat: add phoenix-self example — Phoenix specs itself (dog-food)

Decompose PRD into 6 focused specs: ingestion, canonicalization,
implementation, integrity, operations, platform. Each has full
implementation stubs with Phoenix metadata, server, and tests.

Pipeline eval on its own PRD: recall 97%, typeAcc 86%, coverage 100%,
D-rate 8%, hierarchy 99%. Composite score 0.9445 across 18 total specs.
All 52 example tests + 413 root tests pass.

examples/phoenix-self/package-lock.json

···
+{
+  "name": "phoenix-self",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "phoenix-self",
+      "version": "0.1.0",
+      "devDependencies": {
+        "@types/node": "^22.0.0",
+        "typescript": "^5.4.0",
+        "vitest": "^2.0.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.0.tgz",
+      "integrity": "sha512-WOhNW9K8bR3kf4zLxbfg6Pxu2ybOUbB2AjMDHSQx86LIF4rH4Ft7vmMwNt0loO0eonglSNy4cpD3MKXXKQu0/A==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.0.tgz",
+      "integrity": "sha512-u6JHLll5QKRvjciE78bQXDmqRqNs5M/3GVqZeMwvmjaNODJih/WIrJlFVEihvV0MiYFmd+ZyPr9wxOVbPAG2Iw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.0.tgz",
+      "integrity": "sha512-qEF7CsKKzSRc20Ciu2Zw1wRrBz4g56F7r/vRwY430UPp/nt1x21Q/fpJ9N5l47WWvJlkNCPJz3QRVw008fi7yA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.0.tgz",
+      "integrity": "sha512-WADYozJ4QCnXCH4wPB+3FuGmDPoFseVCUrANmA5LWwGmC6FL14BWC7pcq+FstOZv3baGX65tZ378uT6WG8ynTw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.0.tgz",
+      "integrity": "sha512-6b8wGHJlDrGeSE3aH5mGNHBjA0TTkxdoNHik5EkvPHCt351XnigA4pS7Wsj/Eo9Y8RBU6f35cjN9SYmCFBtzxw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.0.tgz",
+      "integrity": "sha512-h25Ga0t4jaylMB8M/JKAyrvvfxGRjnPQIR8lnCayyzEjEOx2EJIlIiMbhpWxDRKGKF8jbNH01NnN663dH638mA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.0.tgz",
+      "integrity": "sha512-RzeBwv0B3qtVBWtcuABtSuCzToo2IEAIQrcyB/b2zMvBWVbjo8bZDjACUpnaafaxhTw2W+imQbP2BD1usasK4g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.0.tgz",
+      "integrity": "sha512-Sf7zusNI2CIU1HLzuu9Tc5YGAHEZs5Lu7N1ssJG4Tkw6e0MEsN7NdjUDDfGNHy2IU+ENyWT+L2obgWiguWibWQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.0.tgz",
+      "integrity": "sha512-DX2x7CMcrJzsE91q7/O02IJQ5/aLkVtYFryqCjduJhUfGKG6yJV8hxaw8pZa93lLEpPTP/ohdN4wFz7yp/ry9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.0.tgz",
+      "integrity": "sha512-09EL+yFVbJZlhcQfShpswwRZ0Rg+z/CsSELFCnPt3iK+iqwGsI4zht3secj5vLEs957QvFFXnzAT0FFPIxSrkQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.0.tgz",
+      "integrity": "sha512-i9IcCMPr3EXm8EQg5jnja0Zyc1iFxJjZWlb4wr7U2Wx/GrddOuEafxRdMPRYVaXjgbhvqalp6np07hN1w9kAKw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.0.tgz",
+      "integrity": "sha512-DGzdJK9kyJ+B78MCkWeGnpXJ91tK/iKA6HwHxF4TAlPIY7GXEvMe8hBFRgdrR9Ly4qebR/7gfUs9y2IoaVEyog==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.0.tgz",
+      "integrity": "sha512-RwpnLsqC8qbS8z1H1AxBA1H6qknR4YpPR9w2XX0vo2Sz10miu57PkNcnHVaZkbqyw/kUWfKMI73jhmfi9BRMUQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.0.tgz",
+      "integrity": "sha512-Z8pPf54Ly3aqtdWC3G4rFigZgNvd+qJlOE52fmko3KST9SoGfAdSRCwyoyG05q1HrrAblLbk1/PSIV+80/pxLg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.0.tgz",
+      "integrity": "sha512-3a3qQustp3COCGvnP4SvrMHnPQ9d1vzCakQVRTliaz8cIp/wULGjiGpbcqrkv0WrHTEp8bQD/B3HBjzujVWLOA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.0.tgz",
+      "integrity": "sha512-pjZDsVH/1VsghMJ2/kAaxt6dL0psT6ZexQVrijczOf+PeP2BUqTHYejk3l6TlPRydggINOeNRhvpLa0AYpCWSQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.0.tgz",
+      "integrity": "sha512-3ObQs0BhvPgiUVZrN7gqCSvmFuMWvWvsjG5ayJ3Lraqv+2KhOsp+pUbigqbeWqueGIsnn+09HBw27rJ+gYK4VQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.0.tgz",
+      "integrity": "sha512-EtylprDtQPdS5rXvAayrNDYoJhIz1/vzN2fEubo3yLE7tfAw+948dO0g4M0vkTVFhKojnF+n6C8bDNe+gDRdTg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.0.tgz",
+      "integrity": "sha512-k09oiRCi/bHU9UVFqD17r3eJR9bn03TyKraCrlz5ULFJGdJGi7VOmm9jl44vOJvRJ6P7WuBi/s2A97LxxHGIdw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.0.tgz",
+      "integrity": "sha512-1o/0/pIhozoSaDJoDcec+IVLbnRtQmHwPV730+AOD29lHEEo4F5BEUB24H0OBdhbBBDwIOSuf7vgg0Ywxdfiiw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.0.tgz",
+      "integrity": "sha512-pESDkos/PDzYwtyzB5p/UoNU/8fJo68vcXM9ZW2V0kjYayj1KaaUfi1NmTUTUpMn4UhU4gTuK8gIaFO4UGuMbA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.0.tgz",
+      "integrity": "sha512-hj1wFStD7B1YBeYmvY+lWXZ7ey73YGPcViMShYikqKT1GtstIKQAtfUI6yrzPjAy/O7pO0VLXGmUVWXQMaYgTQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.0.tgz",
+      "integrity": "sha512-SyaIPFoxmUPlNDq5EHkTbiKzmSEmq/gOYFI/3HHJ8iS/v1mbugVa7dXUzcJGQfoytp9DJFLhHH4U3/eTy2Bq4w==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.0.tgz",
+      "integrity": "sha512-RdcryEfzZr+lAr5kRm2ucN9aVlCCa2QNq4hXelZxb8GG0NJSazq44Z3PCCc8wISRuCVnGs0lQJVX5Vp6fKA+IA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.0.tgz",
+      "integrity": "sha512-PrsWNQ8BuE00O3Xsx3ALh2Df8fAj9+cvvX9AIA6o4KpATR98c9mud4XtDWVvsEuyia5U4tVSTKygawyJkjm60w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "22.19.15",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.15.tgz",
+      "integrity": "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",
+      "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "2.1.9",
+        "@vitest/utils": "2.1.9",
+        "chai": "^5.1.2",
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz",
+      "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "2.1.9",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.12"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
+      "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz",
+      "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "2.1.9",
+        "pathe": "^1.1.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",
+      "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "2.1.9",
+        "magic-string": "^0.30.12",
+        "pathe": "^1.1.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",
+      "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^3.0.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",
+      "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "2.1.9",
+        "loupe": "^3.1.2",
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/check-error": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
+      "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/pathe": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.8",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.0.tgz",
+      "integrity": "sha512-yqjxruMGBQJ2gG4HtjZtAfXArHomazDHoFwFFmZZl0r7Pdo7qCIXKqKHZc8yeoMgzJJ+pO6pEEHa+V7uzWlrAQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.0",
+        "@rollup/rollup-android-arm64": "4.60.0",
+        "@rollup/rollup-darwin-arm64": "4.60.0",
+        "@rollup/rollup-darwin-x64": "4.60.0",
+        "@rollup/rollup-freebsd-arm64": "4.60.0",
+        "@rollup/rollup-freebsd-x64": "4.60.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.0",
+        "@rollup/rollup-linux-arm64-musl": "4.60.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.0",
+        "@rollup/rollup-linux-loong64-musl": "4.60.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.0",
+        "@rollup/rollup-linux-x64-gnu": "4.60.0",
+        "@rollup/rollup-linux-x64-musl": "4.60.0",
+        "@rollup/rollup-openbsd-x64": "4.60.0",
+        "@rollup/rollup-openharmony-arm64": "4.60.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.0",
+        "@rollup/rollup-win32-x64-gnu": "4.60.0",
+        "@rollup/rollup-win32-x64-msvc": "4.60.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
+      "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tinyspy": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
+      "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-node": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz",
+      "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.3.7",
+        "es-module-lexer": "^1.5.4",
+        "pathe": "^1.1.2",
+        "vite": "^5.0.0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz",
+      "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "2.1.9",
+        "@vitest/mocker": "2.1.9",
+        "@vitest/pretty-format": "^2.1.9",
+        "@vitest/runner": "2.1.9",
+        "@vitest/snapshot": "2.1.9",
+        "@vitest/spy": "2.1.9",
+        "@vitest/utils": "2.1.9",
+        "chai": "^5.1.2",
+        "debug": "^4.3.7",
+        "expect-type": "^1.1.0",
+        "magic-string": "^0.30.12",
+        "pathe": "^1.1.2",
+        "std-env": "^3.8.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.1",
+        "tinypool": "^1.0.1",
+        "tinyrainbow": "^1.2.0",
+        "vite": "^5.0.0",
+        "vite-node": "2.1.9",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "@vitest/browser": "2.1.9",
+        "@vitest/ui": "2.1.9",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    }
+  }
+}

examples/phoenix-self/package.json

···
+{
+  "name": "phoenix-self",
+  "version": "0.1.0",
+  "description": "Generated by Phoenix VCS — 6 services (dog-food: Phoenix specs itself)",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start:ingestion": "tsc && node dist/generated/ingestion/server.js",
+    "start:canonicalization": "tsc && node dist/generated/canonicalization/server.js",
+    "start:implementation": "tsc && node dist/generated/implementation/server.js",
+    "start:integrity": "tsc && node dist/generated/integrity/server.js",
+    "start:operations": "tsc && node dist/generated/operations/server.js",
+    "start:platform": "tsc && node dist/generated/platform/server.js",
+    "start": "tsc && node dist/generated/platform/server.js"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0",
+    "@types/node": "^22.0.0"
+  }
+}

examples/phoenix-self/spec/canonicalization.md

···
+# Canonicalization Pipelines
+
+Canonicalization transforms extracted clauses into a structured canonical requirement graph. The pipeline is versioned and explicitly tracked.
+
+## Pipeline Identity
+
+- Each canonicalization pipeline must be identified by: canon_pipeline_id, model_id, promptpack_version, extraction_rules_version, and diff_policy_version
+- Pipeline upgrades must produce a meta-node of type PipelineUpgrade in the provenance graph
+- Pipeline versions must never be silently changed; every upgrade must be explicit and auditable
+
+## Canonical Node Extraction
+
+- The pipeline must extract canonical nodes of five types: REQUIREMENT, CONSTRAINT, INVARIANT, DEFINITION, and CONTEXT
+- Each canonical node must have a content-addressed canon_id, a type, a normalized statement, confidence score, source clause IDs, tags, and linked canon IDs
+- Extraction must assign a confidence score between 0.0 and 1.0 to each node
+- Nodes with no actionable keywords must default to type CONTEXT
+- The extraction pipeline must track coverage: the percentage of source sentences that produced canonical nodes
+
+## Shadow Canonicalization
+
+- When upgrading pipelines, the system must run old and new pipelines in parallel (shadow mode)
+- Shadow mode must compute diff metrics: node_change_pct, edge_change_pct, risk_escalations, orphan_nodes, out_of_scope_growth, and semantic_stmt_drift
+- An upgrade is classified as SAFE when node_change_pct is at most 3%, there are no orphan nodes, and no risk escalations
+- An upgrade is classified as COMPACTION EVENT when node_change_pct is at most 25%, no orphan nodes, and limited risk escalations
+- An upgrade must be classified as REJECT when orphan nodes exist, churn is excessive, or semantic drift is large
+- Shadow canonicalization results must never be applied to the live graph without explicit acceptance

examples/phoenix-self/spec/implementation.md

···
+# Implementation Units & Boundary Policies
+
+Implementation Units (IUs) are stable compilation boundaries that map canonical requirements to generated code. Boundary policies enforce architectural constraints.
+
+## Implementation Unit Structure
+
+- An Implementation Unit is defined by: iu_id, kind (module or function), risk_tier, contract, dependencies, boundary_policy, impact, and evidence_policy
+- IU IDs must be content-addressed and deterministic
+- IUs must declare their risk tier: low, medium, high, or critical
+- Bots must propose IU changes; humans or policy must accept them
+- Each IU must declare its contract: the set of canonical nodes it implements
+
+## Boundary Policy Schema
+
+- Each IU must declare its allowed and forbidden code dependencies: allowed_ius, allowed_packages, forbidden_ius, forbidden_packages, and forbidden_paths
+- Each IU must declare its side-channel dependencies: databases, queues, caches, config, external_apis, and files
+- Side-channel dependencies must create edges in the invalidation graph
+- Boundary policies must be enforced post-generation by the architectural linter
+
+## Architectural Linter
+
+- After code generation, the linter must extract the dependency graph from generated code
+- The linter must validate all dependencies against the IU's boundary policy
+- Dependency violations must be emitted as diagnostics with configurable severity (error or warning)
+- Side-channel violations must be emitted as diagnostics with configurable severity
+- The linter must never silently ignore a boundary violation
+
+## Regeneration Engine
+
+- Regeneration must operate at IU granularity: only invalidated IUs are regenerated
+- Each regeneration must record: model_id, promptpack hash, toolchain version, and normalization steps
+- Generated artifacts must produce a generated_manifest with per-file and per-IU hashes
+- The manifest must be stored at .phoenix/generated_manifest
+- Regeneration must be reproducible: same inputs must produce semantically equivalent outputs

examples/phoenix-self/spec/ingestion.md

···
+# Spec Ingestion & Change Classification
+
+The ingestion pipeline transforms raw specification documents into structured, content-addressed clauses and classifies changes between spec versions.
+
+## Clause Extraction
+
+- Each spec document must be parsed into atomic clauses with unique clause_id
+- A clause is a content-addressed unit containing: clause_id, source_doc_id, source_line_range, raw_text, normalized_text, and section_path
+- Clause IDs must be deterministic: identical content always produces the same ID
+- The parser must preserve section hierarchy from markdown headings
+- Clauses must never span multiple top-level sections
+
+## Semantic Hashing
+
+- Each clause must have a clause_semhash computed from its normalized text via SHA-256
+- Each clause must have a context_semhash_cold computed from normalized text, section path, and neighbor clause hashes
+- After canonicalization, a context_semhash_warm must be computed incorporating canonical graph context
+- Semantic hashes must be stable: identical input always produces identical hash
+- The warm hash must exclude weak 'relates_to' edges to prevent incidental invalidation
+
+## Change Classification
+
+- Every clause change must be classified into exactly one of four classes: A (trivial), B (local semantic), C (contextual shift), or D (uncertain)
+- Class A changes include formatting-only modifications where the semantic hash is unchanged
+- Class B changes are local semantic modifications with moderate edit distance
+- Class C changes affect the canonical graph or structural context
+- Class D changes are uncertain and require human or LLM review
+- The classifier must use multiple signals: normalized edit distance, semhash delta, context hash delta, term-reference deltas, and section structure deltas
+
+## D-Rate Trust Loop
+
+- The D-rate is defined as the percentage of changes classified as D (uncertain) over a rolling window
+- The target D-rate must be at most 5%
+- D-rate above 10% is acceptable but triggers a warning
+- D-rate above 15% must trigger an alarm requiring classifier tuning
+- When the D-rate alarm fires, override friction must increase and PolicyBot must surface a trust degradation warning
+- D-rate must always be tracked as a first-class metric

examples/phoenix-self/spec/integrity.md

···
+# Integrity: Drift Detection, Evidence & Cascading Failures
+
+The integrity subsystem ensures generated code stays consistent with specifications through drift detection, risk-tiered evidence requirements, and explicit failure propagation.
+
+## Drift Detection
+
+- On status, the system must compare the working tree against the generated_manifest
+- If a mismatch exists and no waiver is present, the system must emit an ERROR diagnostic
+- Unlabeled manual edits must block acceptance of the affected IU
+- Manual edits must be labeled as one of: promote_to_requirement, waiver (signed), or temporary_patch (expires)
+- Temporary patches must have an expiration date and must trigger a warning when expired
+
+## Evidence & Policy Engine
+
+- Evidence requirements must be tiered by IU risk level
+- Low-tier IUs require: typecheck, lint, and boundary validation
+- Medium-tier IUs require: unit tests in addition to low-tier evidence
+- High-tier IUs require: unit tests, property tests, threat note, and static analysis
+- Critical-tier IUs require: human signoff or formal verification / simulation evidence
+- Evidence must bind to canonical nodes, IU IDs, and generated artifact hashes
+- Evidence bindings must always be traceable: given any evidence artifact, the system must identify which canonical nodes and IUs it covers
+
+## Cascading Failure Semantics
+
+- If evidence for IU-X fails, IU-X must be blocked from acceptance
+- When IU-X is blocked, all dependent IUs must re-run: typecheck, boundary checks, and relevant tagged tests
+- Failure propagation must be explicit and graph-based: the system must traverse the IU dependency graph
+- Cascade depth must be bounded to prevent infinite propagation loops
+- The system must report the full cascade chain in diagnostics so developers can trace the root cause

examples/phoenix-self/spec/operations.md

···
+# Operations: Compaction, Diagnostics & Bootstrap
+
+The operations subsystem manages storage lifecycle, system diagnostics, and the bootstrap initialization flow.
+
+## Compaction
+
+- The system must maintain three storage tiers: Hot Graph (last 30 days), Ancestry Index (forever metadata), and Cold Packs (heavy blobs)
+- Compaction must never delete: node headers, provenance edges, approvals, or signatures
+- Compaction must be triggered by: size threshold exceeded, pipeline upgrade accepted, or time-based fallback
+- Each compaction must produce a CompactionEvent meta-node in the provenance graph
+- PolicyBot must announce every compaction event
+
+## Diagnostics & Severity Model
+
+- Every status item must include: severity (error, warning, or info), category, subject, message, and recommended_actions
+- Status items must be grouped by severity in display output
+- The diagnostics system is the primary user experience surface for Phoenix
+- phoenix status must always be explainable, conservative, and correct-enough to rely on
+- Diagnostic messages must never be ambiguous about what action the developer should take
+
+## Bootstrap Flow
+
+- The bootstrap command must execute in order: cold pass, canonicalization, warm pass, generate Trust Dashboard, set system state to WARMING
+- D-rate alarms must be suppressed during the BOOTSTRAP_COLD phase
+- Severity must be downgraded during the BOOTSTRAP_WARMING phase
+- After stabilization, the system must transition to STEADY_STATE
+- Bootstrap must be resumable: if interrupted, it must pick up from the last completed phase
+- The system must never transition to STEADY_STATE until the D-rate is within acceptable bounds

examples/phoenix-self/spec/platform.md

···
+# Platform: Core Graphs, Bot Integration & Brownfield Wrapping
+
+The platform layer provides the foundational graph data model, bot command interface, and progressive integration strategy for existing codebases.
+
+## Core Graph Model
+
+- Phoenix must maintain five interconnected graphs: Spec Graph (clauses), Canonical Graph (requirements, constraints, invariants, definitions), Implementation Graph (IUs), Evidence Graph (tests, analysis, reviews), and Provenance Graph (all transformation edges and meta-events)
+- Everything in Phoenix must be content-addressed and versioned
+- Every transformation between graphs must emit provenance edges
+- Selective invalidation is the defining capability: changing one spec line must invalidate only the dependent subtree, not the entire repository
+- The Provenance Graph must never lose edges: all transformations are append-only
+
+## Bot Integration
+
+- Bots must behave as normal users with no elevated privileges
+- Mutating commands must follow the confirmation model: the bot echoes parsed intent, the user replies with ok or phx confirm
+- Read-only commands must execute immediately without confirmation
+- Each bot must expose help, commands, and version subcommands
+- Phoenix must not use fuzzy NLU for command parsing in v1; commands must be explicit and deterministic
+- Three core bots must be supported: SpecBot (ingest), ImplBot (regen), and PolicyBot (status)
+
+## Brownfield Progressive Wrapping
+
+- Step 1 (Wrap Module): the system must support defining an IU boundary around an existing module, writing a minimal spec, and enforcing boundary and evidence policies without full regeneration
+- Step 2 (Annotate Provenance): the system must support manually mapping functions to requirement IDs and gradually increasing the regeneration surface
+- Brownfield wrapping must never require full codebase regeneration to start providing value
+- The system must track which IUs are fully regenerated vs boundary-only wrapped

examples/phoenix-self/src/generated/canonicalization/__tests__/canonicalization.test.ts

···
+/**
+ * Canonicalization — Generated Tests
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Tests module structure, server health, and Phoenix traceability.
+ */
+
+import { describe, it, expect, afterAll } from 'vitest';
+import { startServer } from '../server.js';
+
+import * as canonPipeline from '../canon-pipeline.js';
+import * as shadowMode from '../shadow-mode.js';
+
+describe('Canonicalization modules', () => {
+  describe('Canon Pipeline', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(canonPipeline._phoenix).toBeDefined();
+      expect(canonPipeline._phoenix.name).toBe('Canon Pipeline');
+      expect(canonPipeline._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(canonPipeline).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Shadow Mode', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(shadowMode._phoenix).toBeDefined();
+      expect(shadowMode._phoenix.name).toBe('Shadow Mode');
+      expect(shadowMode._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(shadowMode).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+});
+
+describe('Canonicalization server', () => {
+  const instance = startServer(0); // random port
+
+  afterAll(() => new Promise<void>(resolve => instance.server.close(() => resolve())));
+
+  it('GET /health returns 200', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.status).toBe('ok');
+    expect(body.service).toBe('Canonicalization');
+  });
+
+  it('GET /metrics returns request counts', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/metrics`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.requests_total).toBe('number');
+  });
+
+  it('GET /modules lists all registered modules', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/modules`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Array<Record<string, unknown>>;
+    expect(body.length).toBe(2);
+  });
+
+  it('GET /unknown returns 404', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/unknown`);
+    expect(res.status).toBe(404);
+  });
+});

examples/phoenix-self/src/generated/canonicalization/canon-pipeline.ts

···
+export type CanonicalType = 'REQUIREMENT' | 'CONSTRAINT' | 'INVARIANT' | 'DEFINITION' | 'CONTEXT';
+
+export interface CanonicalNode {
+  canon_id: string;
+  type: CanonicalType;
+  statement: string;
+  confidence: number;
+  source_clause_ids: string[];
+  tags: string[];
+}
+
+export interface PipelineConfig {
+  canon_pipeline_id: string;
+  model_id: string;
+  promptpack_version: string;
+  extraction_rules_version: string;
+  diff_policy_version: string;
+}
+
+export interface ExtractionCoverage {
+  total_sentences: number;
+  extracted: number;
+  coverage_pct: number;
+}
+
+export class CanonPipeline {
+  private config: PipelineConfig;
+
+  constructor(config: PipelineConfig) {
+    this.config = config;
+  }
+
+  getConfig(): PipelineConfig { return { ...this.config }; }
+
+  extractNodes(clauseTexts: string[]): { nodes: CanonicalNode[]; coverage: ExtractionCoverage } {
+    const nodes: CanonicalNode[] = [];
+    for (const text of clauseTexts) {
+      const type = this.classifyType(text);
+      nodes.push({
+        canon_id: `canon_${nodes.length}`,
+        type,
+        statement: text.trim(),
+        confidence: type === 'CONTEXT' ? 0.3 : 0.7,
+        source_clause_ids: [],
+        tags: this.extractTags(text),
+      });
+    }
+    return { nodes, coverage: { total_sentences: clauseTexts.length, extracted: nodes.length, coverage_pct: 100 } };
+  }
+
+  private classifyType(text: string): CanonicalType {
+    const lower = text.toLowerCase();
+    if (/\b(?:must not|cannot|forbidden|limited to|maximum|minimum)\b/.test(lower)) return 'CONSTRAINT';
+    if (/\b(?:always|never|guaranteed|must remain)\b/.test(lower)) return 'INVARIANT';
+    if (/\b(?:is defined as|means|refers to)\b/.test(lower)) return 'DEFINITION';
+    if (/\b(?:must|shall|required)\b/.test(lower)) return 'REQUIREMENT';
+    return 'CONTEXT';
+  }
+
+  private extractTags(text: string): string[] {
+    return text.toLowerCase().split(/\s+/).filter(w => w.length > 3 && !/^(must|shall|the|and|for|with|from|that|this)$/.test(w)).slice(0, 5);
+  }
+}
+
+export function createCanonPipeline(config: PipelineConfig): CanonPipeline {
+  return new CanonPipeline(config);
+}
+
+export const _phoenix = {
+  iu_id: 'c9d0e1f2',
+  name: 'Canon Pipeline',
+  risk_tier: 'high',
+  canon_ids: [5, 6],
+} as const;

examples/phoenix-self/src/generated/canonicalization/index.ts

···
+export * as canonPipeline from './canon-pipeline.js';
+export * as shadowMode from './shadow-mode.js';

examples/phoenix-self/src/generated/canonicalization/server.ts

···
+/**
+ * Canonicalization — HTTP Server
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Provides health check, metrics, and module endpoints.
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'node:http';
+
+import * as canonPipeline from './canon-pipeline.js';
+import * as shadowMode from './shadow-mode.js';
+
+// ─── Metrics ─────────────────────────────────────────────────────────────────
+
+const _svcMetrics = {
+  requests_total: 0,
+  requests_by_path: {} as Record<string, number>,
+  errors_total: 0,
+  uptime_start: Date.now(),
+};
+
+// ─── Module Registry ─────────────────────────────────────────────────────────
+
+const _svcModules = {
+  'canon-pipeline': canonPipeline,
+  'shadow-mode': shadowMode,
+};
+
+// ─── Router ──────────────────────────────────────────────────────────────────
+
+type Handler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+
+const routes: Record<string, Handler> = {
+  '/health': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      service: 'Canonicalization',
+      uptime: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+      modules: Object.keys(_svcModules),
+    }));
+  },
+
+  '/metrics': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      ..._svcMetrics,
+      uptime_seconds: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+    }, null, 2));
+  },
+
+  '/modules': (_req, res) => {
+    const info = Object.entries(_svcModules).map(([name, mod]) => {
+      const phoenix = (mod as Record<string, unknown>)._phoenix as Record<string, unknown> | undefined;
+      return {
+        name,
+        risk_tier: phoenix?.risk_tier ?? 'unknown',
+        exports: Object.keys(mod).filter(k => k !== '_phoenix'),
+      };
+    });
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(info, null, 2));
+  },
+};
+
+// ─── Server ──────────────────────────────────────────────────────────────────
+
+function handleRequest(req: IncomingMessage, res: ServerResponse): void {
+  const url = req.url ?? '/';
+  const path = url.split('?')[0];
+
+  _svcMetrics.requests_total++;
+  _svcMetrics.requests_by_path[path] = (_svcMetrics.requests_by_path[path] ?? 0) + 1;
+
+  const handler = routes[path];
+  if (handler) {
+    try {
+      handler(req, res);
+    } catch (err) {
+      _svcMetrics.errors_total++;
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      error: 'Not Found',
+      path,
+      available: Object.keys(routes),
+    }));
+  }
+}
+
+export function startServer(port?: number): { server: ReturnType<typeof createServer>; port: number; ready: Promise<void> } {
+  const requestedPort = port ?? parseInt(process.env.CANONICALIZATION_PORT ?? process.env.PORT ?? '3002', 10);
+  const server = createServer(handleRequest);
+  let actualPort = requestedPort;
+
+  const ready = new Promise<void>(resolve => {
+    server.listen(requestedPort, () => {
+      const addr = server.address();
+      if (addr && typeof addr === 'object') actualPort = addr.port;
+      result.port = actualPort;
+      console.log(`Canonicalization listening on http://localhost:${actualPort}`);
+      console.log(`  /health   — health check`);
+      console.log(`  /metrics  — request metrics`);
+      console.log(`  /modules  — registered modules`);
+      resolve();
+    });
+  });
+
+  const result = { server, port: actualPort, ready };
+  return result;
+}
+
+// Start when run directly
+const isMain = process.argv[1]?.endsWith('/canonicalization/server.js') ||
+               process.argv[1]?.endsWith('/canonicalization/server.ts');
+if (isMain) {
+  startServer();
+}

examples/phoenix-self/src/generated/canonicalization/shadow-mode.ts

···
+import type { CanonicalNode } from './canon-pipeline.js';
+
+export type UpgradeClassification = 'SAFE' | 'COMPACTION_EVENT' | 'REJECT';
+
+export interface ShadowDiffMetrics {
+  node_change_pct: number;
+  edge_change_pct: number;
+  risk_escalations: number;
+  orphan_nodes: number;
+  out_of_scope_growth: number;
+  semantic_stmt_drift: number;
+}
+
+export class ShadowPipeline {
+  comparePipelines(oldNodes: CanonicalNode[], newNodes: CanonicalNode[]): ShadowDiffMetrics {
+    const oldIds = new Set(oldNodes.map(n => n.canon_id));
+    const newIds = new Set(newNodes.map(n => n.canon_id));
+    const added = [...newIds].filter(id => !oldIds.has(id)).length;
+    const removed = [...oldIds].filter(id => !newIds.has(id)).length;
+    const total = Math.max(oldNodes.length, 1);
+    return {
+      node_change_pct: ((added + removed) / total) * 100,
+      edge_change_pct: 0,
+      risk_escalations: 0,
+      orphan_nodes: removed,
+      out_of_scope_growth: 0,
+      semantic_stmt_drift: 0,
+    };
+  }
+
+  classifyUpgrade(metrics: ShadowDiffMetrics): UpgradeClassification {
+    if (metrics.orphan_nodes > 0 || metrics.node_change_pct > 25) return 'REJECT';
+    if (metrics.node_change_pct <= 3 && metrics.risk_escalations === 0) return 'SAFE';
+    return 'COMPACTION_EVENT';
+  }
+}
+
+export function createShadowPipeline(): ShadowPipeline {
+  return new ShadowPipeline();
+}
+
+export const _phoenix = {
+  iu_id: 'a3b4c5d6',
+  name: 'Shadow Mode',
+  risk_tier: 'high',
+  canon_ids: [7],
+} as const;

examples/phoenix-self/src/generated/implementation/__tests__/implementation.test.ts

···
+/**
+ * Implementation — Generated Tests
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Tests module structure, server health, and Phoenix traceability.
+ */
+
+import { describe, it, expect, afterAll } from 'vitest';
+import { startServer } from '../server.js';
+
+import * as iuManager from '../iu-manager.js';
+import * as boundaryValidator from '../boundary-validator.js';
+
+describe('Implementation modules', () => {
+  describe('IU Manager', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(iuManager._phoenix).toBeDefined();
+      expect(iuManager._phoenix.name).toBe('IU Manager');
+      expect(iuManager._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(iuManager).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Boundary Validator', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(boundaryValidator._phoenix).toBeDefined();
+      expect(boundaryValidator._phoenix.name).toBe('Boundary Validator');
+      expect(boundaryValidator._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(boundaryValidator).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+});
+
+describe('Implementation server', () => {
+  const instance = startServer(0); // random port
+
+  afterAll(() => new Promise<void>(resolve => instance.server.close(() => resolve())));
+
+  it('GET /health returns 200', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.status).toBe('ok');
+    expect(body.service).toBe('Implementation');
+  });
+
+  it('GET /metrics returns request counts', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/metrics`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.requests_total).toBe('number');
+  });
+
+  it('GET /modules lists all registered modules', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/modules`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Array<Record<string, unknown>>;
+    expect(body.length).toBe(2);
+  });
+
+  it('GET /unknown returns 404', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/unknown`);
+    expect(res.status).toBe(404);
+  });
+});

examples/phoenix-self/src/generated/implementation/boundary-validator.ts

···
+import type { ImplementationUnit } from './iu-manager.js';
+
+export type ViolationSeverity = 'error' | 'warning';
+
+export interface BoundaryViolation {
+  iu_id: string;
+  violation_type: 'dependency' | 'side_channel';
+  severity: ViolationSeverity;
+  target: string;
+  message: string;
+}
+
+export class BoundaryValidator {
+  validate(iu: ImplementationUnit, actualDependencies: string[]): BoundaryViolation[] {
+    const violations: BoundaryViolation[] = [];
+    for (const dep of actualDependencies) {
+      if (iu.boundary_policy.forbidden_ius.includes(dep)) {
+        violations.push({ iu_id: iu.iu_id, violation_type: 'dependency', severity: 'error', target: dep, message: `Forbidden IU dependency: ${dep}` });
+      }
+      if (iu.boundary_policy.forbidden_packages.includes(dep)) {
+        violations.push({ iu_id: iu.iu_id, violation_type: 'dependency', severity: 'error', target: dep, message: `Forbidden package dependency: ${dep}` });
+      }
+    }
+    return violations;
+  }
+}
+
+export function createBoundaryValidator(): BoundaryValidator { return new BoundaryValidator(); }
+
+export const _phoenix = {
+  iu_id: 'b5a6c7d8',
+  name: 'Boundary Validator',
+  risk_tier: 'high',
+  canon_ids: [10, 11],
+} as const;

examples/phoenix-self/src/generated/implementation/index.ts

···
+export * as iuManager from './iu-manager.js';
+export * as boundaryValidator from './boundary-validator.js';

examples/phoenix-self/src/generated/implementation/iu-manager.ts

···
+import { randomUUID } from 'node:crypto';
+
+export type RiskTier = 'low' | 'medium' | 'high' | 'critical';
+export type IUKind = 'module' | 'function';
+
+export interface ImplementationUnit {
+  iu_id: string;
+  kind: IUKind;
+  risk_tier: RiskTier;
+  contract: string[];
+  dependencies: string[];
+  boundary_policy: BoundaryPolicy;
+}
+
+export interface BoundaryPolicy {
+  allowed_ius: string[];
+  allowed_packages: string[];
+  forbidden_ius: string[];
+  forbidden_packages: string[];
+  forbidden_paths: string[];
+  side_channels: SideChannels;
+}
+
+export interface SideChannels {
+  databases: string[];
+  queues: string[];
+  caches: string[];
+  external_apis: string[];
+}
+
+export class IUManager {
+  private units = new Map<string, ImplementationUnit>();
+
+  createIU(kind: IUKind, riskTier: RiskTier, contract: string[]): ImplementationUnit {
+    const iu: ImplementationUnit = {
+      iu_id: randomUUID(),
+      kind,
+      risk_tier: riskTier,
+      contract,
+      dependencies: [],
+      boundary_policy: { allowed_ius: [], allowed_packages: [], forbidden_ius: [], forbidden_packages: [], forbidden_paths: [], side_channels: { databases: [], queues: [], caches: [], external_apis: [] } },
+    };
+    this.units.set(iu.iu_id, iu);
+    return iu;
+  }
+
+  getIU(id: string): ImplementationUnit | undefined { return this.units.get(id); }
+  listIUs(): ImplementationUnit[] { return [...this.units.values()]; }
+  addDependency(iuId: string, depId: string): void {
+    const iu = this.units.get(iuId);
+    if (iu && !iu.dependencies.includes(depId)) iu.dependencies.push(depId);
+  }
+}
+
+export function createIUManager(): IUManager { return new IUManager(); }
+
+export const _phoenix = {
+  iu_id: 'f1e2d3c4',
+  name: 'IU Manager',
+  risk_tier: 'high',
+  canon_ids: [8, 9],
+} as const;

examples/phoenix-self/src/generated/implementation/server.ts

···
+/**
+ * Implementation — HTTP Server
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Provides health check, metrics, and module endpoints.
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'node:http';
+
+import * as iuManager from './iu-manager.js';
+import * as boundaryValidator from './boundary-validator.js';
+
+// ─── Metrics ─────────────────────────────────────────────────────────────────
+
+const _svcMetrics = {
+  requests_total: 0,
+  requests_by_path: {} as Record<string, number>,
+  errors_total: 0,
+  uptime_start: Date.now(),
+};
+
+// ─── Module Registry ─────────────────────────────────────────────────────────
+
+const _svcModules = {
+  'iu-manager': iuManager,
+  'boundary-validator': boundaryValidator,
+};
+
+// ─── Router ──────────────────────────────────────────────────────────────────
+
+type Handler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+
+const routes: Record<string, Handler> = {
+  '/health': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      service: 'Implementation',
+      uptime: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+      modules: Object.keys(_svcModules),
+    }));
+  },
+
+  '/metrics': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      ..._svcMetrics,
+      uptime_seconds: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+    }, null, 2));
+  },
+
+  '/modules': (_req, res) => {
+    const info = Object.entries(_svcModules).map(([name, mod]) => {
+      const phoenix = (mod as Record<string, unknown>)._phoenix as Record<string, unknown> | undefined;
+      return {
+        name,
+        risk_tier: phoenix?.risk_tier ?? 'unknown',
+        exports: Object.keys(mod).filter(k => k !== '_phoenix'),
+      };
+    });
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(info, null, 2));
+  },
+};
+
+// ─── Server ──────────────────────────────────────────────────────────────────
+
+function handleRequest(req: IncomingMessage, res: ServerResponse): void {
+  const url = req.url ?? '/';
+  const path = url.split('?')[0];
+
+  _svcMetrics.requests_total++;
+  _svcMetrics.requests_by_path[path] = (_svcMetrics.requests_by_path[path] ?? 0) + 1;
+
+  const handler = routes[path];
+  if (handler) {
+    try {
+      handler(req, res);
+    } catch (err) {
+      _svcMetrics.errors_total++;
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      error: 'Not Found',
+      path,
+      available: Object.keys(routes),
+    }));
+  }
+}
+
+export function startServer(port?: number): { server: ReturnType<typeof createServer>; port: number; ready: Promise<void> } {
+  const requestedPort = port ?? parseInt(process.env.IMPLEMENTATION_PORT ?? process.env.PORT ?? '3003', 10);
+  const server = createServer(handleRequest);
+  let actualPort = requestedPort;
+
+  const ready = new Promise<void>(resolve => {
+    server.listen(requestedPort, () => {
+      const addr = server.address();
+      if (addr && typeof addr === 'object') actualPort = addr.port;
+      result.port = actualPort;
+      console.log(`Implementation listening on http://localhost:${actualPort}`);
+      console.log(`  /health   — health check`);
+      console.log(`  /metrics  — request metrics`);
+      console.log(`  /modules  — registered modules`);
+      resolve();
+    });
+  });
+
+  const result = { server, port: actualPort, ready };
+  return result;
+}
+
+// Start when run directly
+const isMain = process.argv[1]?.endsWith('/implementation/server.js') ||
+               process.argv[1]?.endsWith('/implementation/server.ts');
+if (isMain) {
+  startServer();
+}

examples/phoenix-self/src/generated/index.ts

···
+export * as ingestion from './ingestion/index.js';
+export * as canonicalization from './canonicalization/index.js';
+export * as implementation from './implementation/index.js';
+export * as integrity from './integrity/index.js';
+export * as operations from './operations/index.js';
+export * as platform from './platform/index.js';
+
+export const services = [
+  { name: 'Ingestion', dir: 'ingestion', port: 3001, modules: 2 },
+  { name: 'Canonicalization', dir: 'canonicalization', port: 3002, modules: 2 },
+  { name: 'Implementation', dir: 'implementation', port: 3003, modules: 2 },
+  { name: 'Integrity', dir: 'integrity', port: 3004, modules: 3 },
+  { name: 'Operations', dir: 'operations', port: 3005, modules: 3 },
+  { name: 'Platform', dir: 'platform', port: 3006, modules: 2 },
+] as const;

examples/phoenix-self/src/generated/ingestion/__tests__/ingestion.test.ts

···
+/**
+ * Ingestion — Generated Tests
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Tests module structure, server health, and Phoenix traceability.
+ */
+
+import { describe, it, expect, afterAll } from 'vitest';
+import { startServer } from '../server.js';
+
+import * as specParser from '../spec-parser.js';
+import * as changeClassifier from '../change-classifier.js';
+
+describe('Ingestion modules', () => {
+  describe('Spec Parser', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(specParser._phoenix).toBeDefined();
+      expect(specParser._phoenix.name).toBe('Spec Parser');
+      expect(specParser._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(specParser).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Change Classifier', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(changeClassifier._phoenix).toBeDefined();
+      expect(changeClassifier._phoenix.name).toBe('Change Classifier');
+      expect(changeClassifier._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(changeClassifier).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+});
+
+describe('Ingestion server', () => {
+  const instance = startServer(0); // random port
+
+  afterAll(() => new Promise<void>(resolve => instance.server.close(() => resolve())));
+
+  it('GET /health returns 200', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.status).toBe('ok');
+    expect(body.service).toBe('Ingestion');
+  });
+
+  it('GET /metrics returns request counts', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/metrics`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.requests_total).toBe('number');
+  });
+
+  it('GET /modules lists all registered modules', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/modules`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Array<Record<string, unknown>>;
+    expect(body.length).toBe(2);
+  });
+
+  it('GET /unknown returns 404', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/unknown`);
+    expect(res.status).toBe(404);
+  });
+});

examples/phoenix-self/src/generated/ingestion/change-classifier.ts

···
+export type ChangeClass = 'A' | 'B' | 'C' | 'D';
+
+export interface ClassificationResult {
+  change_class: ChangeClass;
+  confidence: number;
+  signals: {
+    norm_diff: number;
+    semhash_delta: boolean;
+    context_delta: boolean;
+    term_ref_delta: number;
+  };
+}
+
+export interface DRateMetrics {
+  current_rate: number;
+  rolling_window: number[];
+  alarm_active: boolean;
+}
+
+export class ChangeClassifier {
+  private dRateWindow: number[] = [];
+
+  classify(normDiff: number, semhashDelta: boolean, contextDelta: boolean, termDelta: number): ClassificationResult {
+    if (!semhashDelta) {
+      return { change_class: 'A', confidence: 0.95, signals: { norm_diff: normDiff, semhash_delta: false, context_delta: contextDelta, term_ref_delta: termDelta } };
+    }
+    if (normDiff < 0.1 && termDelta < 0.2) {
+      return { change_class: 'A', confidence: 0.85, signals: { norm_diff: normDiff, semhash_delta: true, context_delta: contextDelta, term_ref_delta: termDelta } };
+    }
+    if (contextDelta) {
+      return { change_class: 'C', confidence: 0.8, signals: { norm_diff: normDiff, semhash_delta: true, context_delta: true, term_ref_delta: termDelta } };
+    }
+    if (normDiff < 0.5 && termDelta < 0.5) {
+      return { change_class: 'B', confidence: 0.8, signals: { norm_diff: normDiff, semhash_delta: true, context_delta: false, term_ref_delta: termDelta } };
+    }
+    return { change_class: 'D', confidence: 0.4, signals: { norm_diff: normDiff, semhash_delta: true, context_delta: contextDelta, term_ref_delta: termDelta } };
+  }
+
+  recordClassification(result: ClassificationResult): void {
+    this.dRateWindow.push(result.change_class === 'D' ? 1 : 0);
+    if (this.dRateWindow.length > 100) this.dRateWindow.shift();
+  }
+
+  getDRateMetrics(): DRateMetrics {
+    const total = this.dRateWindow.length;
+    const dCount = this.dRateWindow.reduce((s, v) => s + v, 0);
+    const rate = total > 0 ? dCount / total : 0;
+    return { current_rate: rate, rolling_window: [...this.dRateWindow], alarm_active: rate > 0.15 };
+  }
+}
+
+export function createChangeClassifier(): ChangeClassifier {
+  return new ChangeClassifier();
+}
+
+export const _phoenix = {
+  iu_id: 'e5f6a7b8',
+  name: 'Change Classifier',
+  risk_tier: 'high',
+  canon_ids: [3, 4],
+} as const;

examples/phoenix-self/src/generated/ingestion/index.ts

···
+export * as specParser from './spec-parser.js';
+export * as changeClassifier from './change-classifier.js';

examples/phoenix-self/src/generated/ingestion/server.ts

···
+/**
+ * Ingestion — HTTP Server
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Provides health check, metrics, and module endpoints.
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'node:http';
+
+import * as specParser from './spec-parser.js';
+import * as changeClassifier from './change-classifier.js';
+
+// ─── Metrics ─────────────────────────────────────────────────────────────────
+
+const _svcMetrics = {
+  requests_total: 0,
+  requests_by_path: {} as Record<string, number>,
+  errors_total: 0,
+  uptime_start: Date.now(),
+};
+
+// ─── Module Registry ─────────────────────────────────────────────────────────
+
+const _svcModules = {
+  'spec-parser': specParser,
+  'change-classifier': changeClassifier,
+};
+
+// ─── Router ──────────────────────────────────────────────────────────────────
+
+type Handler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+
+const routes: Record<string, Handler> = {
+  '/health': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      service: 'Ingestion',
+      uptime: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+      modules: Object.keys(_svcModules),
+    }));
+  },
+
+  '/metrics': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      ..._svcMetrics,
+      uptime_seconds: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+    }, null, 2));
+  },
+
+  '/modules': (_req, res) => {
+    const info = Object.entries(_svcModules).map(([name, mod]) => {
+      const phoenix = (mod as Record<string, unknown>)._phoenix as Record<string, unknown> | undefined;
+      return {
+        name,
+        risk_tier: phoenix?.risk_tier ?? 'unknown',
+        exports: Object.keys(mod).filter(k => k !== '_phoenix'),
+      };
+    });
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(info, null, 2));
+  },
+};
+
+// ─── Server ──────────────────────────────────────────────────────────────────
+
+function handleRequest(req: IncomingMessage, res: ServerResponse): void {
+  const url = req.url ?? '/';
+  const path = url.split('?')[0];
+
+  _svcMetrics.requests_total++;
+  _svcMetrics.requests_by_path[path] = (_svcMetrics.requests_by_path[path] ?? 0) + 1;
+
+  const handler = routes[path];
+  if (handler) {
+    try {
+      handler(req, res);
+    } catch (err) {
+      _svcMetrics.errors_total++;
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      error: 'Not Found',
+      path,
+      available: Object.keys(routes),
+    }));
+  }
+}
+
+export function startServer(port?: number): { server: ReturnType<typeof createServer>; port: number; ready: Promise<void> } {
+  const requestedPort = port ?? parseInt(process.env.INGESTION_PORT ?? process.env.PORT ?? '3001', 10);
+  const server = createServer(handleRequest);
+  let actualPort = requestedPort;
+
+  const ready = new Promise<void>(resolve => {
+    server.listen(requestedPort, () => {
+      const addr = server.address();
+      if (addr && typeof addr === 'object') actualPort = addr.port;
+      result.port = actualPort;
+      console.log(`Ingestion listening on http://localhost:${actualPort}`);
+      console.log(`  /health   — health check`);
+      console.log(`  /metrics  — request metrics`);
+      console.log(`  /modules  — registered modules`);
+      resolve();
+    });
+  });
+
+  const result = { server, port: actualPort, ready };
+  return result;
+}
+
+// Start when run directly
+const isMain = process.argv[1]?.endsWith('/ingestion/server.js') ||
+               process.argv[1]?.endsWith('/ingestion/server.ts');
+if (isMain) {
+  startServer();
+}

examples/phoenix-self/src/generated/ingestion/spec-parser.ts

···
+import { createHash } from 'node:crypto';
+
+export interface Clause {
+  clause_id: string;
+  source_doc_id: string;
+  source_line_range: [number, number];
+  raw_text: string;
+  normalized_text: string;
+  section_path: string[];
+  clause_semhash: string;
+  context_semhash_cold: string;
+}
+
+export class SpecParser {
+  parseDocument(docId: string, content: string): Clause[] {
+    const sections = content.split(/^(?=# )/m);
+    const clauses: Clause[] = [];
+    let lineOffset = 0;
+
+    for (const section of sections) {
+      if (!section.trim()) { lineOffset += section.split('\n').length; continue; }
+      const lines = section.split('\n');
+      const normalized = section.replace(/\s+/g, ' ').trim().toLowerCase();
+      const semhash = createHash('sha256').update(normalized).digest('hex');
+      const sectionPath = this.extractSectionPath(lines[0] ?? '');
+
+      clauses.push({
+        clause_id: createHash('sha256').update(`${docId}\x00${semhash}`).digest('hex').slice(0, 16),
+        source_doc_id: docId,
+        source_line_range: [lineOffset + 1, lineOffset + lines.length],
+        raw_text: section.trim(),
+        normalized_text: normalized,
+        section_path: sectionPath,
+        clause_semhash: semhash,
+        context_semhash_cold: createHash('sha256').update(`${normalized}\x00${sectionPath.join('/')}`).digest('hex'),
+      });
+      lineOffset += lines.length;
+    }
+    return clauses;
+  }
+
+  private extractSectionPath(heading: string): string[] {
+    const match = heading.match(/^(#{1,6})\s+(.*)/);
+    if (!match) return [];
+    return [match[2].trim()];
+  }
+}
+
+export function createSpecParser(): SpecParser {
+  return new SpecParser();
+}
+
+export const _phoenix = {
+  iu_id: 'a1b2c3d4',
+  name: 'Spec Parser',
+  risk_tier: 'high',
+  canon_ids: [1, 2],
+} as const;

examples/phoenix-self/src/generated/integrity/__tests__/integrity.test.ts

···
+/**
+ * Integrity — Generated Tests
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Tests module structure, server health, and Phoenix traceability.
+ */
+
+import { describe, it, expect, afterAll } from 'vitest';
+import { startServer } from '../server.js';
+
+import * as driftDetector from '../drift-detector.js';
+import * as evidenceEngine from '../evidence-engine.js';
+import * as cascadePropagator from '../cascade-propagator.js';
+
+describe('Integrity modules', () => {
+  describe('Drift Detector', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(driftDetector._phoenix).toBeDefined();
+      expect(driftDetector._phoenix.name).toBe('Drift Detector');
+      expect(driftDetector._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(driftDetector).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Evidence Engine', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(evidenceEngine._phoenix).toBeDefined();
+      expect(evidenceEngine._phoenix.name).toBe('Evidence Engine');
+      expect(evidenceEngine._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(evidenceEngine).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Cascade Propagator', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(cascadePropagator._phoenix).toBeDefined();
+      expect(cascadePropagator._phoenix.name).toBe('Cascade Propagator');
+      expect(cascadePropagator._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(cascadePropagator).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+});
+
+describe('Integrity server', () => {
+  const instance = startServer(0); // random port
+
+  afterAll(() => new Promise<void>(resolve => instance.server.close(() => resolve())));
+
+  it('GET /health returns 200', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.status).toBe('ok');
+    expect(body.service).toBe('Integrity');
+  });
+
+  it('GET /metrics returns request counts', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/metrics`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.requests_total).toBe('number');
+  });
+
+  it('GET /modules lists all registered modules', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/modules`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Array<Record<string, unknown>>;
+    expect(body.length).toBe(3);
+  });
+
+  it('GET /unknown returns 404', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/unknown`);
+    expect(res.status).toBe(404);
+  });
+});

examples/phoenix-self/src/generated/integrity/cascade-propagator.ts

···
+/**
+ * Cascade Propagator — integrity module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Traverses dependency graphs to propagate failures and determine cascade effects.
+ */
+
+export interface CascadeResult {
+  blocked: string[];
+  rerunRequired: { iuId: string; checks: string[] }[];
+}
+
+const MAX_DEPTH = 10;
+
+export class CascadePropagator {
+  propagate(failedIuId: string, dependencyGraph: Map<string, string[]>): CascadeResult {
+    const blocked = new Set<string>();
+    const rerunMap = new Map<string, Set<string>>();
+
+    this.traverse(failedIuId, dependencyGraph, blocked, rerunMap, 0);
+
+    const rerunRequired = Array.from(rerunMap.entries()).map(([iuId, checks]) => ({
+      iuId,
+      checks: Array.from(checks),
+    }));
+
+    return {
+      blocked: Array.from(blocked),
+      rerunRequired,
+    };
+  }
+
+  private traverse(
+    nodeId: string,
+    graph: Map<string, string[]>,
+    blocked: Set<string>,
+    rerunMap: Map<string, Set<string>>,
+    depth: number,
+  ): void {
+    if (depth >= MAX_DEPTH) return;
+
+    // Find all nodes that depend on nodeId (dependents)
+    for (const [dependent, dependencies] of graph.entries()) {
+      if (dependencies.includes(nodeId) && !blocked.has(dependent)) {
+        blocked.add(dependent);
+
+        // Determine checks that need rerun
+        const checks = new Set<string>(['unit_tests', 'boundary_validation']);
+        if (depth > 2) checks.add('integration_tests');
+        rerunMap.set(dependent, checks);
+
+        // Recurse into further dependents
+        this.traverse(dependent, graph, blocked, rerunMap, depth + 1);
+      }
+    }
+  }
+}
+
+export function createCascadePropagator(): CascadePropagator {
+  return new CascadePropagator();
+}
+
+export const _phoenix = {
+  iu_id: 'e5f6a7b8',
+  name: 'Cascade Propagator',
+  risk_tier: 'critical',
+  canon_ids: [14],
+} as const;

examples/phoenix-self/src/generated/integrity/drift-detector.ts

···
+/**
+ * Drift Detector — integrity module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Detects drift between expected and actual file hashes.
+ */
+
+export type DriftLabel = 'promote_to_requirement' | 'waiver' | 'temporary_patch' | null;
+
+export interface DriftResult {
+  file: string;
+  drifted: boolean;
+  label: DriftLabel;
+}
+
+export interface DriftEvent {
+  file: string;
+  expectedHash: string;
+  actualHash: string;
+  drifted: boolean;
+  label: DriftLabel;
+  timestamp: number;
+}
+
+export class DriftDetector {
+  private events: DriftEvent[] = [];
+
+  checkDrift(filePath: string, expectedHash: string, actualHash: string): DriftResult {
+    const drifted = expectedHash !== actualHash;
+    let label: DriftLabel = null;
+
+    if (drifted) {
+      // Classify the drift based on hash distance heuristics
+      const hashPrefix = actualHash.slice(0, 4);
+      const expectedPrefix = expectedHash.slice(0, 4);
+
+      if (hashPrefix === expectedPrefix) {
+        label = 'temporary_patch';
+      } else if (actualHash.length !== expectedHash.length) {
+        label = 'waiver';
+      } else {
+        label = 'promote_to_requirement';
+      }
+    }
+
+    const event: DriftEvent = {
+      file: filePath,
+      expectedHash,
+      actualHash,
+      drifted,
+      label,
+      timestamp: Date.now(),
+    };
+    this.events.push(event);
+
+    return { file: filePath, drifted, label };
+  }
+
+  getEvents(): DriftEvent[] {
+    return [...this.events];
+  }
+
+  getDriftCount(): number {
+    return this.events.filter(e => e.drifted).length;
+  }
+}
+
+export function createDriftDetector(): DriftDetector {
+  return new DriftDetector();
+}
+
+export const _phoenix = {
+  iu_id: 'c1d2e3f4',
+  name: 'Drift Detector',
+  risk_tier: 'high',
+  canon_ids: [12],
+} as const;

examples/phoenix-self/src/generated/integrity/evidence-engine.ts

···
+/**
+ * Evidence Engine — integrity module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Determines required evidence per risk tier and binds evidence to canon/IU pairs.
+ */
+
+export type RiskTier = 'low' | 'medium' | 'high' | 'critical';
+
+export interface EvidenceBinding {
+  canonId: number;
+  iuId: string;
+  artifactHash: string;
+  timestamp: number;
+}
+
+const EVIDENCE_BY_TIER: Record<RiskTier, string[]> = {
+  low: ['typecheck', 'lint', 'boundary_validation'],
+  medium: ['typecheck', 'lint', 'boundary_validation', 'unit_tests'],
+  high: ['typecheck', 'lint', 'boundary_validation', 'unit_tests', 'property_tests', 'threat_note', 'static_analysis'],
+  critical: ['typecheck', 'lint', 'boundary_validation', 'unit_tests', 'property_tests', 'threat_note', 'static_analysis', 'human_signoff'],
+};
+
+export class EvidenceEngine {
+  private bindings: EvidenceBinding[] = [];
+
+  getRequirements(riskTier: RiskTier): string[] {
+    return [...EVIDENCE_BY_TIER[riskTier]];
+  }
+
+  bindEvidence(canonId: number, iuId: string, artifactHash: string): EvidenceBinding {
+    const binding: EvidenceBinding = {
+      canonId,
+      iuId,
+      artifactHash,
+      timestamp: Date.now(),
+    };
+    this.bindings.push(binding);
+    return binding;
+  }
+
+  getBindings(): EvidenceBinding[] {
+    return [...this.bindings];
+  }
+}
+
+export function createEvidenceEngine(): EvidenceEngine {
+  return new EvidenceEngine();
+}
+
+export const _phoenix = {
+  iu_id: 'd3e4f5a6',
+  name: 'Evidence Engine',
+  risk_tier: 'high',
+  canon_ids: [13],
+} as const;

examples/phoenix-self/src/generated/integrity/index.ts

···
+export * as driftDetector from './drift-detector.js';
+export * as evidenceEngine from './evidence-engine.js';
+export * as cascadePropagator from './cascade-propagator.js';

examples/phoenix-self/src/generated/integrity/server.ts

···
+/**
+ * Integrity — HTTP Server
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Provides health check, metrics, and module endpoints.
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'node:http';
+
+import * as driftDetector from './drift-detector.js';
+import * as evidenceEngine from './evidence-engine.js';
+import * as cascadePropagator from './cascade-propagator.js';
+
+// ─── Metrics ─────────────────────────────────────────────────────────────────
+
+const _svcMetrics = {
+  requests_total: 0,
+  requests_by_path: {} as Record<string, number>,
+  errors_total: 0,
+  uptime_start: Date.now(),
+};
+
+// ─── Module Registry ─────────────────────────────────────────────────────────
+
+const _svcModules = {
+  'drift-detector': driftDetector,
+  'evidence-engine': evidenceEngine,
+  'cascade-propagator': cascadePropagator,
+};
+
+// ─── Router ──────────────────────────────────────────────────────────────────
+
+type Handler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+
+const routes: Record<string, Handler> = {
+  '/health': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      service: 'Integrity',
+      uptime: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+      modules: Object.keys(_svcModules),
+    }));
+  },
+
+  '/metrics': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      ..._svcMetrics,
+      uptime_seconds: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+    }, null, 2));
+  },
+
+  '/modules': (_req, res) => {
+    const info = Object.entries(_svcModules).map(([name, mod]) => {
+      const phoenix = (mod as Record<string, unknown>)._phoenix as Record<string, unknown> | undefined;
+      return {
+        name,
+        risk_tier: phoenix?.risk_tier ?? 'unknown',
+        exports: Object.keys(mod).filter(k => k !== '_phoenix'),
+      };
+    });
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(info, null, 2));
+  },
+};
+
+// ─── Server ──────────────────────────────────────────────────────────────────
+
+function handleRequest(req: IncomingMessage, res: ServerResponse): void {
+  const url = req.url ?? '/';
+  const path = url.split('?')[0];
+
+  _svcMetrics.requests_total++;
+  _svcMetrics.requests_by_path[path] = (_svcMetrics.requests_by_path[path] ?? 0) + 1;
+
+  const handler = routes[path];
+  if (handler) {
+    try {
+      handler(req, res);
+    } catch (err) {
+      _svcMetrics.errors_total++;
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      error: 'Not Found',
+      path,
+      available: Object.keys(routes),
+    }));
+  }
+}
+
+export function startServer(port?: number): { server: ReturnType<typeof createServer>; port: number; ready: Promise<void> } {
+  const requestedPort = port ?? parseInt(process.env.INTEGRITY_PORT ?? process.env.PORT ?? '3004', 10);
+  const server = createServer(handleRequest);
+  let actualPort = requestedPort;
+
+  const ready = new Promise<void>(resolve => {
+    server.listen(requestedPort, () => {
+      const addr = server.address();
+      if (addr && typeof addr === 'object') actualPort = addr.port;
+      result.port = actualPort;
+      console.log(`Integrity listening on http://localhost:${actualPort}`);
+      console.log(`  /health   — health check`);
+      console.log(`  /metrics  — request metrics`);
+      console.log(`  /modules  — registered modules`);
+      resolve();
+    });
+  });
+
+  const result = { server, port: actualPort, ready };
+  return result;
+}
+
+// Start when run directly
+const isMain = process.argv[1]?.endsWith('/integrity/server.js') ||
+               process.argv[1]?.endsWith('/integrity/server.ts');
+if (isMain) {
+  startServer();
+}

examples/phoenix-self/src/generated/operations/__tests__/operations.test.ts

···
+/**
+ * Operations — Generated Tests
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Tests module structure, server health, and Phoenix traceability.
+ */
+
+import { describe, it, expect, afterAll } from 'vitest';
+import { startServer } from '../server.js';
+
+import * as compaction from '../compaction.js';
+import * as diagnostics from '../diagnostics.js';
+import * as bootstrap from '../bootstrap.js';
+
+describe('Operations modules', () => {
+  describe('Compaction', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(compaction._phoenix).toBeDefined();
+      expect(compaction._phoenix.name).toBe('Compaction');
+      expect(compaction._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(compaction).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Diagnostics', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(diagnostics._phoenix).toBeDefined();
+      expect(diagnostics._phoenix.name).toBe('Diagnostics');
+      expect(diagnostics._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(diagnostics).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Bootstrap', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(bootstrap._phoenix).toBeDefined();
+      expect(bootstrap._phoenix.name).toBe('Bootstrap');
+      expect(bootstrap._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(bootstrap).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+});
+
+describe('Operations server', () => {
+  const instance = startServer(0); // random port
+
+  afterAll(() => new Promise<void>(resolve => instance.server.close(() => resolve())));
+
+  it('GET /health returns 200', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.status).toBe('ok');
+    expect(body.service).toBe('Operations');
+  });
+
+  it('GET /metrics returns request counts', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/metrics`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.requests_total).toBe('number');
+  });
+
+  it('GET /modules lists all registered modules', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/modules`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Array<Record<string, unknown>>;
+    expect(body.length).toBe(3);
+  });
+
+  it('GET /unknown returns 404', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/unknown`);
+    expect(res.status).toBe(404);
+  });
+});

examples/phoenix-self/src/generated/operations/bootstrap.ts

···
+/**
+ * Bootstrap — operations module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Orchestrates system bootstrap through defined phases.
+ */
+
+export type BootstrapPhase = 'COLD_PASS' | 'CANONICALIZATION' | 'WARM_PASS' | 'DASHBOARD' | 'COMPLETE';
+export type SystemState = 'BOOTSTRAP_COLD' | 'BOOTSTRAP_WARMING' | 'STEADY_STATE';
+
+const PHASE_ORDER: BootstrapPhase[] = ['COLD_PASS', 'CANONICALIZATION', 'WARM_PASS', 'DASHBOARD', 'COMPLETE'];
+
+const PHASE_TO_STATE: Record<BootstrapPhase, SystemState> = {
+  COLD_PASS: 'BOOTSTRAP_COLD',
+  CANONICALIZATION: 'BOOTSTRAP_COLD',
+  WARM_PASS: 'BOOTSTRAP_WARMING',
+  DASHBOARD: 'BOOTSTRAP_WARMING',
+  COMPLETE: 'STEADY_STATE',
+};
+
+export class BootstrapOrchestrator {
+  private _currentPhase: BootstrapPhase = 'COLD_PASS';
+
+  get currentPhase(): BootstrapPhase {
+    return this._currentPhase;
+  }
+
+  get systemState(): SystemState {
+    return PHASE_TO_STATE[this._currentPhase];
+  }
+
+  runPhase(): BootstrapPhase {
+    const currentIndex = PHASE_ORDER.indexOf(this._currentPhase);
+    if (currentIndex < PHASE_ORDER.length - 1) {
+      this._currentPhase = PHASE_ORDER[currentIndex + 1];
+    }
+    return this._currentPhase;
+  }
+
+  isComplete(): boolean {
+    return this._currentPhase === 'COMPLETE';
+  }
+}
+
+export function createBootstrapOrchestrator(): BootstrapOrchestrator {
+  return new BootstrapOrchestrator();
+}
+
+export const _phoenix = {
+  iu_id: 'b5c6d7e8',
+  name: 'Bootstrap',
+  risk_tier: 'high',
+  canon_ids: [17],
+} as const;

examples/phoenix-self/src/generated/operations/compaction.ts

···
+/**
+ * Compaction — operations module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Manages graph compaction with protected node types that are never deleted.
+ */
+
+import { createHash } from 'node:crypto';
+
+export type StorageTier = 'hot' | 'ancestry' | 'cold';
+
+export interface CompactionEvent {
+  id: string;
+  timestamp: number;
+  trigger: 'size' | 'upgrade' | 'time';
+  nodes_compacted: number;
+}
+
+const PROTECTED_SET = new Set([
+  'node_headers',
+  'provenance_edges',
+  'approvals',
+  'signatures',
+]);
+
+export class CompactionEngine {
+  private events: CompactionEvent[] = [];
+
+  checkTriggers(hotGraphSize: number, lastCompaction: number): boolean {
+    const now = Date.now();
+    const timeSinceLastCompaction = now - lastCompaction;
+
+    // Trigger on size threshold (>1000 nodes)
+    if (hotGraphSize > 1000) return true;
+
+    // Trigger on time threshold (>24 hours since last compaction)
+    if (timeSinceLastCompaction > 24 * 60 * 60 * 1000) return true;
+
+    return false;
+  }
+
+  compact(nodes: Array<{ id: string; type: string; data: Record<string, unknown> }>): CompactionEvent {
+    // Filter out protected nodes — never delete them
+    const compactable = nodes.filter(n => !PROTECTED_SET.has(n.type));
+
+    const event: CompactionEvent = {
+      id: createHash('sha256').update(`compact-${Date.now()}-${compactable.length}`).digest('hex').slice(0, 16),
+      timestamp: Date.now(),
+      trigger: compactable.length > 500 ? 'size' : 'time',
+      nodes_compacted: compactable.length,
+    };
+
+    this.events.push(event);
+    return event;
+  }
+
+  getEvents(): CompactionEvent[] {
+    return [...this.events];
+  }
+
+  getProtectedTypes(): string[] {
+    return Array.from(PROTECTED_SET);
+  }
+}
+
+export function createCompactionEngine(): CompactionEngine {
+  return new CompactionEngine();
+}
+
+export const _phoenix = {
+  iu_id: 'f1a2b3c4',
+  name: 'Compaction',
+  risk_tier: 'medium',
+  canon_ids: [15],
+} as const;

examples/phoenix-self/src/generated/operations/diagnostics.ts

···
+/**
+ * Diagnostics — operations module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Collects and organizes diagnostic status items by severity.
+ */
+
+export type Severity = 'error' | 'warning' | 'info';
+
+export interface StatusItem {
+  severity: Severity;
+  category: string;
+  subject: string;
+  message: string;
+  recommended_actions: string[];
+}
+
+export interface GroupedItems {
+  error: StatusItem[];
+  warning: StatusItem[];
+  info: StatusItem[];
+}
+
+export class DiagnosticsEngine {
+  private items: StatusItem[] = [];
+
+  addItem(item: StatusItem): void {
+    this.items.push(item);
+  }
+
+  getItems(): GroupedItems {
+    return {
+      error: this.items.filter(i => i.severity === 'error'),
+      warning: this.items.filter(i => i.severity === 'warning'),
+      info: this.items.filter(i => i.severity === 'info'),
+    };
+  }
+
+  getAllItems(): StatusItem[] {
+    return [...this.items];
+  }
+
+  clear(): void {
+    this.items = [];
+  }
+}
+
+export function createDiagnosticsEngine(): DiagnosticsEngine {
+  return new DiagnosticsEngine();
+}
+
+export const _phoenix = {
+  iu_id: 'a3b4c5d6',
+  name: 'Diagnostics',
+  risk_tier: 'medium',
+  canon_ids: [16],
+} as const;

examples/phoenix-self/src/generated/operations/index.ts

···
+export * as compaction from './compaction.js';
+export * as diagnostics from './diagnostics.js';
+export * as bootstrap from './bootstrap.js';

examples/phoenix-self/src/generated/operations/server.ts

···
+/**
+ * Operations — HTTP Server
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Provides health check, metrics, and module endpoints.
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'node:http';
+
+import * as compaction from './compaction.js';
+import * as diagnostics from './diagnostics.js';
+import * as bootstrap from './bootstrap.js';
+
+// ─── Metrics ─────────────────────────────────────────────────────────────────
+
+const _svcMetrics = {
+  requests_total: 0,
+  requests_by_path: {} as Record<string, number>,
+  errors_total: 0,
+  uptime_start: Date.now(),
+};
+
+// ─── Module Registry ─────────────────────────────────────────────────────────
+
+const _svcModules = {
+  'compaction': compaction,
+  'diagnostics': diagnostics,
+  'bootstrap': bootstrap,
+};
+
+// ─── Router ──────────────────────────────────────────────────────────────────
+
+type Handler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+
+const routes: Record<string, Handler> = {
+  '/health': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      service: 'Operations',
+      uptime: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+      modules: Object.keys(_svcModules),
+    }));
+  },
+
+  '/metrics': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      ..._svcMetrics,
+      uptime_seconds: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+    }, null, 2));
+  },
+
+  '/modules': (_req, res) => {
+    const info = Object.entries(_svcModules).map(([name, mod]) => {
+      const phoenix = (mod as Record<string, unknown>)._phoenix as Record<string, unknown> | undefined;
+      return {
+        name,
+        risk_tier: phoenix?.risk_tier ?? 'unknown',
+        exports: Object.keys(mod).filter(k => k !== '_phoenix'),
+      };
+    });
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(info, null, 2));
+  },
+};
+
+// ─── Server ──────────────────────────────────────────────────────────────────
+
+function handleRequest(req: IncomingMessage, res: ServerResponse): void {
+  const url = req.url ?? '/';
+  const path = url.split('?')[0];
+
+  _svcMetrics.requests_total++;
+  _svcMetrics.requests_by_path[path] = (_svcMetrics.requests_by_path[path] ?? 0) + 1;
+
+  const handler = routes[path];
+  if (handler) {
+    try {
+      handler(req, res);
+    } catch (err) {
+      _svcMetrics.errors_total++;
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      error: 'Not Found',
+      path,
+      available: Object.keys(routes),
+    }));
+  }
+}
+
+export function startServer(port?: number): { server: ReturnType<typeof createServer>; port: number; ready: Promise<void> } {
+  const requestedPort = port ?? parseInt(process.env.OPERATIONS_PORT ?? process.env.PORT ?? '3005', 10);
+  const server = createServer(handleRequest);
+  let actualPort = requestedPort;
+
+  const ready = new Promise<void>(resolve => {
+    server.listen(requestedPort, () => {
+      const addr = server.address();
+      if (addr && typeof addr === 'object') actualPort = addr.port;
+      result.port = actualPort;
+      console.log(`Operations listening on http://localhost:${actualPort}`);
+      console.log(`  /health   — health check`);
+      console.log(`  /metrics  — request metrics`);
+      console.log(`  /modules  — registered modules`);
+      resolve();
+    });
+  });
+
+  const result = { server, port: actualPort, ready };
+  return result;
+}
+
+// Start when run directly
+const isMain = process.argv[1]?.endsWith('/operations/server.js') ||
+               process.argv[1]?.endsWith('/operations/server.ts');
+if (isMain) {
+  startServer();
+}

examples/phoenix-self/src/generated/platform/__tests__/platform.test.ts

···
+/**
+ * Platform — Generated Tests
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Tests module structure, server health, and Phoenix traceability.
+ */
+
+import { describe, it, expect, afterAll } from 'vitest';
+import { startServer } from '../server.js';
+
+import * as graphStore from '../graph-store.js';
+import * as botRouter from '../bot-router.js';
+
+describe('Platform modules', () => {
+  describe('Graph Store', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(graphStore._phoenix).toBeDefined();
+      expect(graphStore._phoenix.name).toBe('Graph Store');
+      expect(graphStore._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(graphStore).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Bot Router', () => {
+    it('exports Phoenix traceability metadata', () => {
+      expect(botRouter._phoenix).toBeDefined();
+      expect(botRouter._phoenix.name).toBe('Bot Router');
+      expect(botRouter._phoenix.risk_tier).toBeTruthy();
+    });
+
+    it('has exported functions', () => {
+      const exports = Object.keys(botRouter).filter(k => k !== '_phoenix');
+      expect(exports.length).toBeGreaterThan(0);
+    });
+  });
+
+});
+
+describe('Platform server', () => {
+  const instance = startServer(0); // random port
+
+  afterAll(() => new Promise<void>(resolve => instance.server.close(() => resolve())));
+
+  it('GET /health returns 200', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.status).toBe('ok');
+    expect(body.service).toBe('Platform');
+  });
+
+  it('GET /metrics returns request counts', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/metrics`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.requests_total).toBe('number');
+  });
+
+  it('GET /modules lists all registered modules', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/modules`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Array<Record<string, unknown>>;
+    expect(body.length).toBe(2);
+  });
+
+  it('GET /unknown returns 404', async () => {
+    await instance.ready;
+    const res = await fetch(`http://localhost:${instance.port}/unknown`);
+    expect(res.status).toBe(404);
+  });
+});

examples/phoenix-self/src/generated/platform/bot-router.ts

···
+/**
+ * Bot Router — platform module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Routes commands to registered bots with mutation safety.
+ */
+
+export type CommandHandler = (args: string) => { result: string; mutating: boolean };
+
+export interface Bot {
+  name: string;
+  commands: Map<string, CommandHandler>;
+}
+
+export interface CommandResult {
+  bot: string;
+  command: string;
+  result: string;
+  mutating: boolean;
+  needsConfirmation: boolean;
+  intent?: string;
+}
+
+export class BotRouter {
+  private bots: Map<string, Bot> = new Map();
+
+  constructor() {
+    // Register built-in commands
+    const builtinBot: Bot = {
+      name: '_system',
+      commands: new Map<string, CommandHandler>([
+        ['help', () => ({
+          result: `Available bots: ${Array.from(this.bots.keys()).join(', ')}`,
+          mutating: false,
+        })],
+        ['commands', () => {
+          const allCommands: string[] = [];
+          for (const [botName, bot] of this.bots.entries()) {
+            for (const cmd of bot.commands.keys()) {
+              allCommands.push(`${botName}:${cmd}`);
+            }
+          }
+          return { result: allCommands.join(', '), mutating: false };
+        }],
+        ['version', () => ({
+          result: 'Phoenix Bot Router v1.0.0',
+          mutating: false,
+        })],
+      ]),
+    };
+    this.bots.set('_system', builtinBot);
+  }
+
+  registerBot(bot: Bot): void {
+    this.bots.set(bot.name, bot);
+  }
+
+  routeCommand(input: string): CommandResult {
+    // Parse input: "botname:command args" or "command args" (for system)
+    const colonIndex = input.indexOf(':');
+    let botName: string;
+    let rest: string;
+
+    if (colonIndex >= 0) {
+      botName = input.slice(0, colonIndex);
+      rest = input.slice(colonIndex + 1);
+    } else {
+      botName = '_system';
+      rest = input;
+    }
+
+    const spaceIndex = rest.indexOf(' ');
+    const command = spaceIndex >= 0 ? rest.slice(0, spaceIndex) : rest;
+    const args = spaceIndex >= 0 ? rest.slice(spaceIndex + 1) : '';
+
+    const bot = this.bots.get(botName);
+    if (!bot) {
+      return {
+        bot: botName,
+        command,
+        result: `Unknown bot: ${botName}`,
+        mutating: false,
+        needsConfirmation: false,
+      };
+    }
+
+    const handler = bot.commands.get(command);
+    if (!handler) {
+      return {
+        bot: botName,
+        command,
+        result: `Unknown command: ${command}`,
+        mutating: false,
+        needsConfirmation: false,
+      };
+    }
+
+    const { result, mutating } = handler(args);
+
+    if (mutating) {
+      return {
+        bot: botName,
+        command,
+        result,
+        mutating: true,
+        needsConfirmation: true,
+        intent: `${botName}:${command} ${args}`.trim(),
+      };
+    }
+
+    return {
+      bot: botName,
+      command,
+      result,
+      mutating: false,
+      needsConfirmation: false,
+    };
+  }
+}
+
+export function createBotRouter(): BotRouter {
+  return new BotRouter();
+}
+
+export const _phoenix = {
+  iu_id: 'd9e0f1a2',
+  name: 'Bot Router',
+  risk_tier: 'medium',
+  canon_ids: [19],
+} as const;

examples/phoenix-self/src/generated/platform/graph-store.ts

···
+/**
+ * Graph Store — platform module
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Content-addressed multi-graph store with provenance edges.
+ */
+
+import { createHash } from 'node:crypto';
+
+export interface GraphNode {
+  id: string;
+  type: string;
+  data: Record<string, unknown>;
+}
+
+export interface ProvenanceEdge {
+  from: string;
+  to: string;
+  transformation: string;
+  timestamp: number;
+}
+
+const NAMED_GRAPHS = ['spec', 'canonical', 'implementation', 'evidence', 'provenance'] as const;
+export type GraphName = typeof NAMED_GRAPHS[number];
+
+export class GraphStore {
+  private graphs: Record<GraphName, Map<string, GraphNode>> = {
+    spec: new Map(),
+    canonical: new Map(),
+    implementation: new Map(),
+    evidence: new Map(),
+    provenance: new Map(),
+  };
+  private provenanceEdges: ProvenanceEdge[] = [];
+
+  addNode(graphName: GraphName, node: GraphNode): string {
+    // Content-address: derive ID from data hash
+    const contentHash = createHash('sha256')
+      .update(JSON.stringify({ type: node.type, data: node.data }))
+      .digest('hex')
+      .slice(0, 16);
+
+    const addressedNode: GraphNode = { ...node, id: contentHash };
+    this.graphs[graphName].set(contentHash, addressedNode);
+    return contentHash;
+  }
+
+  getNode(graphName: GraphName, id: string): GraphNode | undefined {
+    return this.graphs[graphName].get(id);
+  }
+
+  addProvenanceEdge(edge: ProvenanceEdge): void {
+    this.provenanceEdges.push(edge);
+  }
+
+  getProvenanceEdges(): ProvenanceEdge[] {
+    return [...this.provenanceEdges];
+  }
+
+  getGraphNames(): readonly string[] {
+    return NAMED_GRAPHS;
+  }
+
+  getGraphSize(graphName: GraphName): number {
+    return this.graphs[graphName].size;
+  }
+}
+
+export function createGraphStore(): GraphStore {
+  return new GraphStore();
+}
+
+export const _phoenix = {
+  iu_id: 'c7d8e9f0',
+  name: 'Graph Store',
+  risk_tier: 'critical',
+  canon_ids: [18],
+} as const;

examples/phoenix-self/src/generated/platform/index.ts

···
+export * as graphStore from './graph-store.js';
+export * as botRouter from './bot-router.js';

examples/phoenix-self/src/generated/platform/server.ts

···
+/**
+ * Platform — HTTP Server
+ *
+ * AUTO-GENERATED by Phoenix VCS
+ * Provides health check, metrics, and module endpoints.
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'node:http';
+
+import * as graphStore from './graph-store.js';
+import * as botRouter from './bot-router.js';
+
+// ─── Metrics ─────────────────────────────────────────────────────────────────
+
+const _svcMetrics = {
+  requests_total: 0,
+  requests_by_path: {} as Record<string, number>,
+  errors_total: 0,
+  uptime_start: Date.now(),
+};
+
+// ─── Module Registry ─────────────────────────────────────────────────────────
+
+const _svcModules = {
+  'graph-store': graphStore,
+  'bot-router': botRouter,
+};
+
+// ─── Router ──────────────────────────────────────────────────────────────────
+
+type Handler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+
+const routes: Record<string, Handler> = {
+  '/health': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      service: 'Platform',
+      uptime: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+      modules: Object.keys(_svcModules),
+    }));
+  },
+
+  '/metrics': (_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      ..._svcMetrics,
+      uptime_seconds: Math.floor((Date.now() - _svcMetrics.uptime_start) / 1000),
+    }, null, 2));
+  },
+
+  '/modules': (_req, res) => {
+    const info = Object.entries(_svcModules).map(([name, mod]) => {
+      const phoenix = (mod as Record<string, unknown>)._phoenix as Record<string, unknown> | undefined;
+      return {
+        name,
+        risk_tier: phoenix?.risk_tier ?? 'unknown',
+        exports: Object.keys(mod).filter(k => k !== '_phoenix'),
+      };
+    });
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(info, null, 2));
+  },
+};
+
+// ─── Server ──────────────────────────────────────────────────────────────────
+
+function handleRequest(req: IncomingMessage, res: ServerResponse): void {
+  const url = req.url ?? '/';
+  const path = url.split('?')[0];
+
+  _svcMetrics.requests_total++;
+  _svcMetrics.requests_by_path[path] = (_svcMetrics.requests_by_path[path] ?? 0) + 1;
+
+  const handler = routes[path];
+  if (handler) {
+    try {
+      handler(req, res);
+    } catch (err) {
+      _svcMetrics.errors_total++;
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      error: 'Not Found',
+      path,
+      available: Object.keys(routes),
+    }));
+  }
+}
+
+export function startServer(port?: number): { server: ReturnType<typeof createServer>; port: number; ready: Promise<void> } {
+  const requestedPort = port ?? parseInt(process.env.PLATFORM_PORT ?? process.env.PORT ?? '3006', 10);
+  const server = createServer(handleRequest);
+  let actualPort = requestedPort;
+
+  const ready = new Promise<void>(resolve => {
+    server.listen(requestedPort, () => {
+      const addr = server.address();
+      if (addr && typeof addr === 'object') actualPort = addr.port;
+      result.port = actualPort;
+      console.log(`Platform listening on http://localhost:${actualPort}`);
+      console.log(`  /health   — health check`);
+      console.log(`  /metrics  — request metrics`);
+      console.log(`  /modules  — registered modules`);
+      resolve();
+    });
+  });
+
+  const result = { server, port: actualPort, ready };
+  return result;
+}
+
+// Start when run directly
+const isMain = process.argv[1]?.endsWith('/platform/server.js') ||
+               process.argv[1]?.endsWith('/platform/server.ts');
+if (isMain) {
+  startServer();
+}

examples/phoenix-self/tsconfig.json

···
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

examples/phoenix-self/vitest.config.ts

···
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/__tests__/**/*.test.ts'],
+  },
+});

experiments/results.tsv

···
 2026-03-26T23:23:35.323Z	0.8298	93.8	70.7	91.3	12.8	58.3	4.3	42knqt
 2026-03-26T23:26:36.687Z	0.8912	97.9	90.3	91.3	12.8	58.3	4.3	42knqt
 2026-03-26T23:43:40.140Z	0.9635	100.0	89.2	99.7	5.5	99.4	6.6	jaxkjx
[phone]T04:26:14.306Z	0.9445	97.5	86.4	99.8	8.0	98.6	5.5	duywk7

tests/eval/gold-standard.ts

···
     ],
     expectedEdges: [],
   },
+  // ─── Phoenix Self (Dog-food) ────────────────────────────────────────────
+  {
+    name: 'Phoenix: ingestion',
+    path: 'examples/phoenix-self/spec/ingestion.md',
+    docId: 'spec/ingestion.md',
+    expectedMinCoverage: 85,
+    expectedMinNodes: 15,
+    expectedMaxNodes: 40,
+    expectedNodes: [
+      { statement: 'clause_id', type: 'REQUIREMENT' },
+      { statement: 'sha-256', type: 'REQUIREMENT' },
+      { statement: 'four classes', type: 'REQUIREMENT' },
+      { statement: 'd-rate', type: 'DEFINITION' },
+      { statement: 'at most 5%', type: 'CONSTRAINT' },
+      { statement: 'above 15%', type: 'REQUIREMENT' },
+      { statement: 'normalized edit distance', type: 'REQUIREMENT' },
+      { statement: 'incidental invalidation', type: 'REQUIREMENT' },
+    ],
+    expectedEdges: [],
+  },
+  {
+    name: 'Phoenix: canonicalization',
+    path: 'examples/phoenix-self/spec/canonicalization.md',
+    docId: 'spec/canonicalization.md',
+    expectedMinCoverage: 85,
+    expectedMinNodes: 12,
+    expectedMaxNodes: 35,
+    expectedNodes: [
+      { statement: 'canon_pipeline_id', type: 'REQUIREMENT' },
+      { statement: 'pipelineupgrade', type: 'REQUIREMENT' },
+      { statement: 'confidence score', type: 'REQUIREMENT' },
+      { statement: 'shadow mode', type: 'REQUIREMENT' },
+      { statement: 'node_change_pct', type: 'REQUIREMENT' },
+      { statement: 'at most 3%', type: 'REQUIREMENT' },
+      { statement: 'reject', type: 'REQUIREMENT' },
+    ],
+    expectedEdges: [],
+  },
+  {
+    name: 'Phoenix: implementation',
+    path: 'examples/phoenix-self/spec/implementation.md',
+    docId: 'spec/implementation.md',
+    expectedMinCoverage: 85,
+    expectedMinNodes: 15,
+    expectedMaxNodes: 40,
+    expectedNodes: [
+      { statement: 'risk tier', type: 'REQUIREMENT' },
+      { statement: 'boundary policy', type: 'REQUIREMENT' },
+      { statement: 'forbidden', type: 'REQUIREMENT' },
+      { statement: 'architectural linter', type: 'REQUIREMENT' },
+      { statement: 'generated_manifest', type: 'REQUIREMENT' },
+      { statement: 'reproducible', type: 'REQUIREMENT' },
+    ],
+    expectedEdges: [],
+  },
+  {
+    name: 'Phoenix: integrity',
+    path: 'examples/phoenix-self/spec/integrity.md',
+    docId: 'spec/integrity.md',
+    expectedMinCoverage: 85,
+    expectedMinNodes: 12,
+    expectedMaxNodes: 35,
+    expectedNodes: [
+      { statement: 'generated_manifest', type: 'REQUIREMENT' },
+      { statement: 'waiver', type: 'REQUIREMENT' },
+      { statement: 'low-tier', type: 'REQUIREMENT' },
+      { statement: 'critical-tier', type: 'REQUIREMENT' },
+      { statement: 'cascade', type: 'REQUIREMENT' },
+      { statement: 'never lose', type: 'INVARIANT' },
+    ],
+    expectedEdges: [],
+  },
+  {
+    name: 'Phoenix: operations',
+    path: 'examples/phoenix-self/spec/operations.md',
+    docId: 'spec/operations.md',
+    expectedMinCoverage: 85,
+    expectedMinNodes: 12,
+    expectedMaxNodes: 35,
+    expectedNodes: [
+      { statement: 'hot graph', type: 'REQUIREMENT' },
+      { statement: 'compaction must never delete', type: 'INVARIANT' },
+      { statement: 'compactionevent', type: 'REQUIREMENT' },
+      { statement: 'severity', type: 'REQUIREMENT' },
+      { statement: 'bootstrap', type: 'REQUIREMENT' },
+      { statement: 'steady_state', type: 'REQUIREMENT' },
+    ],
+    expectedEdges: [],
+  },
+  {
+    name: 'Phoenix: platform',
+    path: 'examples/phoenix-self/spec/platform.md',
+    docId: 'spec/platform.md',
+    expectedMinCoverage: 85,
+    expectedMinNodes: 12,
+    expectedMaxNodes: 35,
+    expectedNodes: [
+      { statement: 'five interconnected graphs', type: 'REQUIREMENT' },
+      { statement: 'content-addressed', type: 'REQUIREMENT' },
+      { statement: 'provenance edges', type: 'REQUIREMENT' },
+      { statement: 'selective invalidation', type: 'REQUIREMENT' },
+      { statement: 'confirmation model', type: 'REQUIREMENT' },
+      { statement: 'brownfield', type: 'REQUIREMENT' },
+    ],
+    expectedEdges: [],
+  },
 ];