artifact-graph 0.6.0 → 0.7.0

package/dist/index.js

@@ -1,48 +1,49 @@
-// src/index.ts
-import Database from "better-sqlite3";
-import matter from "gray-matter";
-import yaml from "js-yaml";
-import { accessSync, constants as fsConstants, existsSync as existsSync2, statSync } from "fs";
-import { mkdir as mkdir4, readFile as readFile2, readdir, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename2, dirname as dirname3, extname, isAbsolute as isAbsolute3, join as join5, relative as relative2, resolve as resolve3 } from "path";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 
 // src/packet-constants.ts
-var ALWAYS_PRESENT_ITEMS = [
-  { path: "AGENTS.md", reason: "project agent instructions" },
-  { path: "CLAUDE.md", reason: "project instructions" },
-  { path: "artifacts/artifact-chain-spec.md", reason: "artifact chain specification" },
-  { path: "artifacts/blueprints/generation-packet-spec.md", reason: "generation packet spec" },
-  { path: "artifacts/blueprints/implementation-blueprint.md", reason: "implementation blueprint" },
-  { path: "artifacts/contracts/interface-contracts.md", reason: "interface contracts" },
-  { path: "artifacts/contracts/data-contracts.md", reason: "data contracts" },
-  { path: "artifacts/contracts/application-state-machines.md", reason: "application state machines" },
-  { path: "artifacts/contracts/error-model.md", reason: "error model" },
-  { path: "artifacts/contracts/report-contracts.md", reason: "report contracts" },
-  { path: "artifacts/contracts/ui-flow-contracts.md", reason: "UI flow contracts" },
-  { path: "artifacts/contracts/non-functional-budgets.md", reason: "non-functional budgets" },
-  { path: "artifacts/domain/domain-glossary.md", reason: "domain glossary" },
-  { path: "artifacts/domain/bounded-context-map.md", reason: "bounded context map" },
-  { path: "artifacts/domain/domain-invariants.md", reason: "domain invariants" },
-  { path: "artifacts/tests/rule-golden-cases.md", reason: "rule golden cases" },
-  { path: "artifacts/tests/verification-fixtures.md", reason: "verification fixtures" },
-  { path: "artifacts/design/test-strategy.md", reason: "test strategy" },
-  { path: "artifacts/traceability-matrix-v2.md", reason: "traceability matrix" }
-];
-var BASELINE_ITEMS_COUNT = ALWAYS_PRESENT_ITEMS.length;
-var BASELINE_CONSTRAINTS = [
-  { id: "C-ARCH-01", description: "\u6280\u672F\u6808\u5FC5\u987B\u4E3A TypeScript \u5168\u6808", source: "artifacts/decisions/D-ARCH-01.md" },
-  { id: "C-ARCH-03", description: "\u4E0D\u53EF\u5728 Quick Check \u8DEF\u5F84\u5F15\u5165 LLM", source: "artifacts/decisions/D-ARCH-03.md" },
-  { id: "C-ARCH-05", description: "\u4EA7\u54C1\u5F62\u6001\u4E3A Tauri v2 \u684C\u9762\u5E94\u7528\uFF0C\u4E0D\u4F7F\u7528\u5DF2\u5E9F\u5F03\u7684 Web Dashboard", source: "artifacts/decisions/D-ARCH-05.md" },
-  { id: "C-RULE-01", description: "SEC severity \u4E0D\u5141\u8BB8\u964D\u7EA7", source: "artifacts/decisions/D-RULE-01.md" },
-  { id: "C-GEN-01", description: "\u5B9E\u73B0\u84DD\u56FE\u4E0D\u5F97\u5F15\u5165 PRD \u4E2D\u672A\u51FA\u73B0\u7684\u65B0\u529F\u80FD", source: "artifacts/blueprints/implementation-blueprint.md" },
-  { id: "C-GEN-02", description: "\u6587\u4EF6\u53D8\u66F4\u5FC5\u987B\u5148\u68C0\u67E5 interface-contracts\u3001data-contracts\u3001error-model \u662F\u5426\u9700\u8981\u540C\u6B65", source: "artifacts/blueprints/implementation-blueprint.md" },
-  { id: "C-GEN-03", description: "\u4E0D\u5F97\u5C06\u5E9F\u5F03 Web Dashboard \u8BBE\u8BA1\u4F5C\u4E3A\u5B9E\u73B0\u4F9D\u636E", source: "artifacts/blueprints/implementation-blueprint.md" }
-];
-var BASELINE_CONSTRAINTS_COUNT = BASELINE_CONSTRAINTS.length;
+var ALWAYS_PRESENT_ITEMS, BASELINE_ITEMS_COUNT, BASELINE_CONSTRAINTS, BASELINE_CONSTRAINTS_COUNT;
+var init_packet_constants = __esm({
+  "src/packet-constants.ts"() {
+    "use strict";
+    ALWAYS_PRESENT_ITEMS = [
+      { path: "AGENTS.md", reason: "project agent instructions" },
+      { path: "CLAUDE.md", reason: "project instructions" },
+      { path: "artifacts/artifact-chain-spec.md", reason: "artifact chain specification" },
+      { path: "artifacts/blueprints/generation-packet-spec.md", reason: "generation packet spec" },
+      { path: "artifacts/blueprints/implementation-blueprint.md", reason: "implementation blueprint" },
+      { path: "artifacts/contracts/interface-contracts.md", reason: "interface contracts" },
+      { path: "artifacts/contracts/data-contracts.md", reason: "data contracts" },
+      { path: "artifacts/contracts/application-state-machines.md", reason: "application state machines" },
+      { path: "artifacts/contracts/error-model.md", reason: "error model" },
+      { path: "artifacts/contracts/report-contracts.md", reason: "report contracts" },
+      { path: "artifacts/contracts/ui-flow-contracts.md", reason: "UI flow contracts" },
+      { path: "artifacts/contracts/non-functional-budgets.md", reason: "non-functional budgets" },
+      { path: "artifacts/domain/domain-glossary.md", reason: "domain glossary" },
+      { path: "artifacts/domain/bounded-context-map.md", reason: "bounded context map" },
+      { path: "artifacts/domain/domain-invariants.md", reason: "domain invariants" },
+      { path: "artifacts/tests/rule-golden-cases.md", reason: "rule golden cases" },
+      { path: "artifacts/tests/verification-fixtures.md", reason: "verification fixtures" },
+      { path: "artifacts/design/test-strategy.md", reason: "test strategy" },
+      { path: "artifacts/traceability-matrix-v2.md", reason: "traceability matrix" }
+    ];
+    BASELINE_ITEMS_COUNT = ALWAYS_PRESENT_ITEMS.length;
+    BASELINE_CONSTRAINTS = [
+      { id: "C-ARCH-01", description: "\u6280\u672F\u6808\u5FC5\u987B\u4E3A TypeScript \u5168\u6808", source: "artifacts/decisions/D-ARCH-01.md" },
+      { id: "C-ARCH-03", description: "\u4E0D\u53EF\u5728 Quick Check \u8DEF\u5F84\u5F15\u5165 LLM", source: "artifacts/decisions/D-ARCH-03.md" },
+      { id: "C-ARCH-05", description: "\u4EA7\u54C1\u5F62\u6001\u4E3A Tauri v2 \u684C\u9762\u5E94\u7528\uFF0C\u4E0D\u4F7F\u7528\u5DF2\u5E9F\u5F03\u7684 Web Dashboard", source: "artifacts/decisions/D-ARCH-05.md" },
+      { id: "C-RULE-01", description: "SEC severity \u4E0D\u5141\u8BB8\u964D\u7EA7", source: "artifacts/decisions/D-RULE-01.md" },
+      { id: "C-GEN-01", description: "\u5B9E\u73B0\u84DD\u56FE\u4E0D\u5F97\u5F15\u5165 PRD \u4E2D\u672A\u51FA\u73B0\u7684\u65B0\u529F\u80FD", source: "artifacts/blueprints/implementation-blueprint.md" },
+      { id: "C-GEN-02", description: "\u6587\u4EF6\u53D8\u66F4\u5FC5\u987B\u5148\u68C0\u67E5 interface-contracts\u3001data-contracts\u3001error-model \u662F\u5426\u9700\u8981\u540C\u6B65", source: "artifacts/blueprints/implementation-blueprint.md" },
+      { id: "C-GEN-03", description: "\u4E0D\u5F97\u5C06\u5E9F\u5F03 Web Dashboard \u8BBE\u8BA1\u4F5C\u4E3A\u5B9E\u73B0\u4F9D\u636E", source: "artifacts/blueprints/implementation-blueprint.md" }
+    ];
+    BASELINE_CONSTRAINTS_COUNT = BASELINE_CONSTRAINTS.length;
+  }
+});
 
 // src/packet-validator.ts
-var MIN_VALIDATION_COMMANDS = 4;
-var VALID_PACKET_TARGET_TYPES = ["feature", "scenario", "decision", "design", "e2e_test"];
 function isPacketTargetType(type) {
   return VALID_PACKET_TARGET_TYPES.includes(type);
 }
@@ -55,7 +56,6 @@ function isPacketTargetTypeDynamic(type, schema) {
   }
   return isPacketTargetType(type);
 }
-var VALID_TARGET_TYPES = [...VALID_PACKET_TARGET_TYPES];
 function validatePacket(packet, schema) {
   const issues = [];
   if (packet.schemaVersion !== "1.0") {
@@ -233,16 +233,6 @@ function validatePacket(packet, schema) {
   const hasError = issues.some((i) => i.severity === "error");
   return { ok: !hasError, issues };
 }
-var REQUIRED_SECTIONS = [
-  "## 1. \u5B9E\u73B0\u76EE\u6807",
-  "## 2. \u4E0A\u4E0B\u6587\u6E05\u5355\u6458\u8981",
-  "## 3. Required Baseline\uFF08\u5FC5\u8BFB\u5236\u54C1\uFF09",
-  "## 8. Implementation Blueprint Draft\uFF08\u5B9E\u73B0\u84DD\u56FE\u8349\u6848\uFF09",
-  "### 8.3 \u7EA6\u675F\u4E0E\u8FB9\u754C",
-  "### 8.4 \u9A8C\u8BC1\u547D\u4EE4",
-  "### 8.5 \u63A8\u8350\u5BA1\u9605\u987A\u5E8F",
-  "### 8.6 \u98CE\u9669\u68C0\u67E5\u6E05\u5355"
-];
 function validatePacketMarkdown(markdown) {
   const issues = [];
   for (const section of REQUIRED_SECTIONS) {
@@ -258,6 +248,26 @@ function validatePacketMarkdown(markdown) {
   const hasError = issues.some((i) => i.severity === "error");
   return { ok: !hasError, issues };
 }
+var MIN_VALIDATION_COMMANDS, VALID_PACKET_TARGET_TYPES, VALID_TARGET_TYPES, REQUIRED_SECTIONS;
+var init_packet_validator = __esm({
+  "src/packet-validator.ts"() {
+    "use strict";
+    init_packet_constants();
+    MIN_VALIDATION_COMMANDS = 4;
+    VALID_PACKET_TARGET_TYPES = ["feature", "scenario", "decision", "design", "e2e_test"];
+    VALID_TARGET_TYPES = [...VALID_PACKET_TARGET_TYPES];
+    REQUIRED_SECTIONS = [
+      "## 1. \u5B9E\u73B0\u76EE\u6807",
+      "## 2. \u4E0A\u4E0B\u6587\u6E05\u5355\u6458\u8981",
+      "## 3. Required Baseline\uFF08\u5FC5\u8BFB\u5236\u54C1\uFF09",
+      "## 8. Implementation Blueprint Draft\uFF08\u5B9E\u73B0\u84DD\u56FE\u8349\u6848\uFF09",
+      "### 8.3 \u7EA6\u675F\u4E0E\u8FB9\u754C",
+      "### 8.4 \u9A8C\u8BC1\u547D\u4EE4",
+      "### 8.5 \u63A8\u8350\u5BA1\u9605\u987A\u5E8F",
+      "### 8.6 \u98CE\u9669\u68C0\u67E5\u6E05\u5355"
+    ];
+  }
+});
 
 // src/glob-matcher.ts
 function matchesRunnerGlob(filePath, pattern) {
@@ -297,6 +307,11 @@ function normalizeGlobValue(value) {
 function escapeRegexCharacter(character) {
   return "\\^$+?.()|{}[]".includes(character) ? String.fromCharCode(92) + character : character;
 }
+var init_glob_matcher = __esm({
+  "src/glob-matcher.ts"() {
+    "use strict";
+  }
+});
 
 // src/target-selector.ts
 function parseTargetSelector(value) {
@@ -306,14 +321,6 @@ function parseTargetSelector(value) {
   }
   return { type: value.slice(0, separator), id: value.slice(separator + 1) };
 }
-var LEGACY_FLAGS = ["feature", "scenario", "decision", "design", "e2e-test"];
-var LEGACY_FLAG_TO_TYPE = {
-  feature: "feature",
-  scenario: "scenario",
-  decision: "decision",
-  design: "design",
-  "e2e-test": "e2e_test"
-};
 function resolveCliTarget(flags, schema) {
   const hasTarget = typeof flags.target === "string";
   const legacyEntries = LEGACY_FLAGS.filter((flag) => typeof flags[flag] === "string").map((flag) => flag);
@@ -346,14 +353,23 @@ function resolveCliTarget(flags, schema) {
     "\u672A\u6307\u5B9A target\uFF1A\u8BF7\u4F7F\u7528 --target <type>:<id> \u6216 --feature/--scenario/--decision/--design/--e2e-test <id>"
   );
 }
+var LEGACY_FLAGS, LEGACY_FLAG_TO_TYPE;
+var init_target_selector = __esm({
+  "src/target-selector.ts"() {
+    "use strict";
+    init_index();
+    LEGACY_FLAGS = ["feature", "scenario", "decision", "design", "e2e-test"];
+    LEGACY_FLAG_TO_TYPE = {
+      feature: "feature",
+      scenario: "scenario",
+      decision: "decision",
+      design: "design",
+      "e2e-test": "e2e_test"
+    };
+  }
+});
 
 // src/packet-assembler.ts
-var DEFAULT_VALIDATION_COMMANDS = [
-  "pnpm build",
-  "pnpm test",
-  "artifact-graph validate --root . --warning-only",
-  "artifact-graph version-lock audit --root . --strict-missing-lock"
-];
 function toPacketItem(item) {
   const pi = {
     path: item.path,
@@ -490,12 +506,6 @@ function renderContextCategory(cat, opts) {
   }
   return lines;
 }
-var COMMAND_COMMENTS = {
-  "pnpm build": "\u6784\u5EFA\u9879\u76EE",
-  "pnpm test": "\u8FD0\u884C\u9879\u76EE\u6D4B\u8BD5",
-  "artifact-graph validate --root . --warning-only": "\u5236\u54C1\u94FE\u4E00\u81F4\u6027\u6821\u9A8C\uFF08warning-only\uFF09",
-  "artifact-graph version-lock audit --root . --strict-missing-lock": "\u5236\u54C1\u94FE\u7248\u672C\u9501\u4E25\u683C\u5BA1\u8BA1"
-};
 function classifyCategories(manifest) {
   let baseline = { category: "baseline", total: 0, items: [] };
   const direct = [];
@@ -792,12 +802,29 @@ function renderPacketMarkdown(packet) {
   lines.push("> \u63D0\u793A\uFF1A\u4F7F\u7528 Ctrl+F \u641C\u7D22 `[\u5FC5\u8BFB]` \u5FEB\u901F\u5B9A\u4F4D\u5FC5\u8BFB\u5236\u54C1\u3002");
   return lines.join("\n");
 }
+var DEFAULT_VALIDATION_COMMANDS, COMMAND_COMMENTS;
+var init_packet_assembler = __esm({
+  "src/packet-assembler.ts"() {
+    "use strict";
+    init_packet_constants();
+    DEFAULT_VALIDATION_COMMANDS = [
+      "pnpm build",
+      "pnpm test",
+      "artifact-graph validate --root . --warning-only",
+      "artifact-graph version-lock audit --root . --strict-missing-lock"
+    ];
+    COMMAND_COMMENTS = {
+      "pnpm build": "\u6784\u5EFA\u9879\u76EE",
+      "pnpm test": "\u8FD0\u884C\u9879\u76EE\u6D4B\u8BD5",
+      "artifact-graph validate --root . --warning-only": "\u5236\u54C1\u94FE\u4E00\u81F4\u6027\u6821\u9A8C\uFF08warning-only\uFF09",
+      "artifact-graph version-lock audit --root . --strict-missing-lock": "\u5236\u54C1\u94FE\u7248\u672C\u9501\u4E25\u683C\u5BA1\u8BA1"
+    };
+  }
+});
 
 // src/packet-audit.ts
 import { mkdir, writeFile } from "fs/promises";
 import { join } from "path";
-var VALID_TYPES = new Set(VALID_PACKET_TARGET_TYPES);
-var VALID_TYPES_LABEL = VALID_PACKET_TARGET_TYPES.join(", ");
 function parseTargetsFile(content, schema) {
   const validTypes = schema ? new Set(getTargetArtifactTypes(schema)) : VALID_TYPES;
   const validTypesLabel = [...validTypes].join(", ");
@@ -995,20 +1022,21 @@ async function discoverAndAuditPackets(root, options) {
     universalBaseline: effectiveBaseline
   }, graph);
 }
+var VALID_TYPES, VALID_TYPES_LABEL;
+var init_packet_audit = __esm({
+  "src/packet-audit.ts"() {
+    "use strict";
+    init_index();
+    init_packet_validator();
+    VALID_TYPES = new Set(VALID_PACKET_TARGET_TYPES);
+    VALID_TYPES_LABEL = VALID_PACKET_TARGET_TYPES.join(", ");
+  }
+});
 
 // src/packet-prompt.ts
-var TYPE_CLI_FLAG = {
-  feature: "feature",
-  scenario: "scenario",
-  decision: "decision",
-  design: "design",
-  e2e_test: "e2e-test"
-};
 function cliFlag(type) {
   return TYPE_CLI_FLAG[type] ?? type;
 }
-var DEFAULT_MAX_CHARS = 4e3;
-var MIN_PROMPT_CHARS = 320;
 function renderPromptHeader(packet) {
   const t = packet.target;
   const typeLabelMap = { feature: "\u529F\u80FD", scenario: "\u573A\u666F", decision: "\u51B3\u7B56", design: "\u8BBE\u8BA1\u89C4\u683C", e2e_test: "E2E \u6D4B\u8BD5" };
@@ -1232,52 +1260,24 @@ function renderPacketPrompt(packet, options) {
     minRequired: absMinText.length
   };
 }
+var TYPE_CLI_FLAG, DEFAULT_MAX_CHARS, MIN_PROMPT_CHARS;
+var init_packet_prompt = __esm({
+  "src/packet-prompt.ts"() {
+    "use strict";
+    init_packet_constants();
+    TYPE_CLI_FLAG = {
+      feature: "feature",
+      scenario: "scenario",
+      decision: "decision",
+      design: "design",
+      e2e_test: "e2e-test"
+    };
+    DEFAULT_MAX_CHARS = 4e3;
+    MIN_PROMPT_CHARS = 320;
+  }
+});
 
 // src/packet-prompt-validator.ts
-var REQUIRED_CHECKS = [
-  {
-    code: "PP-001",
-    description: "\u76EE\u6807\u4FE1\u606F",
-    test: (t) => /实现任务/.test(t),
-    severity: "error"
-  },
-  {
-    code: "PP-002",
-    description: "packet \u547D\u4EE4\u6216\u6765\u6E90\u5F15\u7528",
-    test: (t) => /packet\s+--root/.test(t) || /packet\.json/.test(t) || /artifact-graph\s+packet/.test(t),
-    severity: "error"
-  },
-  {
-    code: "PP-003",
-    description: "\u9A8C\u8BC1\u547D\u4EE4",
-    test: (t) => /验证命令/.test(t) || /artifact-graph\s+(build|test)/.test(t),
-    severity: "error"
-  },
-  {
-    code: "PP-004",
-    description: "\u63D0\u4EA4\u8981\u6C42",
-    test: (t) => /提交要求/.test(t) || /git\s+diff\s+--check/.test(t),
-    severity: "error"
-  },
-  {
-    code: "PP-005",
-    description: "\u7981\u6B62\u4E8B\u9879",
-    test: (t) => /禁止事项/.test(t),
-    severity: "error"
-  },
-  {
-    code: "PP-006",
-    description: "\u4E0D\u5F97\u56DE\u9000\u89C4\u5219",
-    test: (t) => /不得回退/.test(t) || /不要回退/.test(t) || /no[- ]?revert/i.test(t),
-    severity: "error"
-  },
-  {
-    code: "PP-007",
-    description: "SEC severity \u89C4\u5219",
-    test: (t) => /SEC\s+severity/.test(t) || /severity/.test(t) && /降级/.test(t),
-    severity: "error"
-  }
-];
 function checkChineseDominance(text) {
   const textOutsideCode = text.replace(/```[\s\S]*?```/g, "");
   const cleanText = textOutsideCode.replace(/^[#>]+ .*$/gm, "").replace(/\[.*?\]\(.*?\)/g, "");
@@ -1312,15 +1312,62 @@ function validatePacketPrompt(prompt) {
   const hasErrors = issues.some((i) => i.severity === "error");
   return { ok: !hasErrors, issues };
 }
+var REQUIRED_CHECKS;
+var init_packet_prompt_validator = __esm({
+  "src/packet-prompt-validator.ts"() {
+    "use strict";
+    REQUIRED_CHECKS = [
+      {
+        code: "PP-001",
+        description: "\u76EE\u6807\u4FE1\u606F",
+        test: (t) => /实现任务/.test(t),
+        severity: "error"
+      },
+      {
+        code: "PP-002",
+        description: "packet \u547D\u4EE4\u6216\u6765\u6E90\u5F15\u7528",
+        test: (t) => /packet\s+--root/.test(t) || /packet\.json/.test(t) || /artifact-graph\s+packet/.test(t),
+        severity: "error"
+      },
+      {
+        code: "PP-003",
+        description: "\u9A8C\u8BC1\u547D\u4EE4",
+        test: (t) => /验证命令/.test(t) || /artifact-graph\s+(build|test)/.test(t),
+        severity: "error"
+      },
+      {
+        code: "PP-004",
+        description: "\u63D0\u4EA4\u8981\u6C42",
+        test: (t) => /提交要求/.test(t) || /git\s+diff\s+--check/.test(t),
+        severity: "error"
+      },
+      {
+        code: "PP-005",
+        description: "\u7981\u6B62\u4E8B\u9879",
+        test: (t) => /禁止事项/.test(t),
+        severity: "error"
+      },
+      {
+        code: "PP-006",
+        description: "\u4E0D\u5F97\u56DE\u9000\u89C4\u5219",
+        test: (t) => /不得回退/.test(t) || /不要回退/.test(t) || /no[- ]?revert/i.test(t),
+        severity: "error"
+      },
+      {
+        code: "PP-007",
+        description: "SEC severity \u89C4\u5219",
+        test: (t) => /SEC\s+severity/.test(t) || /severity/.test(t) && /降级/.test(t),
+        severity: "error"
+      }
+    ];
+  }
+});
 
 // src/versioned-traceability.ts
 import { createHash } from "crypto";
 import { existsSync } from "fs";
 import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
 import { dirname, join as join2, relative } from "path";
-var VERSION_LOCK_PATH = "artifacts/traceability-version-lock.json";
-var VERSION_INDEX_SCHEMA_VERSION = "1.0";
-var VERSION_LOCK_SCHEMA_VERSION = "1.0";
 async function buildVersionIndex(root, graph) {
   const scannedGraph = graph ?? await scanArtifacts(root);
   const hashCache = /* @__PURE__ */ new Map();
@@ -2120,6 +2167,17 @@ async function isFileActiveInRunner(root, filePath, runner) {
 function sortUnique(items) {
   return [...new Set(items)].sort((left, right) => left.localeCompare(right));
 }
+var VERSION_LOCK_PATH, VERSION_INDEX_SCHEMA_VERSION, VERSION_LOCK_SCHEMA_VERSION;
+var init_versioned_traceability = __esm({
+  "src/versioned-traceability.ts"() {
+    "use strict";
+    init_index();
+    init_glob_matcher();
+    VERSION_LOCK_PATH = "artifacts/traceability-version-lock.json";
+    VERSION_INDEX_SCHEMA_VERSION = "1.0";
+    VERSION_LOCK_SCHEMA_VERSION = "1.0";
+  }
+});
 
 // src/cli-resolver.ts
 import { execFile } from "child_process";
@@ -2127,27 +2185,6 @@ import { constants } from "fs";
 import { access } from "fs/promises";
 import { isAbsolute, join as join3, resolve } from "path";
 import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var KNOWN_COMMANDS = [
-  "init",
-  "scan",
-  "validate",
-  "query",
-  "context",
-  "packet",
-  "packet-prompt",
-  "packet-audit",
-  "packet-prompt-audit",
-  "version-index",
-  "version-lock audit",
-  "version-lock update",
-  "version-lock bootstrap",
-  "version-lock refresh",
-  "trace-version",
-  "next-id",
-  "render",
-  "doctor"
-];
 async function resolveArtifactGraphCli(root, options = {}) {
   const pathCli = await findCommandOnPath("artifact-graph");
   const legacyCliPath = options.projectCliPath ?? process.env.ARTIFACT_GRAPH_LEGACY_CLI;
@@ -2283,11 +2320,38 @@ function isNodeCompatible(version) {
   const major = Number(version.split(".")[0]);
   return Number.isFinite(major) && major >= 22;
 }
+var execFileAsync, KNOWN_COMMANDS;
+var init_cli_resolver = __esm({
+  "src/cli-resolver.ts"() {
+    "use strict";
+    init_versioned_traceability();
+    execFileAsync = promisify(execFile);
+    KNOWN_COMMANDS = [
+      "init",
+      "scan",
+      "validate",
+      "query",
+      "context",
+      "packet",
+      "packet-prompt",
+      "packet-audit",
+      "packet-prompt-audit",
+      "version-index",
+      "version-lock audit",
+      "version-lock update",
+      "version-lock bootstrap",
+      "version-lock refresh",
+      "trace-version",
+      "next-id",
+      "render",
+      "doctor"
+    ];
+  }
+});
 
 // src/git-changes.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
 async function collectChangedPaths(root, options) {
   const args = gitDiffArgs(options);
   let stdout;
@@ -2297,8 +2361,10 @@ async function collectChangedPaths(root, options) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Unable to collect git changed paths (${options.mode}): ${message}`);
   }
-  const changedPaths = normalizeGitPathList(stdout);
-  const unstagedPaths = options.mode === "staged" ? await collectUnstagedPaths(root) : [];
+  const trackedChangedPaths = normalizeGitPathList(stdout);
+  const untrackedPaths = options.mode === "worktree" || options.mode === "staged" ? await collectUntrackedPaths(root) : [];
+  const changedPaths = options.mode === "worktree" ? sortUnique2([...trackedChangedPaths, ...untrackedPaths]) : trackedChangedPaths;
+  const unstagedPaths = options.mode === "staged" ? sortUnique2([...await collectUnstagedPaths(root), ...untrackedPaths]) : [];
   const stagedUnstagedConflictPaths = options.mode === "staged" ? intersect(changedPaths, unstagedPaths) : [];
   return {
     root,
@@ -2330,6 +2396,14 @@ async function collectUnstagedPaths(root) {
     return [];
   }
 }
+async function collectUntrackedPaths(root) {
+  try {
+    const { stdout } = await execFileAsync2("git", ["ls-files", "--others", "--exclude-standard"], { cwd: root });
+    return normalizeGitPathList(stdout);
+  } catch {
+    return [];
+  }
+}
 function normalizeGitPathList(stdout) {
   return sortUnique2(stdout.split(/\r?\n/).map((line) => line.trim().replace(/\\/g, "/").replace(/^\.\//, "")).filter((line) => line.length > 0 && !line.startsWith("../") && !line.startsWith("/")));
 }
@@ -2340,12 +2414,18 @@ function intersect(left, right) {
 function sortUnique2(items) {
   return [...new Set(items)].sort((left, right) => left.localeCompare(right));
 }
+var execFileAsync2;
+var init_git_changes = __esm({
+  "src/git-changes.ts"() {
+    "use strict";
+    execFileAsync2 = promisify2(execFile2);
+  }
+});
 
 // src/git-hook-path.ts
 import { execFile as execFile3 } from "child_process";
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
 import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
 async function resolveGitHookPath(root, hookName) {
   const { stdout } = await execFileAsync3("git", [
     "-C",
@@ -2358,74 +2438,19 @@ async function resolveGitHookPath(root, hookName) {
   if (!value) throw new Error(`Git returned an empty hook path for ${hookName}`);
   return isAbsolute2(value) ? resolve2(value) : resolve2(root, value);
 }
+var execFileAsync3;
+var init_git_hook_path = __esm({
+  "src/git-hook-path.ts"() {
+    "use strict";
+    execFileAsync3 = promisify3(execFile3);
+  }
+});
 
 // src/hook-installer.ts
 import { constants as constants2 } from "fs";
 import { randomUUID } from "crypto";
 import { lstat, mkdir as mkdir3, open, readlink, rename, unlink } from "fs/promises";
 import { basename, dirname as dirname2, join as join4 } from "path";
-var DEFAULT_MARKER_ID = "artifact-chain-assistant";
-var MANAGED_STATE_PREFIX = "# artifact-chain-assistant managed state v1:";
-var UnsupportedHookInterpreterError = class extends Error {
-  constructor(hookPath, shebang) {
-    super(
-      `Refusing to modify non-shell Git hook ${hookPath} (${shebang || "missing shebang"}). Call the artifact-chain hook from the existing hook explicitly.`
-    );
-    this.hookPath = hookPath;
-    this.shebang = shebang;
-  }
-  hookPath;
-  shebang;
-  code = "UNSUPPORTED_HOOK_INTERPRETER";
-};
-var SymlinkHookUnsupportedError = class extends Error {
-  constructor(hookPath, linkTarget) {
-    super(
-      `SYMLINK_HOOK_UNSUPPORTED: Refusing to modify Git hook symlink ${hookPath} -> ${linkTarget}. Integrate the artifact-graph commands manually in the symlink target or replace the link yourself.`
-    );
-    this.hookPath = hookPath;
-    this.linkTarget = linkTarget;
-  }
-  hookPath;
-  linkTarget;
-  code = "SYMLINK_HOOK_UNSUPPORTED";
-};
-var UnsupportedHookTypeError = class extends Error {
-  constructor(hookPath) {
-    super(`UNSUPPORTED_HOOK_TYPE: Git hook path ${hookPath} is not a regular file. Resolve it manually before retrying.`);
-    this.hookPath = hookPath;
-  }
-  hookPath;
-  code = "UNSUPPORTED_HOOK_TYPE";
-};
-var InvalidManagedHookStateError = class extends Error {
-  constructor(hookPath, detail) {
-    super(`INVALID_MANAGED_HOOK_STATE: Cannot safely update ${hookPath}: ${detail}`);
-    this.hookPath = hookPath;
-  }
-  hookPath;
-  code = "INVALID_MANAGED_HOOK_STATE";
-};
-var ConcurrentHookModificationError = class extends Error {
-  constructor(hookPath) {
-    super(`Refusing to overwrite concurrently modified Git hook ${hookPath}. Retry the operation after reviewing the hook.`);
-    this.hookPath = hookPath;
-  }
-  hookPath;
-  code = "CONCURRENT_HOOK_MODIFICATION";
-};
-var HookTransactionRollbackError = class extends Error {
-  constructor(operationError, rollbackErrors) {
-    super(
-      `HOOK_TRANSACTION_ROLLBACK_FAILED: Hook update failed and ${rollbackErrors.length} rollback operation(s) also failed: ` + rollbackErrors.map(({ hookPath, error }) => `${hookPath}: ${error.message}`).join("; ")
-    );
-    this.operationError = operationError;
-    this.rollbackErrors = rollbackErrors;
-  }
-  operationError;
-  rollbackErrors;
-  code = "HOOK_TRANSACTION_ROLLBACK_FAILED";
-};
 function detectHookInterpreter(content) {
   if (content.trim().length === 0) {
     return "empty";
@@ -2783,44 +2808,76 @@ function findManagedRange(content, begin, end) {
     end: endLine < 0 ? content.length : endLine + 1
   };
 }
+var DEFAULT_MARKER_ID, MANAGED_STATE_PREFIX, UnsupportedHookInterpreterError, SymlinkHookUnsupportedError, UnsupportedHookTypeError, InvalidManagedHookStateError, ConcurrentHookModificationError, HookTransactionRollbackError;
+var init_hook_installer = __esm({
+  "src/hook-installer.ts"() {
+    "use strict";
+    DEFAULT_MARKER_ID = "artifact-chain-assistant";
+    MANAGED_STATE_PREFIX = "# artifact-chain-assistant managed state v1:";
+    UnsupportedHookInterpreterError = class extends Error {
+      constructor(hookPath, shebang) {
+        super(
+          `Refusing to modify non-shell Git hook ${hookPath} (${shebang || "missing shebang"}). Call the artifact-chain hook from the existing hook explicitly.`
+        );
+        this.hookPath = hookPath;
+        this.shebang = shebang;
+      }
+      hookPath;
+      shebang;
+      code = "UNSUPPORTED_HOOK_INTERPRETER";
+    };
+    SymlinkHookUnsupportedError = class extends Error {
+      constructor(hookPath, linkTarget) {
+        super(
+          `SYMLINK_HOOK_UNSUPPORTED: Refusing to modify Git hook symlink ${hookPath} -> ${linkTarget}. Integrate the artifact-graph commands manually in the symlink target or replace the link yourself.`
+        );
+        this.hookPath = hookPath;
+        this.linkTarget = linkTarget;
+      }
+      hookPath;
+      linkTarget;
+      code = "SYMLINK_HOOK_UNSUPPORTED";
+    };
+    UnsupportedHookTypeError = class extends Error {
+      constructor(hookPath) {
+        super(`UNSUPPORTED_HOOK_TYPE: Git hook path ${hookPath} is not a regular file. Resolve it manually before retrying.`);
+        this.hookPath = hookPath;
+      }
+      hookPath;
+      code = "UNSUPPORTED_HOOK_TYPE";
+    };
+    InvalidManagedHookStateError = class extends Error {
+      constructor(hookPath, detail) {
+        super(`INVALID_MANAGED_HOOK_STATE: Cannot safely update ${hookPath}: ${detail}`);
+        this.hookPath = hookPath;
+      }
+      hookPath;
+      code = "INVALID_MANAGED_HOOK_STATE";
+    };
+    ConcurrentHookModificationError = class extends Error {
+      constructor(hookPath) {
+        super(`Refusing to overwrite concurrently modified Git hook ${hookPath}. Retry the operation after reviewing the hook.`);
+        this.hookPath = hookPath;
+      }
+      hookPath;
+      code = "CONCURRENT_HOOK_MODIFICATION";
+    };
+    HookTransactionRollbackError = class extends Error {
+      constructor(operationError, rollbackErrors) {
+        super(
+          `HOOK_TRANSACTION_ROLLBACK_FAILED: Hook update failed and ${rollbackErrors.length} rollback operation(s) also failed: ` + rollbackErrors.map(({ hookPath, error }) => `${hookPath}: ${error.message}`).join("; ")
+        );
+        this.operationError = operationError;
+        this.rollbackErrors = rollbackErrors;
+      }
+      operationError;
+      rollbackErrors;
+      code = "HOOK_TRANSACTION_ROLLBACK_FAILED";
+    };
+  }
+});
 
 // src/review-result-validator.ts
-var VALID_STATUSES = /* @__PURE__ */ new Set([
-  "SUCCEEDED",
-  "FAILED",
-  "BLOCKED",
-  "NEEDS_INPUT",
-  "SKIPPED"
-]);
-var VALID_DECISIONS = /* @__PURE__ */ new Set([
-  "PASS",
-  "FAIL",
-  "PASS_WITH_RESIDUAL_MINOR",
-  "BLOCKED",
-  "NEEDS_INPUT",
-  "NOT_APPLICABLE"
-]);
-var VALID_SEVERITIES = /* @__PURE__ */ new Set(["block", "warn", "info"]);
-var VALID_FINDING_STATUSES = /* @__PURE__ */ new Set(["open", "resolved", "accepted", "superseded"]);
-var VALID_EXECUTORS = /* @__PURE__ */ new Set(["script", "worker", "agent", "manual", "cli"]);
-var TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
-  "schema_version",
-  "run_id",
-  "stage_id",
-  "attempt",
-  "status",
-  "decision",
-  "summary",
-  "outputs",
-  "warnings",
-  "blocking_reason",
-  "degradation",
-  "producer",
-  "acceptance",
-  "evidence",
-  "review",
-  "repair"
-]);
 function validateReviewResult(input) {
   const errors = [];
   if (!input || typeof input !== "object" || Array.isArray(input)) {
@@ -3069,19 +3126,6 @@ function validateBatches(val, path, errors) {
     checkOptionalInteger(b.chars, `${itemPath}.chars`, errors);
   }
 }
-var METRIC_FIELDS = [
-  "files_reviewed",
-  "files_scanned",
-  "findings_count",
-  "deterministic_findings_count",
-  "semantic_findings_count",
-  "block_count",
-  "warn_count",
-  "info_count",
-  "resolved_count",
-  "batch_count",
-  "scenario_count"
-];
 function validateMetrics(val, path, errors) {
   if (!isPlainObject(val)) {
     errors.push({ path, message: "Must be an object" });
@@ -3098,10 +3142,844 @@ function validateRepairValidation(val, path, errors) {
   checkOptionalInteger(val.exit_code, `${path}.exit_code`, errors);
   checkOptionalInteger(val.findings_remaining, `${path}.findings_remaining`, errors, 0);
 }
+var VALID_STATUSES, VALID_DECISIONS, VALID_SEVERITIES, VALID_FINDING_STATUSES, VALID_EXECUTORS, TOP_LEVEL_FIELDS, METRIC_FIELDS;
+var init_review_result_validator = __esm({
+  "src/review-result-validator.ts"() {
+    "use strict";
+    VALID_STATUSES = /* @__PURE__ */ new Set([
+      "SUCCEEDED",
+      "FAILED",
+      "BLOCKED",
+      "NEEDS_INPUT",
+      "SKIPPED"
+    ]);
+    VALID_DECISIONS = /* @__PURE__ */ new Set([
+      "PASS",
+      "FAIL",
+      "PASS_WITH_RESIDUAL_MINOR",
+      "BLOCKED",
+      "NEEDS_INPUT",
+      "NOT_APPLICABLE"
+    ]);
+    VALID_SEVERITIES = /* @__PURE__ */ new Set(["block", "warn", "info"]);
+    VALID_FINDING_STATUSES = /* @__PURE__ */ new Set(["open", "resolved", "accepted", "superseded"]);
+    VALID_EXECUTORS = /* @__PURE__ */ new Set(["script", "worker", "agent", "manual", "cli"]);
+    TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
+      "schema_version",
+      "run_id",
+      "stage_id",
+      "attempt",
+      "status",
+      "decision",
+      "summary",
+      "outputs",
+      "warnings",
+      "blocking_reason",
+      "degradation",
+      "producer",
+      "acceptance",
+      "evidence",
+      "review",
+      "repair"
+    ]);
+    METRIC_FIELDS = [
+      "files_reviewed",
+      "files_scanned",
+      "findings_count",
+      "deterministic_findings_count",
+      "semantic_findings_count",
+      "block_count",
+      "warn_count",
+      "info_count",
+      "resolved_count",
+      "batch_count",
+      "scenario_count"
+    ];
+  }
+});
+
+// src/contract-kernel.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2, readdir } from "fs/promises";
+import { join as join5 } from "path";
+import _AjvModule from "ajv";
+function isOfficialNamespace(namespace) {
+  return OFFICIAL_NAMESPACE_PATTERN.test(namespace);
+}
+function validateNamespaceAuthority(identity, expectedAuthority) {
+  if (isOfficialNamespace(identity.namespace) && identity.authority !== OFFICIAL_AUTHORITY) {
+    throw new ContractError(
+      CONTRACT_ERROR_CODES.AUTHORITY_VIOLATION,
+      `Namespace ${identity.namespace} requires authority "${OFFICIAL_AUTHORITY}", got "${identity.authority}"`,
+      { identity, expectedAuthority: OFFICIAL_AUTHORITY }
+    );
+  }
+  if (expectedAuthority && identity.authority !== expectedAuthority) {
+    throw new ContractError(
+      CONTRACT_ERROR_CODES.AUTHORITY_VIOLATION,
+      `Expected authority "${expectedAuthority}", got "${identity.authority}"`,
+      { identity, expectedAuthority }
+    );
+  }
+}
+function canonicalizeForDigest(rawContent) {
+  try {
+    const parsed = JSON.parse(rawContent);
+    if (parsed.contractIdentity && typeof parsed.contractIdentity === "object") {
+      const ci = { ...parsed.contractIdentity };
+      delete ci.revisionDigest;
+      parsed.contractIdentity = ci;
+    }
+    return JSON.stringify(parsed);
+  } catch {
+    return rawContent;
+  }
+}
+function computeRevisionDigest(content) {
+  const canonical = canonicalizeForDigest(content);
+  const hash = createHash2("sha256").update(canonical, "utf-8").digest("hex");
+  return `sha256:${hash}`;
+}
+function verifyDigest(content, expectedDigest) {
+  const actualDigest = computeRevisionDigest(content);
+  return actualDigest === expectedDigest;
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0 || typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function matchesSchemaType(value, definition) {
+  const type = definition?.type;
+  if (type === "array") return Array.isArray(value);
+  if (type === "object") return typeof value === "object" && value !== null && !Array.isArray(value);
+  if (type === "string") return typeof value === "string";
+  if (type === "number" || type === "integer") return typeof value === "number";
+  if (type === "boolean") return typeof value === "boolean";
+  return value !== void 0;
+}
+function getNestedValue(source, path) {
+  let current = source;
+  for (const part of path.split(".")) {
+    if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function valuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function normalizeToCanonical(legacyData, config, contract) {
+  const errors = [];
+  const warnings = [];
+  const legacyFieldMap = /* @__PURE__ */ new Map();
+  for (const mapping of config.fieldMappings) {
+    legacyFieldMap.set(mapping.legacy, mapping.canonical);
+  }
+  const canonical = {};
+  const canonicalRoots = new Set(Object.keys(contract.schema.properties));
+  const presentCanonicalRoots = /* @__PURE__ */ new Set();
+  for (const root of canonicalRoots) {
+    const value = legacyData[root];
+    if (value !== void 0 && matchesSchemaType(value, contract.schema.properties[root])) {
+      canonical[root] = structuredClone(value);
+      presentCanonicalRoots.add(root);
+    }
+  }
+  const unmappedLegacyFields = new Set(
+    Object.keys(legacyData).filter((field) => !presentCanonicalRoots.has(field) && !legacyFieldMap.has(field))
+  );
+  let usedLegacyExpression = false;
+  for (const mapping of config.fieldMappings) {
+    const legacyValue = legacyData[mapping.legacy];
+    const existingCanonicalValue = getNestedValue(canonical, mapping.canonical);
+    if (legacyValue !== void 0 && !presentCanonicalRoots.has(mapping.legacy)) {
+      usedLegacyExpression = true;
+      const canonicalValue = mapping.transform ? mapping.transform(legacyValue) : legacyValue;
+      if (existingCanonicalValue !== void 0) {
+        if (!valuesEqual(existingCanonicalValue, canonicalValue)) {
+          errors.push({
+            code: CONTRACT_ERROR_CODES.CANONICAL_LEGACY_CONFLICT,
+            path: `/${mapping.canonical.replaceAll(".", "/")}`,
+            message: `Canonical field "${mapping.canonical}" conflicts with legacy field "${mapping.legacy}"`
+          });
+        }
+      } else {
+        setNestedValue(canonical, mapping.canonical, canonicalValue);
+      }
+    }
+    if (mapping.required && getNestedValue(canonical, mapping.canonical) === void 0) {
+      errors.push({
+        code: "MISSING_REQUIRED_FIELD",
+        path: `/${mapping.canonical.replaceAll(".", "/")}`,
+        message: `Required canonical field "${mapping.canonical}" missing (legacy: "${mapping.legacy}")`
+      });
+    }
+  }
+  for (const field of unmappedLegacyFields) {
+    errors.push({
+      code: "LOSSY_NORMALIZATION",
+      path: field,
+      message: `Legacy field "${field}" not mapped to canonical form \u2014 would be lost`
+    });
+  }
+  if (config.validate) {
+    const validationErrors = config.validate(canonical);
+    for (const error of validationErrors) {
+      errors.push({
+        code: "VALIDATION_FAILED",
+        path: "",
+        message: error
+      });
+    }
+  }
+  if (errors.length > 0) {
+    return { success: false, errors, warnings };
+  }
+  const schemaResult = validateContractAgainstSchema(canonical, contract);
+  if (!schemaResult.valid) {
+    return {
+      success: false,
+      errors: schemaResult.errors.map((e) => ({
+        code: "SCHEMA_VALIDATION_FAILED",
+        path: e.split(":")[0]?.trim() ?? "",
+        message: e
+      })),
+      warnings
+    };
+  }
+  if (Array.isArray(canonical.relations)) {
+    const relationResult = validateRelations(canonical.relations, contract);
+    if (!relationResult.valid) {
+      return {
+        success: false,
+        errors: relationResult.issues.map((i) => ({
+          code: i.code,
+          path: i.path,
+          message: i.message
+        })),
+        warnings
+      };
+    }
+  }
+  const sourceRevision = usedLegacyExpression ? "legacy" : "canonical";
+  return {
+    success: true,
+    ir: {
+      type: contract.identity.major.split(".")[1]?.split("@")[0] ?? "unknown",
+      id: String(canonical.metadata?.id ?? canonical["id"] ?? ""),
+      contractMajor: contract.identity.major,
+      contractDigest: contract.identity.revisionDigest,
+      canonical,
+      sourceRevision,
+      warnings
+    },
+    errors: [],
+    warnings
+  };
+}
+function resolvePropertyPath(schema, fieldPath) {
+  const parts = fieldPath.split(".");
+  let current = schema.properties;
+  for (const part of parts) {
+    if (!current || typeof current !== "object") return void 0;
+    const propDef = current[part];
+    if (!propDef) return void 0;
+    if (parts.indexOf(part) < parts.length - 1) {
+      current = propDef.properties;
+    } else {
+      return propDef;
+    }
+  }
+  return void 0;
+}
+function validatePolicyCompatibility(policy, baseContract) {
+  const errors = [];
+  const warnings = [];
+  if (policy.baseContractMajor !== baseContract.identity.major) {
+    errors.push(
+      `POLICY_INCOMPATIBLE: Policy references ${policy.baseContractMajor}, but base contract is ${baseContract.identity.major}`
+    );
+    return { compatible: false, errors, warnings };
+  }
+  const schema = baseContract.schema;
+  if (policy.additionalRequired) {
+    for (const field of policy.additionalRequired) {
+      const propDef = resolvePropertyPath(schema, field);
+      if (!propDef) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy requires field "${field}" which does not exist in base contract`);
+      }
+    }
+  }
+  if (policy.restrictedEnums) {
+    for (const [field, values] of Object.entries(policy.restrictedEnums)) {
+      const baseProperty = resolvePropertyPath(schema, field);
+      if (!baseProperty) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy restricts enum for field "${field}" which does not exist in base contract`);
+        continue;
+      }
+      if (!Array.isArray(baseProperty.enum)) {
+        errors.push(`POLICY_INCOMPATIBLE: Field "${field}" is not an enum in base contract \u2014 cannot restrict`);
+        continue;
+      }
+      for (const value of values) {
+        if (!baseProperty.enum.includes(value)) {
+          errors.push(`POLICY_INCOMPATIBLE: Policy enum value "${String(value)}" for field "${field}" not in base contract enum [${baseProperty.enum.join(", ")}]`);
+        }
+      }
+    }
+  }
+  if (policy.minCardinality) {
+    for (const [field, min] of Object.entries(policy.minCardinality)) {
+      if (!Number.isFinite(min) || min < 0 || !Number.isInteger(min)) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy min cardinality for "${field}" must be a non-negative integer, got ${min}`);
+        continue;
+      }
+      const baseProperty = resolvePropertyPath(schema, field);
+      if (!baseProperty) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy sets min cardinality for field "${field}" which does not exist in base contract`);
+        continue;
+      }
+      const baseMin = baseProperty.type === "array" ? baseProperty.minItems : baseProperty.minimum;
+      if (baseMin !== void 0 && min < baseMin) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy min cardinality ${min} for field "${field}" loosens base ${baseProperty.type === "array" ? "minItems" : "minimum"}=${baseMin}`);
+      }
+    }
+  }
+  if (policy.maxCardinality) {
+    for (const [field, max] of Object.entries(policy.maxCardinality)) {
+      if (!Number.isFinite(max) || max < 0 || !Number.isInteger(max)) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy max cardinality for "${field}" must be a non-negative integer, got ${max}`);
+        continue;
+      }
+      const baseProperty = resolvePropertyPath(schema, field);
+      if (!baseProperty) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy sets max cardinality for field "${field}" which does not exist in base contract`);
+        continue;
+      }
+      const baseMax = baseProperty.type === "array" ? baseProperty.maxItems : baseProperty.maximum;
+      if (baseMax !== void 0 && max > baseMax) {
+        errors.push(`POLICY_INCOMPATIBLE: Policy max cardinality ${max} for field "${field}" loosens base ${baseProperty.type === "array" ? "maxItems" : "maximum"}=${baseMax}`);
+      }
+    }
+  }
+  if (policy.constraints && Object.keys(policy.constraints).length > 0) {
+    for (const key of Object.keys(policy.constraints)) {
+      errors.push(`POLICY_INCOMPATIBLE: Constraint "${key}" is not implemented \u2014 rejected as unvalidated escape hatch`);
+    }
+  }
+  return {
+    compatible: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function loadContract(contractPath, options) {
+  const rawContent = await readFile2(contractPath, "utf-8");
+  let schema;
+  try {
+    schema = JSON.parse(rawContent);
+  } catch (error) {
+    throw new ContractError(
+      CONTRACT_ERROR_CODES.INVALID_IDENTITY,
+      `Failed to parse contract JSON: ${error.message}`,
+      { path: contractPath }
+    );
+  }
+  if (!schema.contractIdentity) {
+    throw new ContractError(
+      CONTRACT_ERROR_CODES.INVALID_IDENTITY,
+      "Contract missing contractIdentity",
+      { path: contractPath }
+    );
+  }
+  const identity = schema.contractIdentity;
+  if (!identity.major || !identity.authority || !identity.namespace) {
+    throw new ContractError(
+      CONTRACT_ERROR_CODES.INVALID_IDENTITY,
+      "Contract identity missing required fields (major, authority, namespace)",
+      { identity }
+    );
+  }
+  if (options?.expectedAuthority) {
+    validateNamespaceAuthority(identity, options.expectedAuthority);
+  } else {
+    validateNamespaceAuthority(identity);
+  }
+  const computedDigest = computeRevisionDigest(rawContent);
+  if (identity.revisionDigest && identity.revisionDigest !== computedDigest) {
+    throw new ContractError(
+      CONTRACT_ERROR_CODES.DIGEST_MISMATCH,
+      `Contract digest mismatch: declared ${identity.revisionDigest}, computed ${computedDigest}`,
+      { identity, computedDigest }
+    );
+  }
+  identity.revisionDigest = computedDigest;
+  return {
+    identity,
+    schema,
+    rawContent
+  };
+}
+async function loadContractsFromDirectory(contractsDir, options) {
+  const contracts = [];
+  const entries = await readdir(contractsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const schemaPath = join5(contractsDir, entry.name, "schema.json");
+      const contract = await loadContract(schemaPath, options);
+      contracts.push(contract);
+    }
+  }
+  return contracts;
+}
+function getValidator(schema) {
+  const key = `${schema.$id || "default"}#${computeRevisionDigest(JSON.stringify(schema))}`;
+  if (!_validatorCache.has(key)) {
+    const AjvCtor = _AjvModule;
+    const ajv = new AjvCtor({ allErrors: true, strict: false });
+    _validatorCache.set(key, ajv.compile(schema));
+  }
+  return _validatorCache.get(key);
+}
+function validateContractAgainstSchema(data, contract) {
+  const validate = getValidator(contract.schema);
+  const valid = validate(data);
+  if (valid) {
+    return { valid: true, errors: [] };
+  }
+  const errors = (validate.errors ?? []).map(
+    (err) => `${err.instancePath || "/"}: ${err.message ?? "validation error"}`
+  );
+  return { valid: false, errors };
+}
+function validateRelations(relations, contract) {
+  const issues = [];
+  const relationRules = contract.identity.relationRules;
+  if (!relationRules) {
+    issues.push({
+      code: "RELATION_RULES_MISSING",
+      path: "/contractIdentity/relationRules",
+      message: "Contract does not define relation rules \u2014 cannot validate relations"
+    });
+    return { valid: false, issues };
+  }
+  const relationsByKind = /* @__PURE__ */ new Map();
+  for (const relation of relations) {
+    const kind = relation.kind;
+    if (!relationsByKind.has(kind)) {
+      relationsByKind.set(kind, []);
+    }
+    relationsByKind.get(kind).push(relation);
+  }
+  for (let i = 0; i < relations.length; i++) {
+    const relation = relations[i];
+    const kind = relation.kind;
+    const targetType = relation.target_type;
+    const path = `/relations/${i}`;
+    if (!relationRules[kind]) {
+      issues.push({
+        code: "RELATION_INVALID_KIND",
+        path: `${path}/kind`,
+        message: `Relation kind "${kind}" is not allowed by contract rules`
+      });
+      continue;
+    }
+    const rule = relationRules[kind];
+    if (!rule.allowedTargetTypes.includes(targetType)) {
+      issues.push({
+        code: "RELATION_INVALID_TARGET_TYPE",
+        path: `${path}/target_type`,
+        message: `Target type "${targetType}" is not allowed for relation kind "${kind}". Allowed: ${rule.allowedTargetTypes.join(", ")}`
+      });
+    }
+    const hasAnchor = relation.anchor !== void 0 && relation.anchor !== "";
+    if (rule.anchorPolicy === "required" && !hasAnchor) {
+      issues.push({
+        code: "RELATION_MISSING_ANCHOR",
+        path: `${path}/anchor`,
+        message: `Relation kind "${kind}" requires an anchor`
+      });
+    } else if (rule.anchorPolicy === "forbidden" && hasAnchor) {
+      issues.push({
+        code: "RELATION_FORBIDDEN_ANCHOR",
+        path: `${path}/anchor`,
+        message: `Relation kind "${kind}" forbids anchors`
+      });
+    }
+  }
+  for (const [kind, rule] of Object.entries(relationRules)) {
+    const count = relationsByKind.get(kind)?.length ?? 0;
+    if (count < rule.min) {
+      issues.push({
+        code: "RELATION_BELOW_MIN",
+        path: "/relations",
+        message: `Relation kind "${kind}" has ${count} instances, minimum is ${rule.min}`
+      });
+    }
+    if (count > rule.max) {
+      issues.push({
+        code: "RELATION_ABOVE_MAX",
+        path: "/relations",
+        message: `Relation kind "${kind}" has ${count} instances, maximum is ${rule.max}`
+      });
+    }
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+function normalizeE2eLegacyArtifact(legacyData, contract) {
+  return normalizeToCanonical(legacyData, E2E_NORMALIZER_CONFIG, contract);
+}
+async function loadContractCatalog(contractsDir, options) {
+  const catalog = new ContractCatalog();
+  const contracts = await loadContractsFromDirectory(contractsDir, options);
+  for (const contract of contracts) {
+    catalog.add(contract);
+  }
+  return catalog;
+}
+var CONTRACT_ERROR_CODES, ContractError, OFFICIAL_AUTHORITY, OFFICIAL_NAMESPACE_PATTERN, ContractRegistry, _validatorCache, E2E_NORMALIZER_CONFIG, ContractCatalog;
+var init_contract_kernel = __esm({
+  "src/contract-kernel.ts"() {
+    "use strict";
+    CONTRACT_ERROR_CODES = {
+      /** Contract identity not found */
+      CONTRACT_NOT_FOUND: "CONTRACT_NOT_FOUND",
+      /** Invalid contract identity format */
+      INVALID_IDENTITY: "INVALID_IDENTITY",
+      /** Revision digest mismatch */
+      DIGEST_MISMATCH: "DIGEST_MISMATCH",
+      /** Duplicate contract identity */
+      DUPLICATE_IDENTITY: "DUPLICATE_IDENTITY",
+      /** Multiple active write contracts for same type */
+      MULTIPLE_ACTIVE_WRITE: "MULTIPLE_ACTIVE_WRITE",
+      /** Unknown authority namespace */
+      UNKNOWN_AUTHORITY: "UNKNOWN_AUTHORITY",
+      /** Namespace authority violation */
+      AUTHORITY_VIOLATION: "AUTHORITY_VIOLATION",
+      /** Schema validation failed */
+      SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
+      /** Canonical IR normalization failed */
+      NORMALIZATION_FAILED: "NORMALIZATION_FAILED",
+      /** Policy compatibility check failed */
+      POLICY_INCOMPATIBLE: "POLICY_INCOMPATIBLE",
+      /** Legacy revision cannot be normalized */
+      LEGACY_NORMALIZATION_FAILED: "LEGACY_NORMALIZATION_FAILED",
+      /** Canonical and legacy conflict */
+      CANONICAL_LEGACY_CONFLICT: "CANONICAL_LEGACY_CONFLICT",
+      /** Relation rule violation */
+      RELATION_RULE_VIOLATION: "RELATION_RULE_VIOLATION",
+      /** Relation rules missing in contract (fail closed) */
+      RELATION_RULES_MISSING: "RELATION_RULES_MISSING",
+      /** Ambiguous revision — multiple revisions found, no unique active write */
+      AMBIGUOUS_REVISION: "AMBIGUOUS_REVISION",
+      /** Invalid relation kind */
+      RELATION_INVALID_KIND: "RELATION_INVALID_KIND",
+      /** Invalid relation target type */
+      RELATION_INVALID_TARGET_TYPE: "RELATION_INVALID_TARGET_TYPE",
+      /** Relation below minimum cardinality */
+      RELATION_BELOW_MIN: "RELATION_BELOW_MIN",
+      /** Relation above maximum cardinality */
+      RELATION_ABOVE_MAX: "RELATION_ABOVE_MAX",
+      /** Missing required anchor */
+      RELATION_MISSING_ANCHOR: "RELATION_MISSING_ANCHOR",
+      /** Forbidden anchor present */
+      RELATION_FORBIDDEN_ANCHOR: "RELATION_FORBIDDEN_ANCHOR",
+      /** Missing required semantic marker */
+      MARKER_MISSING: "MARKER_MISSING",
+      /** Duplicate semantic marker */
+      MARKER_DUPLICATE: "MARKER_DUPLICATE",
+      /** Unknown semantic marker */
+      MARKER_UNKNOWN: "MARKER_UNKNOWN"
+    };
+    ContractError = class extends Error {
+      constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "ContractError";
+      }
+      code;
+      details;
+    };
+    OFFICIAL_AUTHORITY = "artifact";
+    OFFICIAL_NAMESPACE_PATTERN = /^artifact(?:\.|$)/;
+    ContractRegistry = class {
+      contracts = /* @__PURE__ */ new Map();
+      typeToActiveWrite = /* @__PURE__ */ new Map();
+      majorToContracts = /* @__PURE__ */ new Map();
+      /**
+       * Register a contract
+       * @throws ContractError if duplicate identity or multiple active write contracts
+       */
+      register(contract, options) {
+        const major = contract.identity.major;
+        const digest = contract.identity.revisionDigest;
+        const key = `${major}@${digest}`;
+        const isActive = options?.isActive ?? true;
+        const isWriteTarget = options?.isWriteTarget ?? true;
+        if (this.contracts.has(key)) {
+          throw new ContractError(
+            CONTRACT_ERROR_CODES.DUPLICATE_IDENTITY,
+            `Contract ${key} already registered`,
+            { identity: contract.identity }
+          );
+        }
+        if (isActive && isWriteTarget) {
+          const type = major.split("@")[0];
+          if (this.typeToActiveWrite.has(type)) {
+            throw new ContractError(
+              CONTRACT_ERROR_CODES.MULTIPLE_ACTIVE_WRITE,
+              `Type ${type} already has active write contract: ${this.typeToActiveWrite.get(type)}`,
+              { identity: contract.identity, existing: this.typeToActiveWrite.get(type) }
+            );
+          }
+          this.typeToActiveWrite.set(type, key);
+        }
+        this.contracts.set(key, {
+          contract,
+          isActive,
+          isWriteTarget,
+          loadedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (!this.majorToContracts.has(major)) {
+          this.majorToContracts.set(major, /* @__PURE__ */ new Set());
+        }
+        this.majorToContracts.get(major).add(key);
+      }
+      /**
+       * Resolve by major identity. Multiple revisions require a unique active write
+       * revision; insertion order is never a resolution policy.
+       */
+      get(major) {
+        const keys = this.majorToContracts.get(major);
+        if (!keys || keys.size === 0) return void 0;
+        if (keys.size === 1) {
+          const onlyKey = keys.values().next().value;
+          return onlyKey ? this.contracts.get(onlyKey)?.contract : void 0;
+        }
+        const type = major.split("@")[0];
+        const activeWriteKey = this.typeToActiveWrite.get(type);
+        if (activeWriteKey && keys.has(activeWriteKey)) {
+          return this.contracts.get(activeWriteKey)?.contract;
+        }
+        throw new ContractError(
+          CONTRACT_ERROR_CODES.AMBIGUOUS_REVISION,
+          `Multiple revisions found for ${major} with no unique active write \u2014 specify digest`,
+          {
+            major,
+            availableDigests: Array.from(keys).map((key) => this.contracts.get(key)?.contract.identity.revisionDigest).filter((digest) => Boolean(digest))
+          }
+        );
+      }
+      /**
+       * Get contract by major identity and digest
+       */
+      getByMajorAndDigest(major, digest) {
+        const key = `${major}@${digest}`;
+        return this.contracts.get(key)?.contract;
+      }
+      /**
+       * Get all contracts for a major identity
+       */
+      getByMajor(major) {
+        const keys = this.majorToContracts.get(major);
+        if (!keys) return [];
+        return Array.from(keys).map((key) => this.contracts.get(key)?.contract).filter((c) => c !== void 0);
+      }
+      /**
+       * Get active write contract for a type
+       */
+      getActiveWriteContract(typePrefix) {
+        const key = this.typeToActiveWrite.get(typePrefix);
+        return key ? this.contracts.get(key)?.contract : void 0;
+      }
+      /**
+       * List all registered contracts
+       */
+      list() {
+        return Array.from(this.contracts.values());
+      }
+      /**
+       * Check if a contract is registered by major identity
+       */
+      has(major) {
+        const keys = this.majorToContracts.get(major);
+        return keys !== void 0 && keys.size > 0;
+      }
+      /**
+       * Check if a contract is registered by major identity and digest
+       */
+      hasByMajorAndDigest(major, digest) {
+        const key = `${major}@${digest}`;
+        return this.contracts.has(key);
+      }
+    };
+    _validatorCache = /* @__PURE__ */ new Map();
+    E2E_NORMALIZER_CONFIG = {
+      contractMajor: "artifact.e2e-test@1",
+      fieldMappings: [
+        { legacy: "id", canonical: "metadata.id", required: true },
+        { legacy: "title", canonical: "metadata.title", required: true },
+        { legacy: "status", canonical: "metadata.status", required: true },
+        { legacy: "test_batch", canonical: "metadata.test_batch" },
+        { legacy: "scope", canonical: "scope.business_goal", transform: (v) => String(v) },
+        { legacy: "actors", canonical: "scope.actors", transform: (v) => Array.isArray(v) ? v : [v] },
+        { legacy: "system_boundaries", canonical: "system_boundary.components", transform: (v) => Array.isArray(v) ? v : [v] },
+        { legacy: "test_cases", canonical: "test_cases", required: true },
+        { legacy: "relations", canonical: "relations" },
+        // Map legacy coverage fields if present
+        { legacy: "ac_coverage", canonical: "coverage.ac_coverage" },
+        { legacy: "related_scenarios", canonical: "coverage.related_scenarios" },
+        // Map legacy environment fields if present
+        { legacy: "topology", canonical: "environment_data.topology" },
+        { legacy: "fixtures", canonical: "environment_data.fixtures" },
+        { legacy: "isolation_strategy", canonical: "environment_data.isolation_strategy" },
+        // Map legacy evidence fields if present
+        { legacy: "required_artifacts", canonical: "evidence_contract.required_artifacts" },
+        { legacy: "runner_binding", canonical: "evidence_contract.runner_binding" }
+      ],
+      validate: (canonical) => {
+        const errors = [];
+        if (!canonical.metadata || typeof canonical.metadata !== "object") {
+          errors.push("metadata must be an object");
+        }
+        if (!canonical.scope || typeof canonical.scope !== "object") {
+          errors.push("scope must be an object");
+        }
+        if (!canonical.system_boundary || typeof canonical.system_boundary !== "object") {
+          errors.push("system_boundary must be an object");
+        }
+        if (!Array.isArray(canonical.test_cases) || canonical.test_cases.length === 0) {
+          errors.push("test_cases must be a non-empty array");
+        }
+        if (Array.isArray(canonical.test_cases)) {
+          for (let i = 0; i < canonical.test_cases.length; i++) {
+            const tc = canonical.test_cases[i];
+            if (!Array.isArray(tc.trace_targets) || tc.trace_targets.length === 0) {
+              errors.push(`test_cases[${i}].trace_targets must be a non-empty array`);
+            }
+          }
+        }
+        return errors;
+      }
+    };
+    ContractCatalog = class {
+      contracts = /* @__PURE__ */ new Map();
+      majorToContracts = /* @__PURE__ */ new Map();
+      majorToActiveWrite = /* @__PURE__ */ new Map();
+      /**
+       * Add a contract to the catalog
+       * @throws ContractError if duplicate identity
+       */
+      add(contract, options) {
+        const major = contract.identity.major;
+        const digest = contract.identity.revisionDigest;
+        const key = `${major}@${digest}`;
+        const isActive = options?.isActive ?? true;
+        const isWriteTarget = options?.isWriteTarget ?? true;
+        if (this.contracts.has(key)) {
+          throw new ContractError(
+            CONTRACT_ERROR_CODES.DUPLICATE_IDENTITY,
+            `Contract ${key} already in catalog`,
+            { identity: contract.identity }
+          );
+        }
+        this.contracts.set(key, contract);
+        if (!this.majorToContracts.has(major)) {
+          this.majorToContracts.set(major, /* @__PURE__ */ new Set());
+        }
+        this.majorToContracts.get(major).add(key);
+        if (isActive && isWriteTarget) {
+          const existingActive = this.majorToActiveWrite.get(major);
+          if (existingActive && existingActive !== key) {
+            this.contracts.delete(key);
+            this.majorToContracts.get(major)?.delete(key);
+            throw new ContractError(
+              CONTRACT_ERROR_CODES.MULTIPLE_ACTIVE_WRITE,
+              `Major ${major} already has active write revision`,
+              { major, existing: existingActive, attempted: key }
+            );
+          }
+          this.majorToActiveWrite.set(major, key);
+        }
+      }
+      /**
+       * Resolve a contract by major identity.
+       * - 0 entries: returns undefined
+       * - 1 entry: returns it
+       * - multiple: if there's a unique active write, returns it; otherwise throws AMBIGUOUS_REVISION
+       */
+      resolve(major) {
+        const keys = this.majorToContracts.get(major);
+        if (!keys || keys.size === 0) return void 0;
+        if (keys.size === 1) {
+          const firstKey = keys.values().next().value;
+          return firstKey ? this.contracts.get(firstKey) : void 0;
+        }
+        const activeWriteKey = this.majorToActiveWrite.get(major);
+        if (activeWriteKey) {
+          return this.contracts.get(activeWriteKey);
+        }
+        throw new ContractError(
+          CONTRACT_ERROR_CODES.AMBIGUOUS_REVISION,
+          `Multiple revisions found for ${major} with no unique active write \u2014 specify digest`,
+          {
+            major,
+            availableDigests: Array.from(keys).map((key) => this.contracts.get(key)?.identity.revisionDigest).filter((digest) => Boolean(digest))
+          }
+        );
+      }
+      /**
+       * Resolve a contract by major identity and exact digest
+       */
+      resolveByDigest(major, digest) {
+        const key = `${major}@${digest}`;
+        return this.contracts.get(key);
+      }
+      /**
+       * List all catalog entries (all revisions)
+       */
+      list() {
+        return Array.from(this.contracts.values()).map((contract) => ({
+          identity: contract.identity,
+          contract
+        }));
+      }
+      /**
+       * Get catalog as JSON-serializable object (all revisions)
+       */
+      toJSON() {
+        return {
+          contracts: this.list().map((entry) => ({
+            major: entry.identity.major,
+            authority: entry.identity.authority,
+            namespace: entry.identity.namespace,
+            revisionDigest: entry.identity.revisionDigest
+          }))
+        };
+      }
+    };
+  }
+});
 
 // src/index.ts
-var TARGET_ARTIFACT_TYPES = VALID_PACKET_TARGET_TYPES;
-var NON_TARGET_ROLES = ["context", "candidate", "not-recommended"];
+import Database from "better-sqlite3";
+import matter from "gray-matter";
+import yaml from "js-yaml";
+import { accessSync, constants as fsConstants, existsSync as existsSync2, statSync } from "fs";
+import { mkdir as mkdir4, readFile as readFile3, readdir as readdir2, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename3, dirname as dirname3, extname, isAbsolute as isAbsolute3, join as join6, relative as relative2, resolve as resolve3 } from "path";
 function isTargetArtifactType(type) {
   return isPacketTargetType(type);
 }
@@ -3142,56 +4020,11 @@ function resolveArtifactTypeName(schema, token) {
   }
   return void 0;
 }
-var DEFAULT_SCHEMA = {
-  types: {
-    decision: { paths: ["artifacts/decisions/**/*.md"], displayName: "\u51B3\u7B56\u6587\u6863", role: "decision", layer: "decision", aliases: ["decisions", "adr"] },
-    entity: { paths: ["artifacts/entities/entity-registry.md"], displayName: "\u5B9E\u4F53\u6CE8\u518C\u8868", role: "context", layer: "domain", aliases: ["entity-registry"] },
-    feature: { paths: ["artifacts/prd/features/**/*.md"], displayName: "\u529F\u80FD\u7279\u6027", role: "feature", layer: "prd", aliases: ["prd-feature", "prd_features"] },
-    scenario: { paths: ["artifacts/scenarios/**/*.md"], displayName: "\u573A\u666F\u5267\u672C", role: "scenario", layer: "scenario", aliases: ["scenarios", "scenario-script"] },
-    design: { paths: ["artifacts/design/**/*.md"], displayName: "\u8BBE\u8BA1\u89C4\u683C", role: "design", layer: "design", aliases: ["design-spec", "design_docs"] },
-    test: { paths: ["heimdall/packages/**/*.test.ts"], displayName: "\u4EE3\u7801\u6CE8\u91CA\u8FFD\u6EAF", role: "context", layer: "implementation", aliases: ["code-test", "code-trace", "unit-test"] },
-    e2e_test: { paths: ["artifacts/tests/e2e/*.md"], displayName: "E2E \u6D4B\u8BD5\u89C4\u683C", role: "e2e_test", layer: "verification", aliases: ["e2e-test", "e2e_tests", "tc"] },
-    e2e_registry: { paths: ["artifacts/tests/e2e/e2e-test-registry.json"], displayName: "E2E \u6D4B\u8BD5\u6CE8\u518C\u8868", role: "context", layer: "verification", aliases: ["e2e-registry"] },
-    "rule-golden-cases": { paths: ["artifacts/tests/rule-golden-cases.md"], displayName: "\u89C4\u5219\u9EC4\u91D1\u6D4B\u8BD5\u7528\u4F8B", role: "context", layer: "verification", aliases: ["rule_golden_cases"] },
-    "test-strategy": { paths: ["artifacts/design/test-strategy.md"], displayName: "\u6D4B\u8BD5\u7B56\u7565", role: "context", layer: "verification", aliases: ["test_strategy"] },
-    "traceability-matrix-v2": { paths: ["artifacts/traceability-matrix-v2.md"], displayName: "\u8FFD\u6EAF\u77E9\u9635 v2", role: "context", layer: "traceability", aliases: ["traceability_matrix_v2"] }
-  },
-  idPatterns: {
-    decision: "^D-[A-Z]+-\\d+$",
-    entity: "^E-\\d{3,}$",
-    feature: "^[A-Z]{1,4}\\d+$",
-    scenario: "^S-\\d+[a-z]?$",
-    design: "^[A-Za-z0-9._-]+$",
-    test: "^.+\\.test\\.ts$",
-    e2e_test: "^.+:(TC-\\d+[a-z]?|FILE)$",
-    e2e_registry: "^e2e-test-registry$",
-    "rule-golden-cases": "^[A-Z]+-\\d{3}:(pass|fail|edge)$",
-    "test-strategy": "^(unit|integration|e2e|desktop_chain|rule|contract)$",
-    "traceability-matrix-v2": "^.+$"
-  },
-  relationFields: {
-    feature: ["scenarios", "decisions", "depends_on", "design_docs"],
-    scenario: ["\u5173\u8054\u529F\u80FD", "\u5173\u8054\u51B3\u7B56"],
-    design: ["related_features", "related_scenarios"],
-    test: ["@scenario", "@feature", "@entity", "@decision"],
-    e2e_test: ["test_batch", "scope", "ac_coverage", "related_scenarios", "related_decisions", "related_entities", "\u8986\u76D6\u573A\u666F", "\u8986\u76D6\u529F\u80FD"],
-    e2e_registry: ["batches"]
-  },
-  allowedEdges: [],
-  forbiddenEdges: [{ from: "scenario", to: "entity", kind: "references" }],
-  statuses: ["planned", "active", "done", "deprecated"],
-  idRanges: {},
-  e2e: {
-    report_uncovered_scenarios: true,
-    report_uncovered_features: true,
-    runners: []
-  }
-};
 async function loadConfig(root) {
-  const configPath = join5(root, "artifact-graph.config.yaml");
+  const configPath = join6(root, "artifact-graph.config.yaml");
   let parsed = {};
   try {
-    const raw = await readFile2(configPath, "utf-8");
+    const raw = await readFile3(configPath, "utf-8");
     parsed = yaml.load(raw) ?? {};
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -3365,7 +4198,7 @@ async function scanArtifacts(root, schema) {
         continue;
       }
       scannedFiles.set(file, type);
-      const raw = await readFile2(join5(root, file), "utf-8");
+      const raw = await readFile3(join6(root, file), "utf-8");
       const parsed = parseFile(type, file, raw, config);
       nodes.push(...parsed.nodes);
       edges.push(...parsed.edges);
@@ -3677,7 +4510,7 @@ async function validateScenarioPrdLinkIndex(root, graph) {
   const indexPath = "artifacts/prd/feature-index.md";
   let raw = "";
   try {
-    raw = await readFile2(join5(root, indexPath), "utf-8");
+    raw = await readFile3(join6(root, indexPath), "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -3867,11 +4700,11 @@ function nextId(graph, schema, type, rangeName) {
   throw new Error(`ID range ${type}.${rangeName} is exhausted`);
 }
 async function writeGraphCache(root, graph) {
-  const cacheDir = join5(root, ".artifact-graph");
+  const cacheDir = join6(root, ".artifact-graph");
   await mkdir4(cacheDir, { recursive: true });
-  await writeFile3(join5(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
+  await writeFile3(join6(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
 `);
-  const db = new Database(join5(cacheDir, "graph.sqlite"));
+  const db = new Database(join6(cacheDir, "graph.sqlite"));
   try {
     db.exec(`
       DROP TABLE IF EXISTS nodes;
@@ -4209,7 +5042,7 @@ function parseDecisions(path, raw) {
 }
 function isTestFile(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const name = basename2(normalized);
+  const name = basename3(normalized);
   if (/\.(test|spec)\.[^.]+$/.test(name)) return true;
   if (/(^|\/)(tests|test|__tests__)\//.test(normalized)) return true;
   if (/\w+Tests?\.java$/.test(name)) return true;
@@ -4500,7 +5333,7 @@ function parseE2eTest(path, raw) {
   });
   const nodes = [];
   const edges = [];
-  const batch = String(data.test_batch ?? basename2(path, extname(path))).trim();
+  const batch = String(data.test_batch ?? basename3(path, extname(path))).trim();
   const frontmatterScenarios = toArray(data.related_scenarios).map((value) => String(value).trim()).filter(Boolean);
   const scopeFeatures = extractCodes(String(data.scope ?? ""), "feature");
   const frontmatterFeatures = [.../* @__PURE__ */ new Set([...Object.keys(asRecord(data.ac_coverage)), ...scopeFeatures])];
@@ -4573,7 +5406,7 @@ function parseE2eRegistry(path, raw) {
     data = { parseError: error.message };
   }
   return {
-    nodes: [{ type: "e2e_registry", code: basename2(path, extname(path)), title: "E2E Test Registry", path, line: 1, attrs: data }],
+    nodes: [{ type: "e2e_registry", code: basename3(path, extname(path)), title: "E2E Test Registry", path, line: 1, attrs: data }],
     edges: []
   };
 }
@@ -5554,10 +6387,10 @@ function validateE2eRegistry(graph) {
 async function validateExecutableTraceability(root, config) {
   const issues = [];
   const schema = config ?? await loadConfig(root);
-  const e2eDir = join5(root, "artifacts", "tests", "e2e");
+  const e2eDir = join6(root, "artifacts", "tests", "e2e");
   let e2eFiles;
   try {
-    e2eFiles = (await readdir(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join5(e2eDir, name));
+    e2eFiles = (await readdir2(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join6(e2eDir, name));
   } catch {
     return [];
   }
@@ -5566,11 +6399,11 @@ async function validateExecutableTraceability(root, config) {
   const tcKeyToFields = /* @__PURE__ */ new Map();
   const mdBatches = /* @__PURE__ */ new Set();
   for (const filePath of e2eFiles) {
-    const raw = await readFile2(filePath, "utf-8");
+    const raw = await readFile3(filePath, "utf-8");
     const relPath = relative2(root, filePath).split("\\").join("/");
     const parsed = matter(raw);
     const data = parsed.data;
-    const batch = String(data.test_batch ?? basename2(filePath, extname(filePath))).trim();
+    const batch = String(data.test_batch ?? basename3(filePath, extname(filePath))).trim();
     const lines = raw.split(/\r?\n/);
     const tcStarts = [];
     lines.forEach((line, index) => {
@@ -5615,10 +6448,10 @@ async function validateExecutableTraceability(root, config) {
   const tcAnnotationRegex = /\/\/!?\s*@(?:e2e_test|tc)\s+(\S+?)\s+\[(\w+)\]/;
   const tcAnnotationNoLevelRegex = /\/\/!?\s*@(?:e2e_test|tc)\s+(\S+)/;
   for (const specFile of specFiles) {
-    const fullSpecPath = join5(root, specFile);
+    const fullSpecPath = join6(root, specFile);
     let content;
     try {
-      content = await readFile2(fullSpecPath, "utf-8");
+      content = await readFile3(fullSpecPath, "utf-8");
     } catch {
       continue;
     }
@@ -5695,7 +6528,7 @@ async function validateExecutableTraceability(root, config) {
       if (entry.testId) {
         let content;
         try {
-          content = await readFile2(join5(root, normalizedRefFile), "utf-8");
+          content = await readFile3(join6(root, normalizedRefFile), "utf-8");
         } catch {
           continue;
         }
@@ -5872,16 +6705,16 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   let withExecutableRef = 0;
   const statusBreakdown = {};
   const chainTypeBreakdown = {};
-  const e2eDir = join5(root, "artifacts", "tests", "e2e");
+  const e2eDir = join6(root, "artifacts", "tests", "e2e");
   const tcFieldsMap = /* @__PURE__ */ new Map();
   let e2eFiles;
   try {
-    e2eFiles = (await readdir(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join5(e2eDir, name));
+    e2eFiles = (await readdir2(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join6(e2eDir, name));
   } catch {
     e2eFiles = [];
   }
   for (const filePath of e2eFiles) {
-    const raw = await readFile2(filePath, "utf-8");
+    const raw = await readFile3(filePath, "utf-8");
     const lines = raw.split(/\r?\n/);
     const tcStarts = [];
     lines.forEach((line, index) => {
@@ -5891,7 +6724,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
       }
     });
     const parsed = matter(raw);
-    const batch = String(parsed.data.test_batch ?? basename2(filePath, extname(filePath))).trim();
+    const batch = String(parsed.data.test_batch ?? basename3(filePath, extname(filePath))).trim();
     for (let i = 0; i < tcStarts.length; i++) {
       const start = tcStarts[i];
       const end = tcStarts[i + 1]?.index ?? lines.length;
@@ -5954,7 +6787,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
     let hasActiveE2eRef = false;
     for (const entry of parseExecutableRefLines(execRef)) {
       const normalized = resolveExecutableRefFile(entry.file, allProjectFiles);
-      if (!normalized || !existsSync2(join5(root, normalized))) continue;
+      if (!normalized || !existsSync2(join6(root, normalized))) continue;
       const accepting = await getAcceptingRunners(root, normalized, runners);
       if (accepting.some((runner) => runner.kind === "e2e")) {
         hasActiveE2eRef = true;
@@ -6013,7 +6846,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   const acCoverageRateByFeature = {};
   const featureAcMap = /* @__PURE__ */ new Map();
   for (const node of featureNodes) {
-    const acs = parseAcceptanceCriteria(await readFile2(join5(root, node.path), "utf-8"));
+    const acs = parseAcceptanceCriteria(await readFile3(join6(root, node.path), "utf-8"));
     featureAcMap.set(node.code, new Set(acs));
   }
   const coveredAcByFeature = /* @__PURE__ */ new Map();
@@ -6055,10 +6888,10 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   };
 }
 async function generateE2eRegistry(root, opts) {
-  const e2eDir = join5(root, "artifacts", "tests", "e2e");
+  const e2eDir = join6(root, "artifacts", "tests", "e2e");
   let files;
   try {
-    files = (await readdir(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
+    files = (await readdir2(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
   } catch {
     return {
       registry_version: "1.0",
@@ -6071,11 +6904,11 @@ async function generateE2eRegistry(root, opts) {
   const batches = [];
   let totalTestCases = 0;
   for (const file of files) {
-    const filePath = join5(e2eDir, file);
-    const raw = await readFile2(filePath, "utf-8");
+    const filePath = join6(e2eDir, file);
+    const raw = await readFile3(filePath, "utf-8");
     const parsed = matter(raw);
     const data = parsed.data;
-    const batch = String(data.test_batch ?? basename2(file, extname(file))).trim();
+    const batch = String(data.test_batch ?? basename3(file, extname(file))).trim();
     const relPath = `artifacts/tests/e2e/${file}`;
     const scope = String(data.scope ?? "").trim();
     const acCoverage = normalizeAcCoverageForRegistry(data.ac_coverage);
@@ -6164,20 +6997,6 @@ function parseExecutableRefLines(ref) {
   }
   return results;
 }
-var VALID_TC_STATUSES = /* @__PURE__ */ new Set(["created", "automated", "verified", "waived"]);
-var VALID_CHAIN_TYPES = /* @__PURE__ */ new Set([
-  "desktop_chain",
-  "mock_playwright",
-  "core_e2e",
-  "cli_e2e",
-  "ui_sidecar_bridge",
-  "partial_sidecar",
-  "partial_rust"
-]);
-var DEPRECATED_CHAIN_TYPE_ALIASES = {
-  core_only: "core_e2e",
-  frontend_only: "mock_playwright"
-};
 function isDesktopChainType(chainType) {
   const normalizedChainType = chainType.trim().toLowerCase();
   return normalizedChainType === "desktop_chain" || normalizedChainType === "";
@@ -6213,10 +7032,10 @@ async function validatePartialRustEvidence(tcFields, tcKey, root, allFiles) {
     if (!normalizedPath) {
       return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
     }
-    const fullPath = join5(root, normalizedPath);
+    const fullPath = join6(root, normalizedPath);
     let content;
     try {
-      content = await readFile2(fullPath, "utf-8");
+      content = await readFile3(fullPath, "utf-8");
     } catch {
       return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
     }
@@ -6325,9 +7144,9 @@ function escapeRegExp(value) {
 }
 async function hasMarkdownTc(tcKey, e2eDir) {
   const [batch, tcId] = tcKey.split(":");
-  const filePath = join5(e2eDir, `${batch}.md`);
+  const filePath = join6(e2eDir, `${batch}.md`);
   try {
-    const raw = await readFile2(filePath, "utf-8");
+    const raw = await readFile3(filePath, "utf-8");
     const tcRegex = new RegExp(`^#{2,3}\\s+${escapeRegExp(tcId)}\\s*[:\uFF1A]?`, "m");
     return tcRegex.test(raw);
   } catch {
@@ -6347,13 +7166,13 @@ async function findFiles(root, patterns) {
   return [...matched].sort();
 }
 async function walk(root, current = root) {
-  const entries = await readdir(current, { withFileTypes: true });
+  const entries = await readdir2(current, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git" || entry.name === ".artifact-graph") {
       continue;
     }
-    const fullPath = join5(current, entry.name);
+    const fullPath = join6(current, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walk(root, fullPath));
     } else {
@@ -6572,7 +7391,7 @@ function normalizeDesignCode(value) {
   if (!raw) {
     return "";
   }
-  return basename2(raw, extname(raw));
+  return basename3(raw, extname(raw));
 }
 function toUid(type, code) {
   return `${type}:${code}`;
@@ -6669,30 +7488,6 @@ function discoverTargets(graph, options) {
   }
   return result;
 }
-var CONTEXT_CATEGORIES = {
-  feature: "prd",
-  scenario: "scenario",
-  decision: "decision",
-  design: "design",
-  entity: "entity",
-  "interface_contracts": "contract",
-  "data_contracts": "contract",
-  "application_state_machines": "contract",
-  "error_model": "contract",
-  "report-contracts": "contract",
-  "ui-flow-contracts": "contract",
-  "non-functional-budgets": "contract",
-  "domain-glossary": "domain",
-  "bounded-context-map": "domain",
-  "domain-invariants": "domain",
-  "generation-packet-spec": "domain",
-  "rule-golden-cases": "verification",
-  "test-strategy": "verification",
-  "verification-fixtures": "verification",
-  "implementation-blueprint": "blueprint",
-  "traceability-matrix-v2": "matrix"
-};
-var TIER_ORDER = ["baseline", "target", "direct", "matrix", "transitive"];
 function resolveArtifactContext(graph, opts) {
   const mode = opts.mode ?? "full";
   const maxPerCategory = opts.maxPerCategory ?? 20;
@@ -6861,7 +7656,7 @@ function resolveArtifactContext(graph, opts) {
     }
     if (root) {
       for (const ap of ALWAYS_PRESENT_ITEMS) {
-        const fullPath = join5(root, ap.path);
+        const fullPath = join6(root, ap.path);
         let stat;
         try {
           stat = statSync(fullPath);
@@ -7091,13 +7886,126 @@ function formatContextMarkdown(manifest) {
   }
   return lines.join("\n");
 }
+var TARGET_ARTIFACT_TYPES, NON_TARGET_ROLES, DEFAULT_SCHEMA, VALID_TC_STATUSES, VALID_CHAIN_TYPES, DEPRECATED_CHAIN_TYPE_ALIASES, CONTEXT_CATEGORIES, TIER_ORDER;
+var init_index = __esm({
+  "src/index.ts"() {
+    init_packet_constants();
+    init_packet_validator();
+    init_glob_matcher();
+    init_packet_constants();
+    init_target_selector();
+    init_packet_assembler();
+    init_packet_audit();
+    init_packet_validator();
+    init_packet_prompt();
+    init_packet_prompt_validator();
+    init_versioned_traceability();
+    init_cli_resolver();
+    init_git_changes();
+    init_git_hook_path();
+    init_hook_installer();
+    init_review_result_validator();
+    init_contract_kernel();
+    TARGET_ARTIFACT_TYPES = VALID_PACKET_TARGET_TYPES;
+    NON_TARGET_ROLES = ["context", "candidate", "not-recommended"];
+    DEFAULT_SCHEMA = {
+      types: {
+        decision: { paths: ["artifacts/decisions/**/*.md"], displayName: "\u51B3\u7B56\u6587\u6863", role: "decision", layer: "decision", aliases: ["decisions", "adr"] },
+        entity: { paths: ["artifacts/entities/entity-registry.md"], displayName: "\u5B9E\u4F53\u6CE8\u518C\u8868", role: "context", layer: "domain", aliases: ["entity-registry"] },
+        feature: { paths: ["artifacts/prd/features/**/*.md"], displayName: "\u529F\u80FD\u7279\u6027", role: "feature", layer: "prd", aliases: ["prd-feature", "prd_features"] },
+        scenario: { paths: ["artifacts/scenarios/**/*.md"], displayName: "\u573A\u666F\u5267\u672C", role: "scenario", layer: "scenario", aliases: ["scenarios", "scenario-script"] },
+        design: { paths: ["artifacts/design/**/*.md"], displayName: "\u8BBE\u8BA1\u89C4\u683C", role: "design", layer: "design", aliases: ["design-spec", "design_docs"] },
+        test: { paths: ["heimdall/packages/**/*.test.ts"], displayName: "\u4EE3\u7801\u6CE8\u91CA\u8FFD\u6EAF", role: "context", layer: "implementation", aliases: ["code-test", "code-trace", "unit-test"] },
+        e2e_test: { paths: ["artifacts/tests/e2e/*.md"], displayName: "E2E \u6D4B\u8BD5\u89C4\u683C", role: "e2e_test", layer: "verification", aliases: ["e2e-test", "e2e_tests", "tc"] },
+        e2e_registry: { paths: ["artifacts/tests/e2e/e2e-test-registry.json"], displayName: "E2E \u6D4B\u8BD5\u6CE8\u518C\u8868", role: "context", layer: "verification", aliases: ["e2e-registry"] },
+        "rule-golden-cases": { paths: ["artifacts/tests/rule-golden-cases.md"], displayName: "\u89C4\u5219\u9EC4\u91D1\u6D4B\u8BD5\u7528\u4F8B", role: "context", layer: "verification", aliases: ["rule_golden_cases"] },
+        "test-strategy": { paths: ["artifacts/design/test-strategy.md"], displayName: "\u6D4B\u8BD5\u7B56\u7565", role: "context", layer: "verification", aliases: ["test_strategy"] },
+        "traceability-matrix-v2": { paths: ["artifacts/traceability-matrix-v2.md"], displayName: "\u8FFD\u6EAF\u77E9\u9635 v2", role: "context", layer: "traceability", aliases: ["traceability_matrix_v2"] }
+      },
+      idPatterns: {
+        decision: "^D-[A-Z]+-\\d+$",
+        entity: "^E-\\d{3,}$",
+        feature: "^[A-Z]{1,4}\\d+$",
+        scenario: "^S-\\d+[a-z]?$",
+        design: "^[A-Za-z0-9._-]+$",
+        test: "^.+\\.test\\.ts$",
+        e2e_test: "^.+:(TC-\\d+[a-z]?|FILE)$",
+        e2e_registry: "^e2e-test-registry$",
+        "rule-golden-cases": "^[A-Z]+-\\d{3}:(pass|fail|edge)$",
+        "test-strategy": "^(unit|integration|e2e|desktop_chain|rule|contract)$",
+        "traceability-matrix-v2": "^.+$"
+      },
+      relationFields: {
+        feature: ["scenarios", "decisions", "depends_on", "design_docs"],
+        scenario: ["\u5173\u8054\u529F\u80FD", "\u5173\u8054\u51B3\u7B56"],
+        design: ["related_features", "related_scenarios"],
+        test: ["@scenario", "@feature", "@entity", "@decision"],
+        e2e_test: ["test_batch", "scope", "ac_coverage", "related_scenarios", "related_decisions", "related_entities", "\u8986\u76D6\u573A\u666F", "\u8986\u76D6\u529F\u80FD"],
+        e2e_registry: ["batches"]
+      },
+      allowedEdges: [],
+      forbiddenEdges: [{ from: "scenario", to: "entity", kind: "references" }],
+      statuses: ["planned", "active", "done", "deprecated"],
+      idRanges: {},
+      e2e: {
+        report_uncovered_scenarios: true,
+        report_uncovered_features: true,
+        runners: []
+      }
+    };
+    VALID_TC_STATUSES = /* @__PURE__ */ new Set(["created", "automated", "verified", "waived"]);
+    VALID_CHAIN_TYPES = /* @__PURE__ */ new Set([
+      "desktop_chain",
+      "mock_playwright",
+      "core_e2e",
+      "cli_e2e",
+      "ui_sidecar_bridge",
+      "partial_sidecar",
+      "partial_rust"
+    ]);
+    DEPRECATED_CHAIN_TYPE_ALIASES = {
+      core_only: "core_e2e",
+      frontend_only: "mock_playwright"
+    };
+    CONTEXT_CATEGORIES = {
+      feature: "prd",
+      scenario: "scenario",
+      decision: "decision",
+      design: "design",
+      entity: "entity",
+      "interface_contracts": "contract",
+      "data_contracts": "contract",
+      "application_state_machines": "contract",
+      "error_model": "contract",
+      "report-contracts": "contract",
+      "ui-flow-contracts": "contract",
+      "non-functional-budgets": "contract",
+      "domain-glossary": "domain",
+      "bounded-context-map": "domain",
+      "domain-invariants": "domain",
+      "generation-packet-spec": "domain",
+      "rule-golden-cases": "verification",
+      "test-strategy": "verification",
+      "verification-fixtures": "verification",
+      "implementation-blueprint": "blueprint",
+      "traceability-matrix-v2": "matrix"
+    };
+    TIER_ORDER = ["baseline", "target", "direct", "matrix", "transitive"];
+  }
+});
+init_index();
 export {
   ALWAYS_PRESENT_ITEMS as ALWAYS_PRESENT,
   BASELINE_CONSTRAINTS,
   BASELINE_CONSTRAINTS_COUNT,
   BASELINE_ITEMS_COUNT,
+  CONTRACT_ERROR_CODES,
+  ContractCatalog,
+  ContractError,
+  ContractRegistry,
   DEFAULT_MAX_CHARS,
   DEFAULT_SCHEMA,
+  E2E_NORMALIZER_CONFIG,
   MIN_PROMPT_CHARS,
   TARGET_ARTIFACT_TYPES,
   VALID_PACKET_TARGET_TYPES,
@@ -7113,6 +8021,7 @@ export {
   buildVersionIndex,
   collectChangedPaths,
   computeE2eCoverageStats,
+  computeRevisionDigest,
   dirname3 as dirname,
   discoverAndAuditPackets,
   discoverTargets,
@@ -7123,11 +8032,17 @@ export {
   getArtifactTypeMetadata,
   getTargetArtifactTypes,
   installManagedHookBlock,
+  isOfficialNamespace,
   isPacketTargetType,
   isPacketTargetTypeDynamic,
   isTargetArtifactType,
   loadConfig,
+  loadContract,
+  loadContractCatalog,
+  loadContractsFromDirectory,
   nextId,
+  normalizeE2eLegacyArtifact,
+  normalizeToCanonical,
   parseTargetSelector,
   parseTargetsFile,
   prepareManagedHookBlock,
@@ -7149,13 +8064,17 @@ export {
   scanArtifacts,
   traceVersion,
   updateVersionLock,
+  validateContractAgainstSchema,
   validateExecutableTraceability,
   validateGraph,
+  validateNamespaceAuthority,
   validatePacket,
   validatePacketMarkdown,
   validatePacketPrompt,
+  validatePolicyCompatibility,
   validateReviewResult,
   validateScenarioPrdLinkIndex,
   validateScenarioPrdLinks,
+  verifyDigest,
   writeGraphCache
 };