artifact-graph 0.4.1 → 0.6.0

package/dist/index.cjs

@@ -50,12 +50,14 @@ __export(index_exports, {
   buildGraph: () => buildGraph,
   buildVersionIndex: () => buildVersionIndex,
   collectChangedPaths: () => collectChangedPaths,
+  computeE2eCoverageStats: () => computeE2eCoverageStats,
   dirname: () => import_node_path6.dirname,
   discoverAndAuditPackets: () => discoverAndAuditPackets,
   discoverTargets: () => discoverTargets,
   doctorArtifactChain: () => doctorArtifactChain,
   extname: () => import_node_path6.extname,
   formatContextMarkdown: () => formatContextMarkdown,
+  generateE2eRegistry: () => generateE2eRegistry,
   getArtifactTypeMetadata: () => getArtifactTypeMetadata,
   getTargetArtifactTypes: () => getTargetArtifactTypes,
   installManagedHookBlock: () => installManagedHookBlock,
@@ -99,6 +101,7 @@ module.exports = __toCommonJS(index_exports);
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_node_fs4 = require("fs");
 var import_promises5 = require("fs/promises");
 var import_node_path6 = require("path");
 
@@ -179,13 +182,76 @@ function validatePacket(packet, schema) {
       path: "target.id"
     });
   }
-  if (packet.requiredBaseline.total !== BASELINE_ITEMS_COUNT) {
-    issues.push({
-      severity: "error",
-      code: "PKT-004",
-      message: `requiredBaseline.total must be ${BASELINE_ITEMS_COUNT}, got ${packet.requiredBaseline.total}`,
-      path: "requiredBaseline.total"
-    });
+  const isBaselineExplicitlyDisabled = packet.baselinePolicy === false;
+  const expectedPaths = new Set(ALWAYS_PRESENT_ITEMS.map((item) => item.path));
+  if (isBaselineExplicitlyDisabled) {
+    if (packet.requiredBaseline.total !== 0) {
+      issues.push({
+        severity: "error",
+        code: "PKT-004",
+        message: `baselinePolicy=false requires requiredBaseline.total=0, got ${packet.requiredBaseline.total}`,
+        path: "requiredBaseline.total"
+      });
+    }
+    if (packet.requiredBaseline.items.length !== 0) {
+      issues.push({
+        severity: "error",
+        code: "PKT-004",
+        message: `baselinePolicy=false requires requiredBaseline.items=[], got ${packet.requiredBaseline.items.length} item(s)`,
+        path: "requiredBaseline.items"
+      });
+    }
+  } else {
+    if (packet.requiredBaseline.total !== BASELINE_ITEMS_COUNT) {
+      issues.push({
+        severity: "error",
+        code: "PKT-004",
+        message: `requiredBaseline.total must be ${BASELINE_ITEMS_COUNT}, got ${packet.requiredBaseline.total}`,
+        path: "requiredBaseline.total"
+      });
+    }
+    if (packet.requiredBaseline.items.length !== BASELINE_ITEMS_COUNT) {
+      issues.push({
+        severity: "error",
+        code: "PKT-004",
+        message: `requiredBaseline.items.length must be ${BASELINE_ITEMS_COUNT}, got ${packet.requiredBaseline.items.length}`,
+        path: "requiredBaseline.items"
+      });
+    }
+    const actualPaths = packet.requiredBaseline.items.map((item) => item.path);
+    const actualPathSet = new Set(actualPaths);
+    if (actualPathSet.size !== actualPaths.length) {
+      issues.push({
+        severity: "error",
+        code: "PKT-004",
+        message: `requiredBaseline.items contains duplicate paths (${actualPaths.length} items, ${actualPathSet.size} unique)`,
+        path: "requiredBaseline.items"
+      });
+    }
+    const missingPaths = [];
+    for (const ep of expectedPaths) {
+      if (!actualPathSet.has(ep)) missingPaths.push(ep);
+    }
+    if (missingPaths.length > 0) {
+      issues.push({
+        severity: "error",
+        code: "PKT-004",
+        message: `requiredBaseline.items missing expected path(s): ${missingPaths.join(", ")}`,
+        path: "requiredBaseline.items"
+      });
+    }
+    const extraPaths = [];
+    for (const ap of actualPathSet) {
+      if (!expectedPaths.has(ap)) extraPaths.push(ap);
+    }
+    if (extraPaths.length > 0) {
+      issues.push({
+        severity: "error",
+        code: "PKT-004",
+        message: `requiredBaseline.items contains unexpected path(s): ${extraPaths.join(", ")}`,
+        path: "requiredBaseline.items"
+      });
+    }
   }
   const constraints = packet.implementationBlueprintDraft.constraints;
   if (constraints.length !== BASELINE_CONSTRAINTS_COUNT) {
@@ -292,6 +358,45 @@ function validatePacketMarkdown(markdown) {
   return { ok: !hasError, issues };
 }
 
+// src/glob-matcher.ts
+function matchesRunnerGlob(filePath, pattern) {
+  const normalizedPath = normalizeGlobValue(filePath);
+  const normalizedPattern = normalizeGlobValue(pattern);
+  let expression = "^";
+  for (let index = 0; index < normalizedPattern.length; index += 1) {
+    const character = normalizedPattern[index];
+    if (character === "*") {
+      if (normalizedPattern[index + 1] === "*") {
+        while (normalizedPattern[index + 1] === "*") {
+          index += 1;
+        }
+        if (normalizedPattern[index + 1] === "/") {
+          index += 1;
+          expression += "(?:[^/]+/)*";
+        } else {
+          expression += ".*";
+        }
+      } else {
+        expression += "[^/]*";
+      }
+      continue;
+    }
+    if (character === "?") {
+      expression += "[^/]";
+      continue;
+    }
+    expression += escapeRegexCharacter(character);
+  }
+  expression += "$";
+  return new RegExp(expression).test(normalizedPath);
+}
+function normalizeGlobValue(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function escapeRegexCharacter(character) {
+  return "\\^$+?.()|{}[]".includes(character) ? String.fromCharCode(92) + character : character;
+}
+
 // src/target-selector.ts
 function parseTargetSelector(value) {
   const separator = value.indexOf(":");
@@ -612,7 +717,10 @@ function assemblePacket(manifest, options) {
     missing: [...manifest.missing],
     missingDetails: manifest.missingDetails ? [...manifest.missingDetails] : void 0,
     implementationBlueprintDraft: blueprintDraft,
-    validationCommands
+    validationCommands,
+    // @feature ACA17
+    // @decision D-ACA-17
+    baselinePolicy: manifest.baselinePolicy
   };
   return packet;
 }
@@ -833,7 +941,9 @@ async function auditSingleTarget(target, graph, options) {
     const manifest = resolveArtifactContext(graph, {
       target: { type: target.type, id: target.id },
       mode: options.mode,
-      maxPerCategory: options.maxPerCategory
+      maxPerCategory: options.maxPerCategory,
+      universalBaseline: options.universalBaseline,
+      root: options.root
     });
     const packet = assemblePacket(manifest, {
       mode: options.mode,
@@ -970,6 +1080,7 @@ async function discoverAndAuditPackets(root, options) {
     type: d.type,
     id: d.id
   }));
+  const effectiveBaseline = options.universalBaseline ?? config.context?.universal_baseline;
   return auditPackets(root, targets, {
     root,
     outDir: options.outDir,
@@ -979,7 +1090,8 @@ async function discoverAndAuditPackets(root, options) {
     summaryOnly: options.summaryOnly,
     sampleTargets: options.sampleTargets,
     summaryDetail: options.summaryDetail,
-    schema: config
+    schema: config,
+    universalBaseline: effectiveBaseline
   }, graph);
 }
 
@@ -1302,6 +1414,7 @@ function validatePacketPrompt(prompt) {
 
 // src/versioned-traceability.ts
 var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
 var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
 var VERSION_LOCK_PATH = "artifacts/traceability-version-lock.json";
@@ -1342,13 +1455,15 @@ async function buildVersionIndex(root, graph) {
     edges: sortBy(edges, (edge2) => `${edge2.from}	${edge2.to}	${edge2.kind}	${edge2.sourcePath}	${edge2.sourceLine}`)
   };
 }
-async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph) {
+async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph, config) {
   const index = await buildVersionIndex(root, graph);
+  const schema = config ?? await loadConfig(root);
   const safeLockPath = normalizeRelativePath(root, lockPath);
   const lock = await readVersionLock(root, safeLockPath);
   const nodeByArtifact = new Map(index.nodes.map((node) => [`${node.type}:${node.id}`, node]));
   const nodeByPath = new Map(index.nodes.map((node) => [node.path, node]));
   const currentEdges = implementationEdges(index);
+  const lockableEdges = await lockableImplementationEdges(root, index, schema);
   const currentEdgeIds = new Set(currentEdges.map((edge2) => edge2.edgeId));
   const issues = [];
   let fresh = 0;
@@ -1436,8 +1551,29 @@ async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph) {
       issues.push(...entryIssues);
     }
   }
+  const livenessCache = /* @__PURE__ */ new Map();
+  for (const entry of lock.locks) {
+    if (entry.kind !== "verifies") continue;
+    const sourcePath = entry.source.path;
+    const fullSourcePath = (0, import_node_path2.join)(root, sourcePath);
+    if (!(0, import_node_fs.existsSync)(fullSourcePath)) continue;
+    let liveness = livenessCache.get(sourcePath);
+    if (liveness === void 0) {
+      liveness = await getTestFileRunnerLiveness(root, sourcePath, schema);
+      livenessCache.set(sourcePath, liveness);
+    }
+    if (liveness === "inactive") {
+      issues.push({
+        status: "orphan_lock",
+        edgeId: entry.edgeId,
+        message: `Liveness: ${sourcePath} is not active in any configured runner \u2014 locked verifies edges may reference dead tests`,
+        artifact: entry.artifact,
+        source: entry.source
+      });
+    }
+  }
   const reportedMissingLocks = /* @__PURE__ */ new Set();
-  for (const edge2 of currentEdges) {
+  for (const edge2 of lockableEdges) {
     const edgeId = edge2.edgeId;
     if (!lock.locks.some((entry) => entry.edgeId === edgeId)) {
       if (reportedMissingLocks.has(edgeId)) {
@@ -1519,6 +1655,7 @@ async function updateVersionLock(root, options) {
 }
 async function bootstrapVersionLock(root, options = {}) {
   const index = await buildVersionIndex(root);
+  const config = await loadConfig(root);
   const lockPath = normalizeRelativePath(root, options.lockPath ?? VERSION_LOCK_PATH);
   if (!options.force) {
     const existing = await readVersionLock(root, lockPath);
@@ -1528,7 +1665,7 @@ async function bootstrapVersionLock(root, options = {}) {
   }
   const nodeByUid = new Map(index.nodes.map((node) => [node.uid, node]));
   const entries = /* @__PURE__ */ new Map();
-  for (const edge2 of implementationEdges(index)) {
+  for (const edge2 of await lockableImplementationEdges(root, index, config)) {
     const source = nodeByUid.get(edge2.from);
     const artifact = nodeByUid.get(edge2.to);
     if (!source || !artifact) {
@@ -1563,10 +1700,11 @@ async function refreshVersionLock(root, options = {}) {
     throw new Error("Changed-only version-lock refresh includes artifact-graph.config.yaml and requires --all");
   }
   const index = await buildVersionIndex(root);
+  const config = await loadConfig(root);
   const lock = await readVersionLock(root, lockPath);
   const nodeByUid = new Map(index.nodes.map((node) => [node.uid, node]));
   const nodeByPath = new Map(index.nodes.map((node) => [node.path, node]));
-  const currentImplementationEdges = implementationEdges(index);
+  const currentImplementationEdges = await lockableImplementationEdges(root, index, config);
   const currentEdgePairs = new Set(currentImplementationEdges.map((edge2) => `${edge2.from}	${edge2.to}`));
   const currentEntries = /* @__PURE__ */ new Map();
   const changedPathSet = new Set(changedPaths);
@@ -1641,7 +1779,7 @@ async function refreshVersionLock(root, options = {}) {
     locks: sortBy([...nextLocks.values()], (item) => item.edgeId)
   };
   await writeVersionLock(root, lockPath, next);
-  const postAudit = await auditVersionLock(root, lockPath);
+  const postAudit = await auditVersionLock(root, lockPath, void 0, config);
   return {
     schemaVersion: "1.0",
     root,
@@ -1660,7 +1798,8 @@ async function refreshVersionLock(root, options = {}) {
 async function traceVersion(root, target, lockPath = VERSION_LOCK_PATH) {
   const index = await buildVersionIndex(root);
   const safeLockPath = normalizeRelativePath(root, lockPath);
-  const audit = await auditVersionLock(root, safeLockPath);
+  const config = await loadConfig(root);
+  const audit = await auditVersionLock(root, safeLockPath, void 0, config);
   const targetUid = parseTarget(target);
   const lock = await readVersionLock(root, safeLockPath);
   const targetNode = index.nodes.find((node) => node.uid === targetUid);
@@ -1896,6 +2035,28 @@ function implementationEdges(index) {
     };
   });
 }
+async function lockableImplementationEdges(root, index, config) {
+  const edges = implementationEdges(index);
+  const nodesByUid = new Map(index.nodes.map((node) => [node.uid, node]));
+  const livenessByPath = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const edge2 of edges) {
+    const source = nodesByUid.get(edge2.from);
+    if (source?.sourceKind !== "test") {
+      result.push(edge2);
+      continue;
+    }
+    let liveness = livenessByPath.get(source.path);
+    if (liveness === void 0) {
+      liveness = await getTestFileRunnerLiveness(root, source.path, config);
+      livenessByPath.set(source.path, liveness);
+    }
+    if (liveness !== "inactive") {
+      result.push(edge2);
+    }
+  }
+  return result;
+}
 function lockRefFromNode(node) {
   return {
     type: node.type,
@@ -2008,13 +2169,60 @@ function normalizeRelativePath(root, path) {
 function sortBy(items, keyFn) {
   return [...items].sort((left, right) => keyFn(left).localeCompare(keyFn(right)));
 }
+async function getTestFileRunnerLiveness(root, filePath, config) {
+  const schema = config ?? await loadConfig(root);
+  const runners = schema.e2e?.runners ?? [];
+  if (runners.length === 0) {
+    if (!/e2e/i.test(filePath) && !/\.e2e\./i.test(filePath)) {
+      return "active";
+    }
+    const fullSourcePath = (0, import_node_path2.join)(root, filePath);
+    if (!(0, import_node_fs.existsSync)(fullSourcePath)) return "inactive";
+    try {
+      const content = await (0, import_promises2.readFile)(fullSourcePath, "utf-8");
+      return /\/\/!?\s*@(?:e2e_test|tc)\s+/.test(content) ? "active" : "inactive";
+    } catch {
+      return "inactive";
+    }
+  }
+  let inRunnerScope = false;
+  for (const runner of runners) {
+    if (!isFileIncludedByRunner(filePath, runner)) continue;
+    inRunnerScope = true;
+    const isActive = await isFileActiveInRunner(root, filePath, runner);
+    if (isActive) return "active";
+  }
+  return inRunnerScope ? "inactive" : "unscoped";
+}
+function isFileIncludedByRunner(filePath, runner) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const runnerRoot = runner.root.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "") || ".";
+  if (runnerRoot !== "." && !normalizedPath.startsWith(`${runnerRoot}/`)) return false;
+  const relativePath = runnerRoot === "." ? normalizedPath : normalizedPath.slice(runnerRoot.length + 1);
+  return runner.include.some((pattern) => matchesRunnerGlob(relativePath, pattern));
+}
+async function isFileActiveInRunner(root, filePath, runner) {
+  if (!isFileIncludedByRunner(filePath, runner)) return false;
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const runnerRoot = runner.root.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "") || ".";
+  const relativePath = runnerRoot === "." ? normalizedPath : normalizedPath.slice(runnerRoot.length).replace(/^\//, "");
+  const matchesExclude = (runner.exclude ?? []).some(
+    (pattern) => matchesRunnerGlob(relativePath, pattern)
+  );
+  if (matchesExclude) return false;
+  const matchesTestIgnore = (runner.testIgnore ?? []).some(
+    (pattern) => matchesRunnerGlob(relativePath, pattern)
+  );
+  if (matchesTestIgnore) return false;
+  return true;
+}
 function sortUnique(items) {
   return [...new Set(items)].sort((left, right) => left.localeCompare(right));
 }
 
 // src/cli-resolver.ts
 var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_promises3 = require("fs/promises");
 var import_node_path3 = require("path");
 var import_node_util = require("util");
@@ -2152,7 +2360,7 @@ ${maybe.stderr ?? ""}`;
 }
 async function pathExists(path) {
   try {
-    await (0, import_promises3.access)(path, import_node_fs.constants.R_OK);
+    await (0, import_promises3.access)(path, import_node_fs2.constants.R_OK);
     return true;
   } catch {
     return false;
@@ -2251,7 +2459,7 @@ async function resolveGitHookPath(root, hookName) {
 }
 
 // src/hook-installer.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_crypto2 = require("crypto");
 var import_promises4 = require("fs/promises");
 var import_node_path5 = require("path");
@@ -2565,7 +2773,7 @@ async function readHookSnapshot(hookPath) {
     }
     let handle;
     try {
-      handle = await (0, import_promises4.open)(hookPath, import_node_fs2.constants.O_RDONLY | (import_node_fs2.constants.O_NOFOLLOW ?? 0));
+      handle = await (0, import_promises4.open)(hookPath, import_node_fs3.constants.O_RDONLY | (import_node_fs3.constants.O_NOFOLLOW ?? 0));
       const opened = await handle.stat({ bigint: true });
       if (opened.dev !== metadata.dev || opened.ino !== metadata.ino) {
         await handle.close();
@@ -2694,12 +2902,35 @@ var VALID_DECISIONS = /* @__PURE__ */ new Set([
 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)) {
     return [{ path: "$", message: "Root must be a non-null object" }];
   }
   const obj = input;
+  for (const key of Object.keys(obj)) {
+    if (!TOP_LEVEL_FIELDS.has(key)) {
+      errors.push({ path: `$.${key}`, message: "Unknown top-level property" });
+    }
+  }
   if (obj.schema_version !== "1.0") {
     errors.push({ path: "$.schema_version", message: `Must be "1.0", got ${JSON.stringify(obj.schema_version)}` });
   }
@@ -2718,8 +2949,8 @@ function validateReviewResult(input) {
   if (obj.stage_id !== void 0 && typeof obj.stage_id !== "string") {
     errors.push({ path: "$.stage_id", message: "Must be a string if present" });
   }
-  if (obj.attempt !== void 0 && (!Number.isInteger(obj.attempt) || obj.attempt < 1)) {
-    errors.push({ path: "$.attempt", message: "Must be a positive integer if present" });
+  if (obj.attempt !== void 0 && (!Number.isInteger(obj.attempt) || obj.attempt < 1 || obj.attempt > 3)) {
+    errors.push({ path: "$.attempt", message: "Must be an integer from 1 through 3 if present" });
   }
   if (obj.outputs !== void 0) {
     checkStringArray(obj.outputs, "$.outputs", errors);
@@ -2730,20 +2961,14 @@ function validateReviewResult(input) {
   checkOptionalNullableString(obj.blocking_reason, "$.blocking_reason", errors);
   checkOptionalNullableString(obj.degradation, "$.degradation", errors);
   if (obj.producer !== void 0) {
-    if (!isPlainObject(obj.producer)) {
-      errors.push({ path: "$.producer", message: "Must be an object" });
-    } else {
-      const p = obj.producer;
-      if (typeof p.executor !== "string") {
-        errors.push({ path: "$.producer.executor", message: "Must be a string" });
-      } else if (!VALID_EXECUTORS.has(p.executor)) {
-        errors.push({ path: "$.producer.executor", message: `Must be one of ${[...VALID_EXECUTORS].join(", ")}; got ${JSON.stringify(p.executor)}` });
-      }
-      if (typeof p.name !== "string") {
-        errors.push({ path: "$.producer.name", message: "Must be a string" });
-      }
-      checkOptionalString(p.skill, "$.producer.skill", errors);
-    }
+    validateProducer(obj.producer, "$.producer", errors);
+  }
+  const successfulAcceptance = obj.status === "SUCCEEDED" && (obj.decision === "PASS" || obj.decision === "PASS_WITH_RESIDUAL_MINOR");
+  if (successfulAcceptance && obj.producer === void 0) {
+    errors.push({ path: "$.producer", message: "Successful acceptance requires producer identity" });
+  }
+  if (obj.acceptance !== void 0) {
+    validateAcceptance(obj.acceptance, obj.producer, "$.acceptance", errors);
   }
   if (obj.evidence !== void 0) {
     if (!Array.isArray(obj.evidence)) {
@@ -2769,6 +2994,17 @@ function validateReviewResult(input) {
   }
   if (obj.review !== void 0) {
     validateReviewData(obj.review, "$.review", errors);
+    if (obj.decision === "PASS" || obj.decision === "PASS_WITH_RESIDUAL_MINOR") {
+      const findings = isPlainObject(obj.review) && Array.isArray(obj.review.findings) ? obj.review.findings : [];
+      findings.forEach((finding, index) => {
+        if (isPlainObject(finding) && finding.severity === "block" && (finding.status === void 0 || finding.status === "open")) {
+          errors.push({
+            path: `$.review.findings[${index}]`,
+            message: `${obj.decision} cannot contain an open block finding`
+          });
+        }
+      });
+    }
   }
   if (obj.repair !== void 0) {
     if (!isPlainObject(obj.repair)) {
@@ -2804,6 +3040,47 @@ function checkStringArray(val, path, errors) {
 function isPlainObject(val) {
   return typeof val === "object" && val !== null && !Array.isArray(val);
 }
+function validateProducer(val, path, errors) {
+  if (!isPlainObject(val)) {
+    errors.push({ path, message: "Must be an object" });
+    return;
+  }
+  if (typeof val.executor !== "string") {
+    errors.push({ path: `${path}.executor`, message: "Must be a string" });
+  } else if (!VALID_EXECUTORS.has(val.executor)) {
+    errors.push({ path: `${path}.executor`, message: `Must be one of ${[...VALID_EXECUTORS].join(", ")}; got ${JSON.stringify(val.executor)}` });
+  }
+  if (typeof val.name !== "string" || val.name.length === 0) {
+    errors.push({ path: `${path}.name`, message: "Must be a non-empty string" });
+  }
+  checkOptionalString(val.skill, `${path}.skill`, errors);
+}
+function producerIdentity(val) {
+  return JSON.stringify([val.executor, val.name]);
+}
+function validateAcceptance(val, resultProducer, path, errors) {
+  if (!isPlainObject(val)) {
+    errors.push({ path, message: "Must be an object" });
+    return;
+  }
+  validateProducer(val.reviewer, `${path}.reviewer`, errors);
+  if (!isPlainObject(val.source_result)) {
+    errors.push({ path: `${path}.source_result`, message: "Must be an object" });
+    return;
+  }
+  const source = val.source_result;
+  if (typeof source.run_id !== "string" || source.run_id.length === 0) {
+    errors.push({ path: `${path}.source_result.run_id`, message: "Must be a non-empty string" });
+  }
+  checkOptionalString(source.stage_id, `${path}.source_result.stage_id`, errors);
+  validateProducer(source.producer, `${path}.source_result.producer`, errors);
+  if (isPlainObject(val.reviewer) && isPlainObject(resultProducer) && producerIdentity(val.reviewer) !== producerIdentity(resultProducer)) {
+    errors.push({ path: `${path}.reviewer`, message: "Acceptance reviewer must match the result producer" });
+  }
+  if (isPlainObject(val.reviewer) && isPlainObject(source.producer) && producerIdentity(val.reviewer) === producerIdentity(source.producer)) {
+    errors.push({ path: `${path}.reviewer`, message: "Repair producer cannot accept its own result" });
+  }
+}
 function checkOptionalString(val, path, errors) {
   if (val !== void 0 && typeof val !== "string") {
     errors.push({ path, message: "Must be a string if present" });
@@ -2972,7 +3249,7 @@ var DEFAULT_SCHEMA = {
     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"] },
+    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"] },
@@ -3002,7 +3279,12 @@ var DEFAULT_SCHEMA = {
   allowedEdges: [],
   forbiddenEdges: [{ from: "scenario", to: "entity", kind: "references" }],
   statuses: ["planned", "active", "done", "deprecated"],
-  idRanges: {}
+  idRanges: {},
+  e2e: {
+    report_uncovered_scenarios: true,
+    report_uncovered_features: true,
+    runners: []
+  }
 };
 async function loadConfig(root) {
   const configPath = (0, import_node_path6.join)(root, "artifact-graph.config.yaml");
@@ -3015,7 +3297,27 @@ async function loadConfig(root) {
       throw error;
     }
   }
-  return {
+  const ub = parsed.context?.universal_baseline;
+  if (ub !== void 0 && typeof ub !== "boolean") {
+    throw new Error(
+      `Invalid context.universal_baseline: ${JSON.stringify(ub)}. Must be boolean (true or false).`
+    );
+  }
+  if (parsed.e2e !== void 0) {
+    if (typeof parsed.e2e !== "object" || parsed.e2e === null || Array.isArray(parsed.e2e)) {
+      throw new Error("Invalid e2e: must be an object.");
+    }
+    validateE2eConfig(parsed.e2e);
+  }
+  const mergedE2e = parsed.e2e === void 0 ? DEFAULT_SCHEMA.e2e : {
+    ...DEFAULT_SCHEMA.e2e,
+    ...parsed.e2e,
+    runners: (parsed.e2e.runners ?? DEFAULT_SCHEMA.e2e?.runners ?? []).map((runner) => ({
+      kind: "e2e",
+      ...runner
+    }))
+  };
+  const merged = {
     ...DEFAULT_SCHEMA,
     ...parsed,
     types: mergeArtifactTypes(DEFAULT_SCHEMA.types, parsed.types),
@@ -3024,10 +3326,103 @@ async function loadConfig(root) {
     allowedEdges: parsed.allowedEdges ?? DEFAULT_SCHEMA.allowedEdges,
     forbiddenEdges: parsed.forbiddenEdges ?? DEFAULT_SCHEMA.forbiddenEdges,
     statuses: parsed.statuses ?? DEFAULT_SCHEMA.statuses,
-    idRanges: mergeRecord(DEFAULT_SCHEMA.idRanges, parsed.idRanges)
+    idRanges: mergeRecord(DEFAULT_SCHEMA.idRanges, parsed.idRanges),
+    e2e: mergedE2e
   };
+  return merged;
 }
-function buildGraph(nodes, edges, diagnostics = []) {
+function validateE2eConfig(e2e) {
+  for (const field of ["report_uncovered_scenarios", "report_uncovered_features"]) {
+    if (e2e[field] !== void 0 && typeof e2e[field] !== "boolean") {
+      throw new Error(`Invalid e2e.${field}: must be boolean.`);
+    }
+  }
+  if (e2e.executable_ref_warning !== void 0) {
+    if (typeof e2e.executable_ref_warning !== "number" || e2e.executable_ref_warning < 0 || e2e.executable_ref_warning > 1) {
+      throw new Error(`Invalid e2e.executable_ref_warning: ${JSON.stringify(e2e.executable_ref_warning)}. Must be a number between 0 and 1.`);
+    }
+  }
+  if (e2e.executable_ref_error !== void 0) {
+    if (typeof e2e.executable_ref_error !== "number" || e2e.executable_ref_error < 0 || e2e.executable_ref_error > 1) {
+      throw new Error(`Invalid e2e.executable_ref_error: ${JSON.stringify(e2e.executable_ref_error)}. Must be a number between 0 and 1.`);
+    }
+  }
+  const validateWaivers = (waivers, field) => {
+    if (waivers === void 0) return;
+    if (!Array.isArray(waivers)) {
+      throw new Error(`Invalid ${field}: must be an array of {id, reason} objects.`);
+    }
+    for (const w of waivers) {
+      if (typeof w !== "object" || w === null || !("id" in w) || !("reason" in w)) {
+        throw new Error(`Invalid ${field} entry: ${JSON.stringify(w)}. Must be {id, reason} object.`);
+      }
+      if (typeof w.id !== "string" || !w.id.trim()) {
+        throw new Error(`Invalid ${field} entry: id must be a non-empty string. Got: ${JSON.stringify(w.id)}`);
+      }
+      if (typeof w.reason !== "string" || !w.reason.trim()) {
+        throw new Error(`Invalid ${field} entry: reason must be a non-empty string. Got: ${JSON.stringify(w.reason)}`);
+      }
+    }
+  };
+  validateWaivers(e2e.scenario_waivers, "e2e.scenario_waivers");
+  validateWaivers(e2e.feature_waivers, "e2e.feature_waivers");
+  if (e2e.runners !== void 0) {
+    if (!Array.isArray(e2e.runners)) {
+      throw new Error(`Invalid e2e.runners: must be an array.`);
+    }
+    for (const runner of e2e.runners) {
+      if (typeof runner !== "object" || runner === null) {
+        throw new Error(`Invalid e2e.runners entry: must be an object.`);
+      }
+      if (typeof runner.name !== "string" || !runner.name.trim()) {
+        throw new Error(`Invalid e2e.runners entry: name must be a non-empty string.`);
+      }
+      if (typeof runner.root !== "string" || !runner.root.trim()) {
+        throw new Error(`Invalid e2e.runners[${runner.name}].root: must be a non-empty string.`);
+      }
+      if ((0, import_node_path6.isAbsolute)(runner.root)) {
+        throw new Error(`Invalid e2e.runners[${runner.name}].root: "${runner.root}" must not be an absolute path.`);
+      }
+      if (runner.root.replace(/\\/g, "/").split("/").includes("..")) {
+        throw new Error(`Invalid e2e.runners[${runner.name}].root: "${runner.root}" must not contain ".." segments.`);
+      }
+      if (!Array.isArray(runner.include) || runner.include.length === 0) {
+        throw new Error(`Invalid e2e.runners[${runner.name}].include: must be a non-empty array of glob patterns.`);
+      }
+      for (const pattern of runner.include) {
+        if (typeof pattern !== "string" || !pattern.trim()) {
+          throw new Error(`Invalid e2e.runners[${runner.name}].include: pattern must be a non-empty string.`);
+        }
+      }
+      if (runner.exclude !== void 0) {
+        if (!Array.isArray(runner.exclude)) {
+          throw new Error(`Invalid e2e.runners[${runner.name}].exclude: must be an array.`);
+        }
+        for (const pattern of runner.exclude) {
+          if (typeof pattern !== "string" || !pattern.trim()) {
+            throw new Error(`Invalid e2e.runners[${runner.name}].exclude: pattern must be a non-empty string.`);
+          }
+        }
+      }
+      if (runner.testIgnore !== void 0) {
+        if (!Array.isArray(runner.testIgnore)) {
+          throw new Error(`Invalid e2e.runners[${runner.name}].testIgnore: must be an array.`);
+        }
+        for (const pattern of runner.testIgnore) {
+          if (typeof pattern !== "string" || !pattern.trim()) {
+            throw new Error(`Invalid e2e.runners[${runner.name}].testIgnore: pattern must be a non-empty string.`);
+          }
+        }
+      }
+      if (runner.kind !== void 0) {
+        if (!["unit", "integration", "e2e"].includes(runner.kind)) {
+          throw new Error(`Invalid e2e.runners[${runner.name}].kind: "${runner.kind}". Must be unit, integration, or e2e.`);
+        }
+      }
+    }
+  }
+}
+function buildGraph(nodes, edges, diagnostics = [], root) {
   const graphNodes = nodes.map((node) => ({ ...node, uid: toUid(node.type, node.code) }));
   graphNodes.sort(compareNode);
   edges.sort(compareEdge);
@@ -3044,6 +3439,7 @@ function buildGraph(nodes, edges, diagnostics = []) {
     nodes: graphNodes,
     edges: dedupedEdges,
     generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    ...root ? { root } : {},
     diagnostics: diagnostics.sort((left, right) => left.code.localeCompare(right.code) || left.path.localeCompare(right.path) || left.line - right.line)
   };
 }
@@ -3075,7 +3471,8 @@ async function scanArtifacts(root, schema) {
       scanDiagnostics.push(...parsed.diagnostics);
     }
   }
-  const graph = buildGraph(nodes, edges, scanDiagnostics);
+  const absoluteRoot = (0, import_node_path6.isAbsolute)(root) ? root : (0, import_node_path6.resolve)(root);
+  const graph = buildGraph(nodes, edges, scanDiagnostics, absoluteRoot);
   return resolveMatrixEdges(graph);
 }
 function artifactTypeEntriesBySpecificity(schema) {
@@ -3415,23 +3812,34 @@ async function validateScenarioPrdLinkIndex(root, graph) {
 function validateCodeCommentTraceabilityFormat(graph) {
   const issues = [];
   for (const node of graph.nodes) {
-    if (node.type !== "test") {
+    if (node.type !== "test" && node.type !== "implementation") {
       continue;
     }
     const invalidComments = node.attrs?.invalidTraceabilityComments;
-    if (!Array.isArray(invalidComments)) {
-      continue;
+    if (Array.isArray(invalidComments)) {
+      for (const invalid of invalidComments) {
+        const line = typeof invalid?.line === "number" ? invalid.line : node.line;
+        const reason = typeof invalid?.reason === "string" ? invalid.reason : "traceability tags must use standalone // comments";
+        issues.push(issue(
+          "CODE_COMMENT_TRACEABILITY_FORMAT",
+          `${reason}: ${typeof invalid?.text === "string" ? invalid.text : ""}`.trim(),
+          node.path,
+          line,
+          { node: node.uid }
+        ));
+      }
     }
-    for (const invalid of invalidComments) {
-      const line = typeof invalid?.line === "number" ? invalid.line : node.line;
-      const reason = typeof invalid?.reason === "string" ? invalid.reason : "traceability tags must use standalone // comments";
-      issues.push(issue(
-        "CODE_COMMENT_TRACEABILITY_FORMAT",
-        `${reason}: ${typeof invalid?.text === "string" ? invalid.text : ""}`.trim(),
-        node.path,
-        line,
-        { node: node.uid }
-      ));
+    const deprecatedComments = node.attrs?.deprecatedTraceabilityComments;
+    if (Array.isArray(deprecatedComments)) {
+      for (const deprecated of deprecatedComments) {
+        issues.push(issue(
+          "E2E-TRACE-007",
+          "@tc is deprecated; use @e2e_test instead",
+          node.path,
+          typeof deprecated?.line === "number" ? deprecated.line : node.line,
+          { node: node.uid, severity: "warning" }
+        ));
+      }
     }
   }
   return issues;
@@ -3913,13 +4321,16 @@ function parseTest(path, raw, schema = DEFAULT_SCHEMA) {
   const isTest = isTestFile(path);
   const nodeType = isTest ? "test" : "implementation";
   const edgeKind = isTest ? "verifies" : "implements";
+  const attrs = {};
+  if (traceabilityComments.invalid.length > 0) attrs.invalidTraceabilityComments = traceabilityComments.invalid;
+  if (traceabilityComments.deprecated.length > 0) attrs.deprecatedTraceabilityComments = traceabilityComments.deprecated;
   const node = {
     type: nodeType,
     code: path,
     title: path.split("/").at(-1) ?? path,
     path,
     line: 1,
-    attrs: traceabilityComments.invalid.length > 0 ? { invalidTraceabilityComments: traceabilityComments.invalid } : {}
+    attrs
   };
   let hasTags = false;
   for (const { tags, lineNumber } of traceabilityComments.canonical) {
@@ -3930,7 +4341,7 @@ function parseTest(path, raw, schema = DEFAULT_SCHEMA) {
       }
     }
   }
-  if (hasTags || traceabilityComments.invalid.length > 0) {
+  if (hasTags || traceabilityComments.invalid.length > 0 || traceabilityComments.deprecated.length > 0) {
     nodes.push(node);
   }
   return { nodes, edges };
@@ -3938,6 +4349,7 @@ function parseTest(path, raw, schema = DEFAULT_SCHEMA) {
 function scanTraceabilityComments(raw, schema = DEFAULT_SCHEMA) {
   const canonical = [];
   const invalid = [];
+  const deprecated = [];
   for (const comment of scanCodeComments(raw)) {
     if (!containsTraceabilityTag(comment.text, schema)) {
       continue;
@@ -3953,6 +4365,9 @@ function scanTraceabilityComments(raw, schema = DEFAULT_SCHEMA) {
     const parsed = parseTraceabilityTagLine(comment.text.trim(), schema);
     if (parsed.valid) {
       canonical.push({ tags: parsed.tags, lineNumber: comment.lineNumber });
+      if (/(?:^|\s)@tc(?=\s|$)/.test(comment.text.trim())) {
+        deprecated.push({ line: comment.lineNumber, text: comment.text.trim() });
+      }
     } else {
       invalid.push({ line: comment.lineNumber, text: comment.text.trim(), reason: parsed.reason });
     }
@@ -3968,11 +4383,14 @@ function scanTraceabilityComments(raw, schema = DEFAULT_SCHEMA) {
     const parsed = parseTraceabilityTagLine(comment.text.trim(), schema);
     if (parsed.valid) {
       canonical.push({ tags: parsed.tags, lineNumber: comment.lineNumber });
+      if (/(?:^|\s)@tc(?=\s|$)/.test(comment.text.trim())) {
+        deprecated.push({ line: comment.lineNumber, text: comment.text.trim() });
+      }
     } else {
       invalid.push({ line: comment.lineNumber, text: comment.text.trim(), reason: parsed.reason });
     }
   }
-  return { canonical, invalid };
+  return { canonical, invalid, deprecated };
 }
 function scanCodeComments(raw) {
   const comments = [];
@@ -4139,7 +4557,14 @@ function expandCodeRange(value) {
   return Array.from({ length: end - start + 1 }, (_, index) => `${prefix}${String(start + index).padStart(width, "0")}`);
 }
 function containsTraceabilityTag(value, schema = DEFAULT_SCHEMA) {
-  return /@[\w][\w-]*\b/.test(value);
+  const tokens = /* @__PURE__ */ new Set();
+  for (const [type, definition] of Object.entries(schema.types)) {
+    tokens.add(type);
+    for (const alias of definition.aliases ?? []) tokens.add(alias);
+  }
+  if (tokens.size === 0) return false;
+  const alternatives = [...tokens].sort((a, b) => b.length - a.length).map((token) => token.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|");
+  return new RegExp(`(?:^|\\s)@(?:${alternatives})(?=\\s|$)`).test(value);
 }
 function parseDesign(path, raw) {
   const parsed = (0, import_gray_matter.default)(raw);
@@ -5144,6 +5569,29 @@ function validateE2eTests(graph) {
         issues.push(issue("E2E_AC_UNKNOWN", `${node.uid} references unknown AC ${reference.feature}(${reference.ac})`, node.path, node.line, { node: node.uid, severity: "warning" }));
       }
     }
+    const tcStatus = String(fields["status"] ?? "").trim().toLowerCase();
+    if (tcStatus && !VALID_TC_STATUSES.has(tcStatus)) {
+      issues.push(issue("E2E_INVALID_TC_STATUS", `${node.uid} has invalid TC status "${tcStatus}"; allowed: ${[...VALID_TC_STATUSES].join(", ")}`, node.path, node.line, { node: node.uid, severity: "warning" }));
+    }
+    if (tcStatus === "waived") {
+      const reason = String(fields["waived_reason"] ?? "").trim();
+      if (!reason) {
+        issues.push(issue("E2E_WAIVED_NO_REASON", `${node.uid} has status "waived" but no waived_reason`, node.path, node.line, { node: node.uid, severity: "warning" }));
+      }
+    }
+    const rawChainType = String(fields["chain_type"] ?? "").trim();
+    const chainType = rawChainType.toLowerCase();
+    if (rawChainType) {
+      if (!VALID_CHAIN_TYPES.has(chainType) && !(chainType in DEPRECATED_CHAIN_TYPE_ALIASES)) {
+        issues.push(issue("E2E_INVALID_CHAIN_TYPE", `${node.uid} has invalid chain_type "${rawChainType}"; allowed: ${[...VALID_CHAIN_TYPES].join(", ")}`, node.path, node.line, { node: node.uid, severity: "warning" }));
+      } else if (chainType in DEPRECATED_CHAIN_TYPE_ALIASES) {
+        issues.push(issue("E2E_DEPRECATED_CHAIN_TYPE", `${node.uid} uses deprecated chain_type "${rawChainType}"; migrate to "${DEPRECATED_CHAIN_TYPE_ALIASES[chainType]}"`, node.path, node.line, { node: node.uid, severity: "warning" }));
+      }
+    }
+    const rawAcCoverageRate = String(fields["ac_coverage_rate"] ?? "").trim();
+    if (rawAcCoverageRate) {
+      issues.push(issue("E2E_AC_COVERAGE_RATE_FREETEXT", `${node.uid} has handwritten ac_coverage_rate "${rawAcCoverageRate}"; this field must be derived from ac_coverage and the feature acceptance-criteria inventory`, node.path, node.line, { node: node.uid, severity: "warning" }));
+    }
     if (needsDesktopChainWarning(node)) {
       issues.push(issue("E2E_DESKTOP_CHAIN_WARNING", `${node.uid} appears desktop-related but does not cover the full React/UI -> Tauri/IPC -> Node sidecar/JSON Lines -> core/engine -> SQLite/report data \u771F\u5B9E\u684C\u9762\u94FE\u8DEF`, node.path, node.line, { node: node.uid, severity: "warning" }));
     }
@@ -5202,10 +5650,10 @@ function validateE2eRegistry(graph) {
   }
   return issues;
 }
-async function validateExecutableTraceability(root) {
+async function validateExecutableTraceability(root, config) {
   const issues = [];
+  const schema = config ?? await loadConfig(root);
   const e2eDir = (0, import_node_path6.join)(root, "artifacts", "tests", "e2e");
-  const specPatterns = ["heimdall/**/*.spec.ts", "heimdall/**/*.e2e.spec.ts"];
   let e2eFiles;
   try {
     e2eFiles = (await (0, import_promises5.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path6.join)(e2eDir, name));
@@ -5248,16 +5696,23 @@ async function validateExecutableTraceability(root) {
   }
   const allFiles = await walk(root);
   const specFiles = /* @__PURE__ */ new Set();
-  for (const pattern of specPatterns) {
+  const configuredRunners = schema.e2e?.runners ?? [];
+  if (configuredRunners.length > 0) {
     for (const file of allFiles) {
-      if (matchesPattern(file, pattern)) {
+      if (configuredRunners.some((runner) => isRunnerIncludeCandidate(file, runner))) {
+        specFiles.add(file);
+      }
+    }
+  } else {
+    for (const file of allFiles) {
+      if (/\.(?:e2e\.)?spec\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(file)) {
         specFiles.add(file);
       }
     }
   }
   const refToSource = /* @__PURE__ */ new Map();
-  const tcAnnotationRegex = /\/\/!?\s*@tc\s+(\S+?)\s+\[(\w+)\]/;
-  const tcAnnotationNoLevelRegex = /\/\/!?\s*@tc\s+(\S+)/;
+  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 = (0, import_node_path6.join)(root, specFile);
     let content;
@@ -5321,12 +5776,21 @@ async function validateExecutableTraceability(root) {
     const refEntries = parseExecutableRefLines(ref);
     const validFiles = [];
     for (const entry of refEntries) {
-      const normalizedRefFile = entry.file.startsWith("heimdall/") ? entry.file : `heimdall/${entry.file}`;
-      const fileExists = specFiles.has(normalizedRefFile);
+      const normalizedRefFile = resolveExecutableRefFile(entry.file, allFiles);
+      const fileExists = normalizedRefFile !== void 0 && specFiles.has(normalizedRefFile);
       if (!fileExists) {
         issues.push(issue("E2E-TRACE-001", `executable_ref target file not found: ${entry.file}`, path, line, { node: tcKey, severity: "warning" }));
         continue;
       }
+      const runners = schema.e2e?.runners ?? [];
+      if (runners.length > 0) {
+        const acceptingRunners = await getAcceptingRunners(root, normalizedRefFile, runners);
+        const hasE2eRunner = acceptingRunners.some((r) => r.kind === "e2e" || r.kind === "integration");
+        const hasUnitRunner = acceptingRunners.some((r) => r.kind === "unit");
+        if (hasUnitRunner && !hasE2eRunner && acceptingRunners.length > 0) {
+          issues.push(issue("E2E-UNIT-TEST-NOT-E2E", `executable_ref target ${entry.file} is only accepted by unit runner(s) [${acceptingRunners.map((r) => r.name).join(", ")}], not by any e2e/integration runner`, path, line, { node: tcKey, severity: "warning" }));
+        }
+      }
       if (entry.testId) {
         let content;
         try {
@@ -5341,12 +5805,9 @@ async function validateExecutableTraceability(root) {
         }
       }
       const annotationsForTc = refToSource.get(tcKey);
-      const hasAnnotationInFile = annotationsForTc?.some((ann) => {
-        const normalizedAnnFile = ann.file.startsWith("heimdall/") ? ann.file : `heimdall/${ann.file}`;
-        return normalizedAnnFile === normalizedRefFile;
-      }) ?? false;
+      const hasAnnotationInFile = annotationsForTc?.some((ann) => ann.file === normalizedRefFile) ?? false;
       if (!hasAnnotationInFile) {
-        issues.push(issue("E2E-TRACE-003", `executable_ref target ${entry.file} has no // @tc ${tcKey} line-comment annotation`, path, line, { node: tcKey, severity: "warning" }));
+        issues.push(issue("E2E-TRACE-003", `executable_ref target ${entry.file} has no E2E trace annotation ${tcKey}`, path, line, { node: tcKey, severity: "warning" }));
         continue;
       }
       validFiles.push(normalizedRefFile);
@@ -5357,13 +5818,13 @@ async function validateExecutableTraceability(root) {
     const batch = tcKey.split(":")[0];
     if (!mdBatches.has(batch)) {
       for (const ann of annotations) {
-        issues.push(issue("E2E-TRACE-002", `@tc annotation ${tcKey} references non-existent E2E batch "${batch}"`, ann.file, ann.line, { node: tcKey, severity: "warning" }));
+        issues.push(issue("E2E-TRACE-002", `E2E trace annotation ${tcKey} references non-existent E2E batch "${batch}"`, ann.file, ann.line, { node: tcKey, severity: "warning" }));
       }
       continue;
     }
     if (!mdToRef.has(tcKey) && !await hasMarkdownTc(tcKey, e2eDir)) {
       for (const ann of annotations) {
-        issues.push(issue("E2E-TRACE-002", `@tc annotation ${tcKey} references non-existent Markdown TC`, ann.file, ann.line, { node: tcKey, severity: "warning" }));
+        issues.push(issue("E2E-TRACE-002", `E2E trace annotation ${tcKey} references non-existent Markdown TC`, ann.file, ann.line, { node: tcKey, severity: "warning" }));
       }
     }
   }
@@ -5382,24 +5843,37 @@ async function validateExecutableTraceability(root) {
       if (matchesAnyRef) {
         continue;
       }
-      const primaryRef = refEntries[0];
-      const normalizedPrimary = primaryRef?.file.startsWith("heimdall/") ? primaryRef?.file : `heimdall/${primaryRef?.file ?? ""}`;
       const detail = `file: MD refs=[${refEntries.map((e) => e.file).join(", ")}] vs source=${ann.file}`;
-      issues.push(issue("E2E-TRACE-003", `executable_ref \u2194 @tc mismatch for ${tcKey}: ${detail}`, path, line, { node: tcKey, severity: "warning" }));
+      issues.push(issue("E2E-TRACE-003", `executable_ref \u2194 E2E trace annotation mismatch for ${tcKey}: ${detail}`, path, line, { node: tcKey, severity: "warning" }));
     }
   }
-  for (const [tcKey, { chainType, path, line }] of mdToRef) {
-    if (!isDesktopChainType(chainType)) {
+  for (const [tcKey, { chainType, path, line }] of allMdTcInfo) {
+    const tcFields = tcKeyToFields.get(tcKey);
+    const explicitChainType = String(tcFields?.["chain_type"] ?? "").trim().toLowerCase();
+    if (explicitChainType !== "desktop_chain") {
       continue;
     }
+    if (!mdToRef.has(tcKey)) {
+      issues.push(issue("E2E-DESKTOP-CHAIN-MISSING", `desktop_chain TC ${tcKey} has no executable_ref`, path, line, { node: tcKey, severity: "warning" }));
+    }
+  }
+  for (const [tcKey, { chainType, path, line }] of mdToRef) {
+    const normalizedDeclaredChainType = chainType.trim().toLowerCase();
+    const hasLegalNonDesktopDeclaration = normalizedDeclaredChainType.length > 0 && VALID_CHAIN_TYPES.has(normalizedDeclaredChainType) && normalizedDeclaredChainType !== "desktop_chain";
+    if (hasLegalNonDesktopDeclaration) continue;
     const validFiles = new Set(tcValidRefFiles.get(tcKey) ?? []);
     const sourceAnnotations = refToSource.get(tcKey);
     if (!sourceAnnotations) {
       continue;
     }
+    const tcFields = tcKeyToFields.get(tcKey);
+    const explicitChainType = String(tcFields?.["chain_type"] ?? "").trim().toLowerCase();
+    const hasExplicitDesktopChain = explicitChainType === "desktop_chain";
+    if (hasExplicitDesktopChain) {
+      continue;
+    }
     for (const ann of sourceAnnotations) {
-      const normalizedAnnFile = ann.file.startsWith("heimdall/") ? ann.file : `heimdall/${ann.file}`;
-      if (!validFiles.has(normalizedAnnFile)) {
+      if (!validFiles.has(ann.file)) {
         continue;
       }
       if (ann.level === "mock_playwright") {
@@ -5425,10 +5899,7 @@ async function validateExecutableTraceability(root) {
       continue;
     }
     const validFiles = new Set(tcValidRefFiles.get(tcKey) ?? []);
-    const sourceAnnotations = refToSource.get(tcKey)?.filter((ann) => {
-      const normalized = ann.file.startsWith("heimdall/") ? ann.file : `heimdall/${ann.file}`;
-      return validFiles.has(normalized);
-    });
+    const sourceAnnotations = refToSource.get(tcKey)?.filter((ann) => validFiles.has(ann.file));
     const hasDesktopChain = sourceAnnotations?.some((ann) => ann.level === "desktop_chain") ?? false;
     const hasBridge = sourceAnnotations?.some((ann) => ann.level === "ui_sidecar_bridge") ?? false;
     if (isComplete) {
@@ -5437,7 +5908,7 @@ async function validateExecutableTraceability(root) {
       if (hasDesktopChain) {
         hasValidEvidence = true;
       } else if (hasBridge) {
-        const partialResult = await validatePartialRustEvidence(tcFields, tcKey, root);
+        const partialResult = await validatePartialRustEvidence(tcFields, tcKey, root, allFiles);
         if (partialResult.hasValidPartialRust) {
           hasValidEvidence = true;
         } else {
@@ -5477,7 +5948,7 @@ async function validateExecutableTraceability(root) {
       }
       let partialDetail = "";
       if (hasBridge) {
-        const partialResult = await validatePartialRustEvidence(tcFields, tcKey, root);
+        const partialResult = await validatePartialRustEvidence(tcFields, tcKey, root, allFiles);
         if (partialResult.hasValidPartialRust) {
           continue;
         }
@@ -5494,6 +5965,287 @@ async function validateExecutableTraceability(root) {
   }
   return issues;
 }
+async function computeE2eCoverageStats(graph, root, thresholds = {}) {
+  const e2eNodes = graph.nodes.filter((n) => n.type === "e2e_test" && n.attrs?.fileLevelOnly !== true);
+  const totalTestCases = e2eNodes.length;
+  let withExecutableRef = 0;
+  const statusBreakdown = {};
+  const chainTypeBreakdown = {};
+  const e2eDir = (0, import_node_path6.join)(root, "artifacts", "tests", "e2e");
+  const tcFieldsMap = /* @__PURE__ */ new Map();
+  let e2eFiles;
+  try {
+    e2eFiles = (await (0, import_promises5.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path6.join)(e2eDir, name));
+  } catch {
+    e2eFiles = [];
+  }
+  for (const filePath of e2eFiles) {
+    const raw = await (0, import_promises5.readFile)(filePath, "utf-8");
+    const lines = raw.split(/\r?\n/);
+    const tcStarts = [];
+    lines.forEach((line, index) => {
+      const match = /^#{2,3}\s+(TC-\d+[a-z]?)\s*[:：]?\s*.*$/.exec(line);
+      if (match) {
+        tcStarts.push({ id: match[1], index });
+      }
+    });
+    const parsed = (0, import_gray_matter.default)(raw);
+    const batch = String(parsed.data.test_batch ?? (0, import_node_path6.basename)(filePath, (0, import_node_path6.extname)(filePath))).trim();
+    for (let i = 0; i < tcStarts.length; i++) {
+      const start = tcStarts[i];
+      const end = tcStarts[i + 1]?.index ?? lines.length;
+      const block = lines.slice(start.index, end);
+      const fields = extractE2eTcFields(block);
+      tcFieldsMap.set(`${batch}:${start.id}`, fields);
+    }
+  }
+  for (const node of e2eNodes) {
+    const tcKey = node.code;
+    const fields = tcFieldsMap.get(tcKey) ?? asRecord(node.attrs?.tcFields);
+    const execRef = String(fields["executable_ref"] ?? "").trim();
+    if (execRef && !isPendingExecutableRef(execRef)) {
+      withExecutableRef++;
+    }
+    const status = String(fields["status"] ?? "created").trim().toLowerCase();
+    statusBreakdown[status] = (statusBreakdown[status] ?? 0) + 1;
+    const chainType = String(fields["chain_type"] ?? "").trim().toLowerCase() || "unspecified";
+    chainTypeBreakdown[chainType] = (chainTypeBreakdown[chainType] ?? 0) + 1;
+  }
+  const executableRefRate = totalTestCases > 0 ? `${withExecutableRef}/${totalTestCases} (${(withExecutableRef / totalTestCases * 100).toFixed(1)}%)` : "0/0";
+  const scenarioNodes = graph.nodes.filter((n) => n.type === "scenario");
+  const featureNodes = graph.nodes.filter((n) => n.type === "feature");
+  const linkedScenarios = /* @__PURE__ */ new Set();
+  const linkedFeatures = /* @__PURE__ */ new Set();
+  const acCoveredScenarios = /* @__PURE__ */ new Set();
+  const acCoveredFeatures = /* @__PURE__ */ new Set();
+  const verifiedScenarios = /* @__PURE__ */ new Set();
+  const verifiedFeatures = /* @__PURE__ */ new Set();
+  for (const edge2 of graph.edges) {
+    if (edge2.kind === "verifies" && edge2.from.startsWith("e2e_test:")) {
+      if (edge2.to.startsWith("scenario:")) {
+        linkedScenarios.add(edge2.to.replace("scenario:", ""));
+      }
+      if (edge2.to.startsWith("feature:")) {
+        linkedFeatures.add(edge2.to.replace("feature:", ""));
+      }
+    }
+  }
+  for (const node of e2eNodes) {
+    const fields = tcFieldsMap.get(node.code) ?? asRecord(node.attrs?.tcFields);
+    const acCoverage = asRecord(fields["ac_coverage"] ?? node.attrs?.ac_coverage);
+    for (const feature of Object.keys(acCoverage)) {
+      acCoveredFeatures.add(feature);
+    }
+    const relatedScenarios = toArray(fields["related_scenarios"] ?? node.attrs?.related_scenarios).map(String);
+    for (const scenario of relatedScenarios) {
+      acCoveredScenarios.add(scenario);
+    }
+  }
+  const runners = (await loadConfig(root)).e2e?.runners ?? [];
+  const allProjectFiles = await walk(root);
+  for (const node of e2eNodes) {
+    const fields = tcFieldsMap.get(node.code) ?? asRecord(node.attrs?.tcFields);
+    const status = String(fields["status"] ?? "").trim().toLowerCase();
+    const execRef = String(fields["executable_ref"] ?? "").trim();
+    if (status !== "verified") continue;
+    if (!execRef || isPendingExecutableRef(execRef)) continue;
+    if (runners.length === 0) continue;
+    let hasActiveE2eRef = false;
+    for (const entry of parseExecutableRefLines(execRef)) {
+      const normalized = resolveExecutableRefFile(entry.file, allProjectFiles);
+      if (!normalized || !(0, import_node_fs4.existsSync)((0, import_node_path6.join)(root, normalized))) continue;
+      const accepting = await getAcceptingRunners(root, normalized, runners);
+      if (accepting.some((runner) => runner.kind === "e2e")) {
+        hasActiveE2eRef = true;
+        break;
+      }
+    }
+    if (!hasActiveE2eRef) continue;
+    const relatedScenarios = toArray(fields["related_scenarios"] ?? node.attrs?.related_scenarios).map(String);
+    for (const scenario of relatedScenarios) {
+      verifiedScenarios.add(scenario);
+    }
+    const acCoverage = asRecord(fields["ac_coverage"] ?? node.attrs?.ac_coverage);
+    for (const feature of Object.keys(acCoverage)) {
+      verifiedFeatures.add(feature);
+    }
+  }
+  const scenarioWaivers = new Set((thresholds.scenarioWaivers ?? []).map((w) => w.id));
+  const featureWaivers = new Set((thresholds.featureWaivers ?? []).map((w) => w.id));
+  const uncoveredScenarios = scenarioNodes.map((n) => n.code).filter((code) => !linkedScenarios.has(code) && !scenarioWaivers.has(code));
+  const uncoveredFeatures = featureNodes.map((n) => n.code).filter((code) => !acCoveredFeatures.has(code) && !featureWaivers.has(code));
+  const scenarioCoverage = {};
+  for (const node of scenarioNodes) {
+    scenarioCoverage[node.code] = {
+      linked: linkedScenarios.has(node.code),
+      acCovered: acCoveredScenarios.has(node.code),
+      waived: scenarioWaivers.has(node.code),
+      verified: !scenarioWaivers.has(node.code) && verifiedScenarios.has(node.code)
+    };
+  }
+  const featureCoverage = {};
+  for (const node of featureNodes) {
+    featureCoverage[node.code] = {
+      linked: linkedFeatures.has(node.code),
+      acCovered: acCoveredFeatures.has(node.code),
+      waived: featureWaivers.has(node.code),
+      verified: !featureWaivers.has(node.code) && verifiedFeatures.has(node.code)
+    };
+  }
+  const thresholdWarnings = [];
+  const thresholdErrors = [];
+  const warningRate = thresholds.executableRefWarning;
+  const errorRate = thresholds.executableRefError;
+  const actualRate = totalTestCases > 0 ? withExecutableRef / totalTestCases : 1;
+  if (warningRate !== void 0 && actualRate < warningRate) {
+    thresholdWarnings.push(`executable_ref coverage ${executableRefRate} < warning threshold ${(warningRate * 100).toFixed(0)}%`);
+  }
+  if (errorRate !== void 0 && actualRate < errorRate) {
+    thresholdErrors.push(`executable_ref coverage ${executableRefRate} < error threshold ${(errorRate * 100).toFixed(0)}%`);
+  }
+  if (thresholds.reportUncoveredScenarios !== false && uncoveredScenarios.length > 0) {
+    thresholdWarnings.push(`${uncoveredScenarios.length} scenario(s) have no E2E coverage: ${uncoveredScenarios.join(", ")}`);
+  }
+  if (thresholds.reportUncoveredFeatures !== false && uncoveredFeatures.length > 0) {
+    thresholdWarnings.push(`${uncoveredFeatures.length} feature(s) have no E2E coverage: ${uncoveredFeatures.join(", ")}`);
+  }
+  const acCoverageRateByFeature = {};
+  const featureAcMap = /* @__PURE__ */ new Map();
+  for (const node of featureNodes) {
+    const acs = parseAcceptanceCriteria(await (0, import_promises5.readFile)((0, import_node_path6.join)(root, node.path), "utf-8"));
+    featureAcMap.set(node.code, new Set(acs));
+  }
+  const coveredAcByFeature = /* @__PURE__ */ new Map();
+  for (const node of e2eNodes) {
+    const fields = tcFieldsMap.get(node.code) ?? asRecord(node.attrs?.tcFields);
+    const acCoverage = asRecord(fields["ac_coverage"] ?? node.attrs?.ac_coverage);
+    for (const [feature, acs] of Object.entries(acCoverage)) {
+      const existing = coveredAcByFeature.get(feature) ?? /* @__PURE__ */ new Set();
+      for (const ac of toArray(acs)) {
+        existing.add(String(ac));
+      }
+      coveredAcByFeature.set(feature, existing);
+    }
+  }
+  for (const [feature, allAcs] of featureAcMap) {
+    const denominator = allAcs.size;
+    if (denominator === 0) continue;
+    const coveredAcs = coveredAcByFeature.get(feature) ?? /* @__PURE__ */ new Set();
+    const numerator = [...coveredAcs].filter((ac) => allAcs.has(ac)).length;
+    acCoverageRateByFeature[feature] = {
+      numerator,
+      denominator,
+      rate: denominator > 0 ? numerator / denominator : 0
+    };
+  }
+  return {
+    totalTestCases,
+    withExecutableRef,
+    executableRefRate,
+    statusBreakdown,
+    chainTypeBreakdown,
+    uncoveredScenarios,
+    uncoveredFeatures,
+    thresholdWarnings,
+    thresholdErrors,
+    acCoverageRateByFeature,
+    scenarioCoverage,
+    featureCoverage
+  };
+}
+async function generateE2eRegistry(root, opts) {
+  const e2eDir = (0, import_node_path6.join)(root, "artifacts", "tests", "e2e");
+  let files;
+  try {
+    files = (await (0, import_promises5.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
+  } catch {
+    return {
+      registry_version: "1.0",
+      generated_at: opts?.deterministic ? "1970-01-01T00:00:00.000Z" : (/* @__PURE__ */ new Date()).toISOString(),
+      total_batches: 0,
+      total_test_cases: 0,
+      batches: []
+    };
+  }
+  const batches = [];
+  let totalTestCases = 0;
+  for (const file of files) {
+    const filePath = (0, import_node_path6.join)(e2eDir, file);
+    const raw = await (0, import_promises5.readFile)(filePath, "utf-8");
+    const parsed = (0, import_gray_matter.default)(raw);
+    const data = parsed.data;
+    const batch = String(data.test_batch ?? (0, import_node_path6.basename)(file, (0, import_node_path6.extname)(file))).trim();
+    const relPath = `artifacts/tests/e2e/${file}`;
+    const scope = String(data.scope ?? "").trim();
+    const acCoverage = normalizeAcCoverageForRegistry(data.ac_coverage);
+    const relatedScenarios = toArray(data.related_scenarios).map(String).filter(Boolean);
+    const lines = raw.split(/\r?\n/);
+    const tcStarts = [];
+    lines.forEach((line, index) => {
+      const match = /^#{2,3}\s+(TC-\d+[a-z]?)\s*[:：]?\s*.*$/.exec(line);
+      if (match) {
+        tcStarts.push({ id: match[1], index });
+      }
+    });
+    const statusSummary = {};
+    const blockingReasons = {};
+    const frontmatterFixesBlock = String(data.fixes_block ?? "").trim();
+    if (frontmatterFixesBlock && /no\s+(test\s+file|e2e)/i.test(frontmatterFixesBlock)) {
+      for (const tc of tcStarts) {
+        blockingReasons[tc.id] = frontmatterFixesBlock;
+      }
+    }
+    for (const start of tcStarts) {
+      const end = tcStarts[tcStarts.indexOf(start) + 1]?.index ?? lines.length;
+      const block = lines.slice(start.index, end);
+      const fields = extractE2eTcFields(block);
+      const status = String(fields["status"] ?? "created").trim().toLowerCase() || "created";
+      statusSummary[status] = (statusSummary[status] ?? 0) + 1;
+      if (status === "created" && !blockingReasons[start.id]) {
+        const executableRef = String(fields["executable_ref"] ?? "").trim();
+        const chainType = String(fields["chain_type"] ?? "").trim().toLowerCase();
+        if (!executableRef && chainType === "desktop_chain") {
+          blockingReasons[start.id] = "desktop_chain TC requires executable_ref";
+        } else if (isPendingExecutableRef(executableRef)) {
+          blockingReasons[start.id] = `pending: ${executableRef}`;
+        }
+      }
+    }
+    const testCaseCount = tcStarts.length;
+    totalTestCases += testCaseCount;
+    const batchStatus = Object.keys(blockingReasons).length > 0 ? "blocked" : void 0;
+    batches.push({
+      batch_id: batch,
+      file: relPath,
+      scope,
+      ac_coverage: acCoverage,
+      related_scenarios: relatedScenarios,
+      test_case_count: testCaseCount,
+      status_summary: statusSummary,
+      status: batchStatus,
+      blocking_reasons: Object.keys(blockingReasons).length > 0 ? blockingReasons : void 0
+    });
+  }
+  return {
+    registry_version: "1.0",
+    generated_at: opts?.deterministic ? "1970-01-01T00:00:00.000Z" : (/* @__PURE__ */ new Date()).toISOString(),
+    total_batches: batches.length,
+    total_test_cases: totalTestCases,
+    batches
+  };
+}
+function normalizeAcCoverageForRegistry(value) {
+  if (!value || typeof value !== "object") return {};
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (Array.isArray(val)) {
+      result[key] = val.map(String);
+    } else if (typeof val === "string") {
+      result[key] = val.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  return result;
+}
 function isPendingExecutableRef(ref) {
   const stripped = ref.replace(/^[\s-*()]+/, "").trim();
   return /^pending\b/i.test(stripped);
@@ -5511,6 +6263,20 @@ 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 === "";
@@ -5518,7 +6284,7 @@ function isDesktopChainType(chainType) {
 function parseChainCoverageStatus(chainCoverage) {
   return chainCoverage.trim().toLowerCase().match(/^[a-z_]+/)?.[0] ?? "";
 }
-async function validatePartialRustEvidence(tcFields, tcKey, root) {
+async function validatePartialRustEvidence(tcFields, tcKey, root, allFiles) {
   const partialEvidence = String(tcFields["partial_evidence"] ?? "");
   if (!partialEvidence.trim()) {
     return { hasValidPartialRust: false, detail: "no partial_evidence field" };
@@ -5542,7 +6308,10 @@ async function validatePartialRustEvidence(tcFields, tcKey, root) {
     return { hasValidPartialRust: false, detail: "no .rs file in partial_evidence" };
   }
   for (const ref of rustRefs) {
-    const normalizedPath = ref.file.startsWith("heimdall/") ? ref.file : `heimdall/${ref.file}`;
+    const normalizedPath = resolveExecutableRefFile(ref.file, allFiles);
+    if (!normalizedPath) {
+      return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
+    }
     const fullPath = (0, import_node_path6.join)(root, normalizedPath);
     let content;
     try {
@@ -5551,14 +6320,14 @@ async function validatePartialRustEvidence(tcFields, tcKey, root) {
       return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
     }
     const tcAnnotationPattern = new RegExp(
-      `//[/!]?\\s*@tc\\s+${escapeRegExp(tcKey)}\\s+\\[partial_rust\\]`
+      `//[/!]?\\s*@(?:e2e_test|tc)\\s+${escapeRegExp(tcKey)}\\s+\\[partial_rust\\]`
     );
     if (!tcAnnotationPattern.test(content)) {
-      const noLevelPattern = new RegExp(`//[/!]?\\s*@tc\\s+${escapeRegExp(tcKey)}\\b`);
+      const noLevelPattern = new RegExp(`//[/!]?\\s*@(?:e2e_test|tc)\\s+${escapeRegExp(tcKey)}\\b`);
       if (noLevelPattern.test(content)) {
-        return { hasValidPartialRust: false, detail: `partial_rust file ${ref.file} has @tc ${tcKey} but not tagged [partial_rust]` };
+        return { hasValidPartialRust: false, detail: `partial_rust file ${ref.file} has E2E trace annotation ${tcKey} but not tagged [partial_rust]` };
       }
-      return { hasValidPartialRust: false, detail: `partial_rust file ${ref.file} has no @tc ${tcKey} annotation` };
+      return { hasValidPartialRust: false, detail: `partial_rust file ${ref.file} has no E2E trace annotation ${tcKey}` };
     }
   }
   return { hasValidPartialRust: true, detail: "ok" };
@@ -5578,6 +6347,46 @@ function detectTestLevel(specFile, content) {
   }
   return "desktop_chain";
 }
+function resolveExecutableRefFile(refFile, allFiles) {
+  const normalized = refFile.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!normalized || (0, import_node_path6.isAbsolute)(refFile) || normalized.split("/").includes("..")) {
+    return void 0;
+  }
+  if (allFiles.includes(normalized)) {
+    return normalized;
+  }
+  const suffix = `/${normalized}`;
+  const matches = allFiles.filter((file) => file.endsWith(suffix));
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function isRunnerIncludeCandidate(filePath, runner) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const runnerRoot = runner.root.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "") || ".";
+  if (runnerRoot !== "." && !normalizedPath.startsWith(`${runnerRoot}/`)) {
+    return false;
+  }
+  const relativePath = runnerRoot === "." ? normalizedPath : normalizedPath.slice(runnerRoot.length + 1);
+  return runner.include.some((pattern) => matchesRunnerGlob(relativePath, pattern));
+}
+async function getAcceptingRunners(root, filePath, runners) {
+  const accepting = [];
+  for (const runner of runners) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const runnerRoot = runner.root.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "") || ".";
+    const relativePath = runnerRoot === "." ? normalizedPath : normalizedPath.startsWith(runnerRoot + "/") ? normalizedPath.slice(runnerRoot.length + 1) : normalizedPath;
+    if (runnerRoot !== "." && !normalizedPath.startsWith(`${runnerRoot}/`)) {
+      continue;
+    }
+    const matchesInclude = runner.include.some((p) => matchesRunnerGlob(relativePath, p));
+    if (!matchesInclude) continue;
+    const matchesExclude = (runner.exclude ?? []).some((p) => matchesRunnerGlob(relativePath, p));
+    if (matchesExclude) continue;
+    const matchesTestIgnore = (runner.testIgnore ?? []).some((p) => matchesRunnerGlob(relativePath, p));
+    if (matchesTestIgnore) continue;
+    accepting.push(runner);
+  }
+  return accepting;
+}
 function splitMarkdownCells(line) {
   const cells = [];
   let current = "";
@@ -5731,7 +6540,7 @@ function flattenAcCoverage(value) {
 function needsDesktopChainWarning(node) {
   const tcFields = asRecord(node.attrs?.tcFields);
   const chainType = String(tcFields["chain_type"] ?? "").trim().toLowerCase();
-  if (chainType === "frontend_only" || chainType === "core_only") {
+  if (chainType && VALID_CHAIN_TYPES.has(chainType) && chainType !== "desktop_chain" || chainType in DEPRECATED_CHAIN_TYPE_ALIASES) {
     return false;
   }
   const chainCoverage = String(tcFields["chain_coverage"] ?? "").trim().toLowerCase();
@@ -5885,9 +6694,14 @@ function mergeRecord(base, override) {
 function mergeArtifactTypes(base, override) {
   const result = { ...base };
   for (const [type, definition] of Object.entries(override ?? {})) {
+    const aliases = [
+      ...base[type]?.aliases ?? [],
+      ...definition.aliases ?? []
+    ].filter((alias, index, all) => all.indexOf(alias) === index);
     result[type] = {
       ...base[type] ?? {},
-      ...definition
+      ...definition,
+      ...aliases.length > 0 ? { aliases } : {}
     };
   }
   return result;
@@ -5981,6 +6795,8 @@ var TIER_ORDER = ["baseline", "target", "direct", "matrix", "transitive"];
 function resolveArtifactContext(graph, opts) {
   const mode = opts.mode ?? "full";
   const maxPerCategory = opts.maxPerCategory ?? 20;
+  const universalBaseline = opts.universalBaseline ?? true;
+  const root = opts.root ?? graph.root;
   const legacyCount = [opts.feature, opts.scenario, opts.decision, opts.design, opts.e2e_test].filter(Boolean).length;
   if (opts.target && legacyCount > 0) {
     return {
@@ -6133,12 +6949,80 @@ function resolveArtifactContext(graph, opts) {
     return "direct";
   }
   const pathMap = /* @__PURE__ */ new Map();
-  for (const ap of ALWAYS_PRESENT_ITEMS) {
-    const existing = pathMap.get(ap.path);
-    if (existing) {
-      if (!existing.reasons.includes(ap.reason)) existing.reasons.push(ap.reason);
+  if (universalBaseline) {
+    for (const ap of ALWAYS_PRESENT_ITEMS) {
+      const existing = pathMap.get(ap.path);
+      if (existing) {
+        if (!existing.reasons.includes(ap.reason)) existing.reasons.push(ap.reason);
+      } else {
+        pathMap.set(ap.path, { path: ap.path, reasons: [ap.reason], category: "baseline", required: true, tier: "baseline" });
+      }
+    }
+    if (root) {
+      for (const ap of ALWAYS_PRESENT_ITEMS) {
+        const fullPath = (0, import_node_path6.join)(root, ap.path);
+        let stat;
+        try {
+          stat = (0, import_node_fs4.statSync)(fullPath);
+        } catch {
+          stat = null;
+        }
+        if (!stat) {
+          const msg = `Required baseline artifact not found: ${ap.path}`;
+          if (!missing.includes(msg)) {
+            missing.push(msg);
+            missingDetails.push({
+              ref: ap.path,
+              from: "baseline",
+              kind: "missing-baseline",
+              message: msg,
+              suggestedAction: `\u521B\u5EFA\u6587\u4EF6 ${ap.path} \u6216\u914D\u7F6E\u8DF3\u8FC7 universal baseline`
+            });
+          }
+        } else if (!stat.isFile()) {
+          const msg = `Required baseline artifact is not a regular file: ${ap.path}`;
+          if (!missing.includes(msg)) {
+            missing.push(msg);
+            missingDetails.push({
+              ref: ap.path,
+              from: "baseline",
+              kind: "missing-baseline",
+              message: msg,
+              suggestedAction: `\u5C06 ${ap.path} \u4ECE\u76EE\u5F55\u6539\u4E3A\u6587\u4EF6\uFF0C\u6216\u914D\u7F6E\u8DF3\u8FC7 universal baseline`
+            });
+          }
+        } else {
+          try {
+            (0, import_node_fs4.accessSync)(fullPath, import_node_fs4.constants.R_OK);
+          } catch {
+            const msg = `Required baseline artifact is not readable: ${ap.path}`;
+            if (!missing.includes(msg)) {
+              missing.push(msg);
+              missingDetails.push({
+                ref: ap.path,
+                from: "baseline",
+                kind: "missing-baseline",
+                message: msg,
+                suggestedAction: `\u4FEE\u590D ${ap.path} \u7684\u6587\u4EF6\u6743\u9650\uFF0C\u6216\u914D\u7F6E\u8DF3\u8FC7 universal baseline`
+              });
+            }
+          }
+        }
+      }
     } else {
-      pathMap.set(ap.path, { path: ap.path, reasons: [ap.reason], category: "baseline", required: true, tier: "baseline" });
+      for (const ap of ALWAYS_PRESENT_ITEMS) {
+        const msg = `Cannot verify baseline without root: ${ap.path}`;
+        if (!missing.includes(msg)) {
+          missing.push(msg);
+          missingDetails.push({
+            ref: ap.path,
+            from: "baseline",
+            kind: "missing-baseline",
+            message: msg,
+            suggestedAction: `\u4F20\u9012 root \u53C2\u6570\u6216\u914D\u7F6E\u8DF3\u8FC7 universal baseline`
+          });
+        }
+      }
     }
   }
   pathMap.set(targetNode.path, {
@@ -6239,7 +7123,8 @@ function resolveArtifactContext(graph, opts) {
     context,
     missing,
     missingDetails,
-    omitted
+    omitted,
+    baselinePolicy: universalBaseline
   };
 }
 function formatContextMarkdown(manifest) {
@@ -6327,12 +7212,14 @@ function formatContextMarkdown(manifest) {
   buildGraph,
   buildVersionIndex,
   collectChangedPaths,
+  computeE2eCoverageStats,
   dirname,
   discoverAndAuditPackets,
   discoverTargets,
   doctorArtifactChain,
   extname,
   formatContextMarkdown,
+  generateE2eRegistry,
   getArtifactTypeMetadata,
   getTargetArtifactTypes,
   installManagedHookBlock,