artifact-graph 0.8.3 → 0.8.5

package/dist/index.cjs

@@ -362,6 +362,41 @@ var init_glob_matcher = __esm({
   }
 });
 
+// src/file-walker.ts
+async function walkFiles(root, current = root, readDirectory = defaultReadDirectory) {
+  let entries;
+  try {
+    entries = await readDirectory(current, { withFileTypes: true });
+  } catch (error) {
+    if (current !== root && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  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 = (0, import_node_path.join)(current, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFiles(root, fullPath, readDirectory));
+    } else {
+      files.push((0, import_node_path.relative)(root, fullPath).split("\\").join("/"));
+    }
+  }
+  return files;
+}
+var import_promises, import_node_path, defaultReadDirectory;
+var init_file_walker = __esm({
+  "src/file-walker.ts"() {
+    "use strict";
+    import_promises = require("fs/promises");
+    import_node_path = require("path");
+    defaultReadDirectory = import_promises.readdir;
+  }
+});
+
 // src/target-selector.ts
 function parseTargetSelector(value) {
   const separator = value.indexOf(":");
@@ -965,14 +1000,14 @@ async function auditSingleTarget(target, graph, options) {
       const fmt = options.format ?? "markdown";
       const ext = fmt === "json" ? "json" : "md";
       const filename = `${target.type}-${target.id}.packet.${ext}`;
-      const outPath = (0, import_node_path.join)(options.outDir, filename);
+      const outPath = (0, import_node_path2.join)(options.outDir, filename);
       let content;
       if (fmt === "json") {
         content = JSON.stringify(packet, null, 2) + "\n";
       } else {
         content = renderPacketMarkdown(packet);
       }
-      await (0, import_promises.writeFile)(outPath, content, "utf-8");
+      await (0, import_promises2.writeFile)(outPath, content, "utf-8");
       entry.outputPath = outPath;
     }
   } catch (error) {
@@ -993,7 +1028,7 @@ async function auditPackets(root, targets, options, graph) {
     }
   }
   if (options.outDir) {
-    await (0, import_promises.mkdir)(options.outDir, { recursive: true });
+    await (0, import_promises2.mkdir)(options.outDir, { recursive: true });
   }
   const sampleSet = options.sampleTargets ? new Set(options.sampleTargets) : null;
   const sampleOutputPaths = [];
@@ -1045,8 +1080,8 @@ async function auditPackets(root, targets, options, graph) {
     ...isCompact ? { summaryDetail: "compact", countsByType } : {}
   };
   if (options.outDir) {
-    const summaryPath = (0, import_node_path.join)(options.outDir, "summary.json");
-    await (0, import_promises.writeFile)(summaryPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
+    const summaryPath = (0, import_node_path2.join)(options.outDir, "summary.json");
+    await (0, import_promises2.writeFile)(summaryPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
   }
   return summary;
 }
@@ -1072,14 +1107,14 @@ async function discoverAndAuditPackets(root, options) {
     universalBaseline: effectiveBaseline
   }, graph);
 }
-var import_promises, import_node_path, VALID_TYPES, VALID_TYPES_LABEL;
+var import_promises2, import_node_path2, VALID_TYPES, VALID_TYPES_LABEL;
 var init_packet_audit = __esm({
   "src/packet-audit.ts"() {
     "use strict";
     init_index();
     init_packet_validator();
-    import_promises = require("fs/promises");
-    import_node_path = require("path");
+    import_promises2 = require("fs/promises");
+    import_node_path2 = require("path");
     VALID_TYPES = new Set(VALID_PACKET_TARGET_TYPES);
     VALID_TYPES_LABEL = VALID_PACKET_TARGET_TYPES.join(", ");
   }
@@ -1551,7 +1586,7 @@ async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph, confi
   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);
+    const fullSourcePath = (0, import_node_path3.join)(root, sourcePath);
     if (!(0, import_node_fs.existsSync)(fullSourcePath)) continue;
     let liveness = livenessCache.get(sourcePath);
     if (liveness === void 0) {
@@ -1563,6 +1598,7 @@ async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph, confi
         status: "orphan_lock",
         edgeId: entry.edgeId,
         message: `Liveness: ${sourcePath} is not active in any configured runner \u2014 locked verifies edges may reference dead tests`,
+        severity: "warning",
         artifact: entry.artifact,
         source: entry.source
       });
@@ -1645,14 +1681,14 @@ async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph, confi
         currentArtifactHash: targetNode.contentHash
       });
     }
-    if (!(0, import_node_fs.existsSync)((0, import_node_path2.join)(root, sourceNode.path))) {
+    if (!(0, import_node_fs.existsSync)((0, import_node_path3.join)(root, sourceNode.path))) {
       entryIssues.push({
         status: "orphan_lock",
         edgeId: relEdgeId,
         message: `Artifact relation source file ${sourceNode.path} no longer exists`
       });
     }
-    if (!(0, import_node_fs.existsSync)((0, import_node_path2.join)(root, targetNode.path))) {
+    if (!(0, import_node_fs.existsSync)((0, import_node_path3.join)(root, targetNode.path))) {
       entryIssues.push({
         status: "orphan_lock",
         edgeId: relEdgeId,
@@ -1692,7 +1728,84 @@ async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph, confi
     fresh,
     totalArtifactRelationLocks: artifactRelationLocks.length,
     artifactRelationFresh,
-    issues: sortBy(issues, (issue2) => `${issue2.status}	${issue2.edgeId}	${issue2.verifiedByPath ?? ""}`)
+    issues: sortBy(issues.map(enrichVersionLockIssue), (issue2) => `${issue2.status}	${issue2.edgeId}	${issue2.verifiedByPath ?? ""}`)
+  };
+}
+function isLivenessIssue(issue2) {
+  return issue2.status === "orphan_lock" && issue2.message.startsWith(LIVENESS_MESSAGE_PREFIX);
+}
+function versionLockIssueSeverity(issue2) {
+  if (issue2.severity) {
+    return issue2.severity;
+  }
+  if (issue2.status === "missing_lock") {
+    return "warning";
+  }
+  if (issue2.status === "orphan_lock" && issue2.message.startsWith(LIVENESS_MESSAGE_PREFIX)) {
+    return "warning";
+  }
+  return "error";
+}
+function isVersionLockIssueBlocking(issue2, strictMissingLock) {
+  if (issue2.status === "missing_lock") {
+    return strictMissingLock;
+  }
+  return versionLockIssueSeverity(issue2) === "error";
+}
+function versionLockIssueRemediation(issue2) {
+  switch (issue2.status) {
+    case "artifact_changed":
+      return [
+        "\u786E\u8BA4\u8FD9\u6B21\u5236\u54C1\u53D8\u66F4\uFF08\u5185\u5BB9\u6216\u8DEF\u5F84\uFF09\u662F\u6709\u610F\u7684\u3002",
+        "\u8FD0\u884C `artifact-graph version-lock refresh --changed-only --worktree --format markdown`\uFF08\u65E5\u5E38\u5F00\u53D1\uFF09\u6216 `artifact-graph version-lock refresh --changed-only --staged --format markdown`\uFF08\u63D0\u4EA4\u524D\uFF09\u5237\u65B0\u53D7\u5F71\u54CD\u7684\u9501\u3002",
+        "\u8FD0\u884C `git diff artifacts/traceability-version-lock.json` \u5BA1\u67E5\u9501\u53D8\u66F4\uFF0C\u786E\u8BA4\u540E `git add artifacts/traceability-version-lock.json` \u5E76\u91CD\u65B0\u63D0\u4EA4\u3002"
+      ];
+    case "source_changed":
+      return [
+        "\u786E\u8BA4\u8FD9\u6B21\u6E90\u7801/\u6D4B\u8BD5\u53D8\u66F4\uFF08\u5185\u5BB9\u6216\u8DEF\u5F84\uFF09\u662F\u6709\u610F\u7684\u3002",
+        "\u8FD0\u884C `artifact-graph version-lock refresh --changed-only --worktree --format markdown`\uFF08\u65E5\u5E38\u5F00\u53D1\uFF09\u6216 `artifact-graph version-lock refresh --changed-only --staged --format markdown`\uFF08\u63D0\u4EA4\u524D\uFF09\u5237\u65B0\u53D7\u5F71\u54CD\u7684\u9501\u3002",
+        "\u8FD0\u884C `git diff artifacts/traceability-version-lock.json` \u5BA1\u67E5\u9501\u53D8\u66F4\uFF0C\u786E\u8BA4\u540E `git add artifacts/traceability-version-lock.json` \u5E76\u91CD\u65B0\u63D0\u4EA4\u3002"
+      ];
+    case "verified_by_changed":
+      return [
+        "\u786E\u8BA4\u8FD9\u6B21\u9A8C\u8BC1\u6587\u4EF6\u53D8\u66F4\u662F\u6709\u610F\u7684\u3002",
+        "\u8FD0\u884C `artifact-graph version-lock refresh --changed-only --worktree --format markdown`\uFF08\u65E5\u5E38\u5F00\u53D1\uFF09\u6216 `artifact-graph version-lock refresh --changed-only --staged --format markdown`\uFF08\u63D0\u4EA4\u524D\uFF09\u5237\u65B0\u53D7\u5F71\u54CD\u7684\u9501\u3002",
+        "\u8FD0\u884C `git diff artifacts/traceability-version-lock.json` \u5BA1\u67E5\u9501\u53D8\u66F4\uFF0C\u786E\u8BA4\u540E `git add artifacts/traceability-version-lock.json` \u5E76\u91CD\u65B0\u63D0\u4EA4\u3002"
+      ];
+    case "missing_lock":
+      return [
+        "\u65B0\u589E\u8FFD\u6EAF\u8FB9\u8FD8\u6CA1\u6709\u5BF9\u5E94\u7248\u672C\u9501\uFF1B\u9ED8\u8BA4\u4E0D\u963B\u65AD\uFF0C`--strict-missing-lock` \u4E0B\u4F1A\u963B\u65AD\u3002",
+        "\u8FD0\u884C `artifact-graph version-lock refresh --changed-only --worktree --format markdown` \u4E3A\u53D7\u5F71\u54CD\u8FB9\u8865\u9501\uFF1B\u9996\u6B21\u5EFA\u7ACB\u57FA\u7EBF\u6216\u914D\u7F6E\u53D8\u66F4\u65F6\u7528 `artifact-graph version-lock refresh --all --format markdown`\u3002",
+        "\u8FD0\u884C `git diff artifacts/traceability-version-lock.json` \u5BA1\u67E5\u540E `git add artifacts/traceability-version-lock.json` \u6682\u5B58\u3002"
+      ];
+    case "orphan_lock":
+      if (isLivenessIssue(issue2)) {
+        return [
+          "\u8FD9\u662F liveness \u8B66\u544A\uFF0C\u4E0D\u662F\u6821\u9A8C\u5931\u8D25\uFF1A\u9501\u4ECD\u7136\u4FDD\u7559\uFF0C\u9ED8\u8BA4\u4E0D\u963B\u65AD\u3002",
+          "\u5982\u679C\u6D4B\u8BD5\u5DF2\u5E9F\u5F03\uFF1A\u5220\u9664\u8BE5\u6587\u4EF6\u6216\u79FB\u9664\u5176\u4E2D\u7684\u8FFD\u6EAF\u6CE8\u91CA\uFF0C\u7136\u540E\u8FD0\u884C `artifact-graph version-lock refresh --all --remove-orphans --format markdown` \u6E05\u7406\u5BF9\u5E94\u7684\u9501\u3002",
+          "\u5982\u679C\u6D4B\u8BD5\u4ECD\u7136\u6709\u6548\uFF1A\u628A\u5B83\u52A0\u5165 artifact-graph.config.yaml \u4E2D\u67D0\u4E2A e2e runner \u7684 include\uFF0C\u6216\u68C0\u67E5 exclude/testIgnore \u662F\u5426\u8BEF\u4F24\u3002"
+        ];
+      }
+      return [
+        "\u9501\u5F15\u7528\u7684\u5236\u54C1\u3001\u6E90\u7801\u6216\u8FFD\u6EAF\u8FB9\u5728\u5F53\u524D\u56FE\u4E2D\u5DF2\u4E0D\u5B58\u5728\uFF0C\u5E38\u89C1\u4E8E\u5236\u54C1\u5220\u9664\u6216\u62C6\u5206\u4E4B\u540E\u3002",
+        "\u786E\u8BA4\u5220\u9664\u662F\u6709\u610F\u7684\u540E\uFF0C\u8FD0\u884C `artifact-graph version-lock refresh --all --remove-orphans --format markdown` \u6E05\u7406\u5B64\u7ACB\u9501\u3002",
+        "\u8FD0\u884C `git diff artifacts/traceability-version-lock.json` \u5BA1\u67E5\u88AB\u79FB\u9664\u7684\u9501\u6761\u76EE\uFF0C\u786E\u8BA4\u540E `git add artifacts/traceability-version-lock.json` \u6682\u5B58\u3002",
+        "\u5982\u679C\u5220\u9664\u662F\u8BEF\u64CD\u4F5C\uFF0C\u5148\u6062\u590D\u5BF9\u5E94\u5236\u54C1\u6216\u6E90\u7801\u6587\u4EF6\uFF0C\u518D\u8FD0\u884C\u4E0D\u5E26 `--remove-orphans` \u7684 refresh \u5237\u65B0\u54C8\u5E0C\u3002"
+      ];
+    case "target_not_found":
+      return [
+        "\u68C0\u67E5 `--target` \u7684 `type:id` \u662F\u5426\u62FC\u5199\u6B63\u786E\u3002",
+        "\u5982\u679C\u8BE5\u5236\u54C1\u5DF2\u88AB\u5220\u9664\u6216\u6539\u540D\uFF0C\u6539\u7528\u5F53\u524D\u5B58\u5728\u7684\u5236\u54C1\u6807\u8BC6\u91CD\u8BD5\u3002"
+      ];
+    default:
+      return [];
+  }
+}
+function enrichVersionLockIssue(issue2) {
+  return {
+    ...issue2,
+    severity: versionLockIssueSeverity(issue2),
+    remediation: issue2.remediation ?? versionLockIssueRemediation(issue2)
   };
 }
 async function updateVersionLock(root, options) {
@@ -1990,59 +2103,118 @@ async function traceVersion(root, target, lockPath = VERSION_LOCK_PATH) {
     currentEdges: index.edges.filter((edge2) => edge2.from === targetUid || edge2.to === targetUid),
     locks: lock.locks.filter((entry) => `${entry.artifact.type}:${entry.artifact.id}` === targetUid),
     artifactRelations: targetArtifactRelations,
-    issues: [...targetIssues, ...audit.issues.filter((issue2) => `${issue2.artifact?.type}:${issue2.artifact?.id}` === targetUid || issue2.edgeId.includes(`#${targetUid}`))]
+    issues: [...targetIssues.map(enrichVersionLockIssue), ...audit.issues.filter((issue2) => `${issue2.artifact?.type}:${issue2.artifact?.id}` === targetUid || issue2.edgeId.includes(`#${targetUid}`))]
   };
 }
-function renderVersionLockAuditMarkdown(result) {
+function renderIssueBlockingTag(issue2, strictMissingLock) {
+  return isVersionLockIssueBlocking(issue2, strictMissingLock) ? "\u963B\u65AD" : "\u8B66\u544A";
+}
+function renderIssueBlockingExplanation(issue2, strictMissingLock) {
+  if (!isVersionLockIssueBlocking(issue2, strictMissingLock)) {
+    return "\u5426\uFF08\u4EC5\u63D0\u9192\uFF0C\u4E0D\u963B\u65AD\uFF09";
+  }
+  if (issue2.status === "missing_lock" && versionLockIssueSeverity(issue2) !== "error") {
+    return "\u662F\uFF08\u5DF2\u7531 --strict-missing-lock \u5347\u7EA7\u4E3A\u963B\u65AD\uFF09";
+  }
+  return "\u662F\uFF08\u4F1A\u4F7F\u547D\u4EE4\u4EE5\u975E\u96F6\u9000\u51FA\u7801\u7ED3\u675F\uFF09";
+}
+function appendIssueDetails(lines, issues, strictMissingLock) {
+  issues.forEach((issue2, index) => {
+    const label = VERSION_LOCK_STATUS_LABELS[issue2.status] ?? issue2.status;
+    lines.push(`### ${index + 1}. [${renderIssueBlockingTag(issue2, strictMissingLock)}] ${label}\uFF08\`${issue2.status}\`\uFF09`);
+    lines.push("");
+    lines.push(`- \u8FB9: \`${issue2.edgeId}\``);
+    lines.push(`- \u8BE6\u60C5: ${issue2.message}`);
+    lines.push(`- \u662F\u5426\u963B\u65AD: ${renderIssueBlockingExplanation(issue2, strictMissingLock)}`);
+    const remediation = issue2.remediation ?? [];
+    if (remediation.length > 0) {
+      lines.push("- \u89E3\u51B3\u6B65\u9AA4:");
+      remediation.forEach((step, stepIndex) => {
+        lines.push(`  ${stepIndex + 1}. ${step}`);
+      });
+    }
+    lines.push("");
+  });
+}
+function renderVersionLockAuditMarkdown(result, options = {}) {
+  const strictMissingLock = options.strictMissingLock === true;
+  const blockingCount = result.issues.filter((issue2) => isVersionLockIssueBlocking(issue2, strictMissingLock)).length;
+  const nonBlockingCount = result.issues.length - blockingCount;
   const lines = [
-    "# Version Lock Audit",
+    "# \u7248\u672C\u9501\u5BA1\u8BA1\uFF08version-lock audit\uFF09",
     "",
-    `Root: \`${result.root}\``,
-    `Lock: \`${result.lockPath}\``,
-    `Locks: ${result.totalLocks} | Fresh: ${result.fresh} | Issues: ${result.issues.length}`,
-    `Artifact Relations: ${result.totalArtifactRelationLocks} | Fresh: ${result.artifactRelationFresh}`,
+    `- \u6839\u76EE\u5F55: \`${result.root}\``,
+    `- \u9501\u6587\u4EF6: \`${result.lockPath}\``,
+    `- \u5B9E\u73B0/\u9A8C\u8BC1\u9501: ${result.totalLocks}\uFF08\u65B0\u9C9C ${result.fresh}\uFF09`,
+    `- \u5236\u54C1\u5173\u7CFB\u9501: ${result.totalArtifactRelationLocks}\uFF08\u65B0\u9C9C ${result.artifactRelationFresh}\uFF09`,
+    `- \u963B\u65AD\u7B56\u7565: ${strictMissingLock ? "--strict-missing-lock\uFF08missing_lock \u5347\u7EA7\u4E3A\u963B\u65AD\uFF09" : "\u9ED8\u8BA4\uFF08missing_lock \u4E0D\u963B\u65AD\uFF09"}`,
+    `- \u95EE\u9898: ${result.issues.length}\uFF08\u963B\u65AD ${blockingCount}\uFF0C\u4E0D\u963B\u65AD ${nonBlockingCount}\uFF09`,
     ""
   ];
   if (result.issues.length === 0) {
-    lines.push("No version lock issues.");
+    lines.push("\u672A\u53D1\u73B0\u7248\u672C\u9501\u95EE\u9898\u3002");
     return `${lines.join("\n")}
 `;
   }
-  for (const issue2 of result.issues) {
-    lines.push(`- [${issue2.status}] \`${issue2.edgeId}\` \u2014 ${issue2.message}`);
+  if (blockingCount > 0) {
+    lines.push(`\u5F53\u524D\u7B56\u7565\u4E0B\u5B58\u5728 ${blockingCount} \u4E2A\u963B\u65AD\u95EE\u9898\uFF0C\u547D\u4EE4\u5C06\u4EE5\u975E\u96F6\u9000\u51FA\u7801\u7ED3\u675F\uFF1B\u8BF7\u6309\u4E0B\u65B9\u6B65\u9AA4\u9010\u9879\u5904\u7406\u3002`);
+  } else {
+    lines.push("\u5F53\u524D\u7B56\u7565\u4E0B\u6CA1\u6709\u963B\u65AD\u95EE\u9898\uFF0C\u4EE5\u4E0B\u4EC5\u4E3A\u63D0\u9192\uFF0C\u547D\u4EE4\u4EE5\u96F6\u9000\u51FA\u7801\u7ED3\u675F\u3002");
   }
+  lines.push("");
+  lines.push("## \u95EE\u9898\u6E05\u5355");
+  lines.push("");
+  appendIssueDetails(lines, result.issues, strictMissingLock);
   return `${lines.join("\n")}
 `;
 }
 function renderVersionLockRefreshMarkdown(result) {
+  const strictMissingLock = true;
+  const blockingCount = result.postAudit.issues.filter((issue2) => isVersionLockIssueBlocking(issue2, strictMissingLock)).length;
+  const nonBlockingCount = result.postAudit.issues.length - blockingCount;
   const lines = [
-    "# Version Lock Refresh",
+    "# \u7248\u672C\u9501\u5237\u65B0\uFF08version-lock refresh\uFF09",
+    "",
+    `- \u6839\u76EE\u5F55: \`${result.root}\``,
+    `- \u9501\u6587\u4EF6: \`${result.lockPath}\``,
+    `- \u6A21\u5F0F: \`${result.mode}\`\uFF08\u53D8\u66F4\u8DEF\u5F84 ${result.changedPaths.length} \u4E2A\uFF0C\u53D7\u5F71\u54CD\u8FB9 ${result.affectedEdges.length} \u6761\uFF09`,
+    `- \u5B9E\u73B0/\u9A8C\u8BC1\u9501: \u65B0\u589E ${result.addedLocks.length} | \u66F4\u65B0 ${result.updatedLocks.length} | \u4FDD\u7559\u5B64\u7ACB ${result.retainedOrphans.length} | \u5220\u9664\u5B64\u7ACB ${result.removedOrphans.length}`,
+    `- \u5236\u54C1\u5173\u7CFB\u9501: \u65B0\u589E ${result.addedArtifactRelationLocks.length} | \u66F4\u65B0 ${result.updatedArtifactRelationLocks.length} | \u4FDD\u7559\u5B64\u7ACB ${result.retainedArtifactRelationOrphans.length} | \u5220\u9664 ${result.removedArtifactRelationLocks.length}`,
+    `- \u963B\u65AD\u7B56\u7565: refresh \u56FA\u5B9A\u6309 --strict-missing-lock \u5224\u5B9A\uFF0Cmissing_lock \u4E5F\u4F1A\u963B\u65AD`,
+    `- \u5237\u65B0\u540E\u5BA1\u8BA1\u95EE\u9898: ${result.postAudit.issues.length}\uFF08\u963B\u65AD ${blockingCount}\uFF0C\u4E0D\u963B\u65AD ${nonBlockingCount}\uFF09`,
+    "",
+    "\u9501\u6587\u4EF6\u5DF2\u5199\u5165\u3002\u82E5\u9501\u6587\u4EF6\u76F8\u5BF9\u6682\u5B58\u533A\u6709\u53D8\u5316\uFF08\u4F8B\u5982 pre-commit \u573A\u666F\uFF09\uFF0C\u8BF7\u5148\u5BA1\u67E5\u5E76\u6682\u5B58\uFF1A",
     "",
-    `Root: \`${result.root}\``,
-    `Lock: \`${result.lockPath}\``,
-    `Mode: \`${result.mode}\``,
-    `Changed paths: ${result.changedPaths.length}`,
-    `Affected edges: ${result.affectedEdges.length}`,
-    `Added: ${result.addedLocks.length} | Updated: ${result.updatedLocks.length} | Retained orphans: ${result.retainedOrphans.length} | Removed orphans: ${result.removedOrphans.length}`,
-    `Artifact Relations \u2014 Added: ${result.addedArtifactRelationLocks.length} | Updated: ${result.updatedArtifactRelationLocks.length} | Retained orphans: ${result.retainedArtifactRelationOrphans.length} | Removed: ${result.removedArtifactRelationLocks.length}`,
-    `Post-audit issues: ${result.postAudit.issues.length}`,
+    "1. `git diff artifacts/traceability-version-lock.json`",
+    "2. `git add artifacts/traceability-version-lock.json`",
+    "3. \u91CD\u65B0\u6267\u884C `git commit`",
     ""
   ];
-  appendList(lines, "Added Locks", result.addedLocks);
-  appendList(lines, "Updated Locks", result.updatedLocks);
-  appendList(lines, "Retained Orphans", result.retainedOrphans);
-  appendList(lines, "Removed Orphans", result.removedOrphans);
-  appendList(lines, "Added Artifact Relation Locks", result.addedArtifactRelationLocks);
-  appendList(lines, "Updated Artifact Relation Locks", result.updatedArtifactRelationLocks);
-  appendList(lines, "Retained Artifact Relation Orphans", result.retainedArtifactRelationOrphans);
-  appendList(lines, "Removed Artifact Relation Locks", result.removedArtifactRelationLocks);
-  appendList(lines, "Warnings", result.warnings);
+  appendList(lines, "\u65B0\u589E\u7684\u9501", result.addedLocks);
+  appendList(lines, "\u66F4\u65B0\u7684\u9501", result.updatedLocks);
+  appendList(lines, "\u4FDD\u7559\u7684\u5B64\u7ACB\u9501", result.retainedOrphans);
+  if (result.retainedOrphans.length > 0) {
+    lines.push("> \u4EE5\u4E0A\u662F\u5DF2\u5220\u9664/\u62C6\u5206\u5236\u54C1\u6216\u5931\u6548\u8FFD\u6EAF\u8FB9\u9057\u7559\u7684\u9501\u3002\u786E\u8BA4\u4E0D\u518D\u9700\u8981\u540E\u8FD0\u884C `artifact-graph version-lock refresh --all --remove-orphans --format markdown` \u6E05\u7406\uFF0C\u5BA1\u67E5 `git diff artifacts/traceability-version-lock.json` \u540E\u518D\u6682\u5B58\u3002");
+    lines.push("");
+  }
+  appendList(lines, "\u5220\u9664\u7684\u5B64\u7ACB\u9501", result.removedOrphans);
+  appendList(lines, "\u65B0\u589E\u7684\u5236\u54C1\u5173\u7CFB\u9501", result.addedArtifactRelationLocks);
+  appendList(lines, "\u66F4\u65B0\u7684\u5236\u54C1\u5173\u7CFB\u9501", result.updatedArtifactRelationLocks);
+  appendList(lines, "\u4FDD\u7559\u7684\u5B64\u7ACB\u5236\u54C1\u5173\u7CFB\u9501", result.retainedArtifactRelationOrphans);
+  if (result.retainedArtifactRelationOrphans.length > 0) {
+    lines.push("> \u4EE5\u4E0A\u662F\u5931\u6548\u5236\u54C1\u5173\u7CFB\u9057\u7559\u7684\u9501\u3002\u786E\u8BA4\u540E\u8FD0\u884C `artifact-graph version-lock refresh --all --remove-orphans --format markdown` \u6E05\u7406\uFF0C\u5BA1\u67E5\u9501 diff \u540E\u518D\u6682\u5B58\u3002");
+    lines.push("");
+  }
+  appendList(lines, "\u5220\u9664\u7684\u5236\u54C1\u5173\u7CFB\u9501", result.removedArtifactRelationLocks);
+  appendList(lines, "\u63D0\u9192", result.warnings);
   if (result.postAudit.issues.length > 0) {
-    lines.push("## Post-Audit Issues");
-    for (const issue2 of result.postAudit.issues) {
-      lines.push(`- [${issue2.status}] \`${issue2.edgeId}\` \u2014 ${issue2.message}`);
+    if (blockingCount > 0) {
+      lines.push(`## \u5237\u65B0\u540E\u5BA1\u8BA1\u95EE\u9898\uFF08\u963B\u65AD ${blockingCount}\uFF0C\u4E0D\u963B\u65AD ${nonBlockingCount}\uFF09`);
+    } else {
+      lines.push(`## \u5237\u65B0\u540E\u5BA1\u8BA1\u95EE\u9898\uFF08\u5F53\u524D\u7B56\u7565\u4E0B\u5168\u90E8\u4E0D\u963B\u65AD\uFF09`);
     }
     lines.push("");
+    appendIssueDetails(lines, result.postAudit.issues, strictMissingLock);
   }
   return `${lines.join("\n")}
 `;
@@ -2089,7 +2261,7 @@ function renderTraceVersionMarkdown(result) {
 async function readVersionLock(root, lockPath) {
   const safeLockPath = normalizeRelativePath(root, lockPath);
   try {
-    const raw = await (0, import_promises2.readFile)((0, import_node_path2.join)(root, safeLockPath), "utf-8");
+    const raw = await (0, import_promises3.readFile)((0, import_node_path3.join)(root, safeLockPath), "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -2248,9 +2420,9 @@ function requireSafeRelativePath(value, path) {
 }
 async function writeVersionLock(root, lockPath, lock) {
   const safeLockPath = normalizeRelativePath(root, lockPath);
-  const fullPath = (0, import_node_path2.join)(root, safeLockPath);
-  await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(fullPath), { recursive: true });
-  await (0, import_promises2.writeFile)(fullPath, `${JSON.stringify(lock, null, 2)}
+  const fullPath = (0, import_node_path3.join)(root, safeLockPath);
+  await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(fullPath), { recursive: true });
+  await (0, import_promises3.writeFile)(fullPath, `${JSON.stringify(lock, null, 2)}
 `);
 }
 function implementationEdges(index) {
@@ -2431,14 +2603,14 @@ async function hashRelativePath(root, path, cache) {
   const normalized = normalizeRelativePath(root, path);
   const cached = cache.get(normalized);
   if (cached) return cached;
-  const content = await (0, import_promises2.readFile)((0, import_node_path2.join)(root, normalized));
+  const content = await (0, import_promises3.readFile)((0, import_node_path3.join)(root, normalized));
   const hash = `sha256:${(0, import_node_crypto.createHash)("sha256").update(content).digest("hex")}`;
   cache.set(normalized, hash);
   return hash;
 }
 function normalizeRelativePath(root, path) {
   const normalized = path.replace(/\\/g, "/");
-  const relativePath = normalized.startsWith("/") ? (0, import_node_path2.relative)(root, normalized).replace(/\\/g, "/") : normalized.replace(/^\.\//, "");
+  const relativePath = normalized.startsWith("/") ? (0, import_node_path3.relative)(root, normalized).replace(/\\/g, "/") : normalized.replace(/^\.\//, "");
   if (relativePath === ".." || relativePath.startsWith("../")) {
     throw new Error(`Path is outside root: ${path}`);
   }
@@ -2454,10 +2626,10 @@ async function getTestFileRunnerLiveness(root, filePath, config) {
     if (!/e2e/i.test(filePath) && !/\.e2e\./i.test(filePath)) {
       return "active";
     }
-    const fullSourcePath = (0, import_node_path2.join)(root, filePath);
+    const fullSourcePath = (0, import_node_path3.join)(root, filePath);
     if (!(0, import_node_fs.existsSync)(fullSourcePath)) return "inactive";
     try {
-      const content = await (0, import_promises2.readFile)(fullSourcePath, "utf-8");
+      const content = await (0, import_promises3.readFile)(fullSourcePath, "utf-8");
       return /\/\/!?\s*@(?:e2e_test|tc)\s+/.test(content) ? "active" : "inactive";
     } catch {
       return "inactive";
@@ -2497,19 +2669,29 @@ async function isFileActiveInRunner(root, filePath, runner) {
 function sortUnique(items) {
   return [...new Set(items)].sort((left, right) => left.localeCompare(right));
 }
-var import_node_crypto, import_node_fs, import_promises2, import_node_path2, VERSION_LOCK_PATH, VERSION_INDEX_SCHEMA_VERSION, VERSION_LOCK_SCHEMA_VERSION;
+var import_node_crypto, import_node_fs, import_promises3, import_node_path3, VERSION_LOCK_PATH, VERSION_INDEX_SCHEMA_VERSION, VERSION_LOCK_SCHEMA_VERSION, LIVENESS_MESSAGE_PREFIX, VERSION_LOCK_STATUS_LABELS;
 var init_versioned_traceability = __esm({
   "src/versioned-traceability.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
     import_node_fs = require("fs");
-    import_promises2 = require("fs/promises");
-    import_node_path2 = require("path");
+    import_promises3 = require("fs/promises");
+    import_node_path3 = require("path");
     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";
+    LIVENESS_MESSAGE_PREFIX = "Liveness:";
+    VERSION_LOCK_STATUS_LABELS = {
+      fresh: "\u65B0\u9C9C",
+      target_not_found: "\u76EE\u6807\u5236\u54C1\u4E0D\u5B58\u5728",
+      artifact_changed: "\u5236\u54C1\u5DF2\u53D8\u5316",
+      source_changed: "\u6E90\u7801/\u6D4B\u8BD5\u5DF2\u53D8\u5316",
+      verified_by_changed: "\u9A8C\u8BC1\u6587\u4EF6\u5DF2\u53D8\u5316",
+      missing_lock: "\u7F3A\u5C11\u7248\u672C\u9501",
+      orphan_lock: "\u5B64\u7ACB\u9501"
+    };
   }
 });
 
@@ -2520,7 +2702,7 @@ async function resolveArtifactGraphCli(root, options = {}) {
   const candidates = [
     {
       source: "node_modules",
-      path: (0, import_node_path3.join)(root, "node_modules/.bin/artifact-graph"),
+      path: (0, import_node_path4.join)(root, "node_modules/.bin/artifact-graph"),
       exists: false
     },
     {
@@ -2553,8 +2735,8 @@ async function resolveArtifactGraphCli(root, options = {}) {
 }
 async function doctorArtifactChain(root, options = {}) {
   const cli = await resolveArtifactGraphCli(root, options);
-  const configPath = (0, import_node_path3.join)(root, "artifact-graph.config.yaml");
-  const lockPath = (0, import_node_path3.join)(root, VERSION_LOCK_PATH);
+  const configPath = (0, import_node_path4.join)(root, "artifact-graph.config.yaml");
+  const lockPath = (0, import_node_path4.join)(root, VERSION_LOCK_PATH);
   const supportedCommands = cli.path ? await detectSupportedCommands(cli.path) : [];
   const nodeCompatible = isNodeCompatible(process.versions.node);
   const warnings = [
@@ -2627,7 +2809,7 @@ ${maybe.stderr ?? ""}`;
 }
 async function pathExists(path) {
   try {
-    await (0, import_promises3.access)(path, import_node_fs2.constants.R_OK);
+    await (0, import_promises4.access)(path, import_node_fs2.constants.R_OK);
     return true;
   } catch {
     return false;
@@ -2643,20 +2825,20 @@ async function findCommandOnPath(command) {
   }
 }
 function resolveCandidatePath(root, candidatePath) {
-  return (0, import_node_path3.isAbsolute)(candidatePath) ? candidatePath : (0, import_node_path3.resolve)(root, candidatePath);
+  return (0, import_node_path4.isAbsolute)(candidatePath) ? candidatePath : (0, import_node_path4.resolve)(root, candidatePath);
 }
 function isNodeCompatible(version) {
   const major = Number(version.split(".")[0]);
   return Number.isFinite(major) && major >= 22;
 }
-var import_node_child_process, import_node_fs2, import_promises3, import_node_path3, import_node_util, execFileAsync, KNOWN_COMMANDS;
+var import_node_child_process, import_node_fs2, import_promises4, import_node_path4, import_node_util, execFileAsync, KNOWN_COMMANDS;
 var init_cli_resolver = __esm({
   "src/cli-resolver.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
     import_node_fs2 = require("fs");
-    import_promises3 = require("fs/promises");
-    import_node_path3 = require("path");
+    import_promises4 = require("fs/promises");
+    import_node_path4 = require("path");
     import_node_util = require("util");
     init_versioned_traceability();
     execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
@@ -2767,14 +2949,14 @@ async function resolveGitHookPath(root, hookName) {
   ]);
   const value = stdout.trim();
   if (!value) throw new Error(`Git returned an empty hook path for ${hookName}`);
-  return (0, import_node_path4.isAbsolute)(value) ? (0, import_node_path4.resolve)(value) : (0, import_node_path4.resolve)(root, value);
+  return (0, import_node_path5.isAbsolute)(value) ? (0, import_node_path5.resolve)(value) : (0, import_node_path5.resolve)(root, value);
 }
-var import_node_child_process3, import_node_path4, import_node_util3, execFileAsync3;
+var import_node_child_process3, import_node_path5, import_node_util3, execFileAsync3;
 var init_git_hook_path = __esm({
   "src/git-hook-path.ts"() {
     "use strict";
     import_node_child_process3 = require("child_process");
-    import_node_path4 = require("path");
+    import_node_path5 = require("path");
     import_node_util3 = require("util");
     execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
   }
@@ -2997,7 +3179,7 @@ async function readHookSnapshot(hookPath) {
   for (let attempt = 0; attempt < 3; attempt += 1) {
     let metadata;
     try {
-      metadata = await (0, import_promises4.lstat)(hookPath, { bigint: true });
+      metadata = await (0, import_promises5.lstat)(hookPath, { bigint: true });
     } catch (error) {
       if (error.code === "ENOENT") {
         return { kind: "missing", bytes: Buffer.alloc(0) };
@@ -3013,7 +3195,7 @@ async function readHookSnapshot(hookPath) {
         size: metadata.size,
         mtimeNs: metadata.mtimeNs,
         mode: metadata.mode,
-        linkTarget: await (0, import_promises4.readlink)(hookPath)
+        linkTarget: await (0, import_promises5.readlink)(hookPath)
       };
     }
     if (!metadata.isFile()) {
@@ -3029,7 +3211,7 @@ async function readHookSnapshot(hookPath) {
     }
     let handle;
     try {
-      handle = await (0, import_promises4.open)(hookPath, import_node_fs3.constants.O_RDONLY | (import_node_fs3.constants.O_NOFOLLOW ?? 0));
+      handle = await (0, import_promises5.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();
@@ -3087,15 +3269,15 @@ async function removeHookAtomically(hookPath, snapshot) {
     throw new ConcurrentHookModificationError(hookPath);
   }
   if (current.kind !== "missing") {
-    await (0, import_promises4.unlink)(hookPath);
+    await (0, import_promises5.unlink)(hookPath);
   }
 }
 async function writeHookAtomically(hookPath, content, snapshot, mode) {
-  await (0, import_promises4.mkdir)((0, import_node_path5.dirname)(hookPath), { recursive: true });
-  const temporaryPath = (0, import_node_path5.join)((0, import_node_path5.dirname)(hookPath), `.${(0, import_node_path5.basename)(hookPath)}.${(0, import_node_crypto2.randomUUID)()}.tmp`);
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(hookPath), { recursive: true });
+  const temporaryPath = (0, import_node_path6.join)((0, import_node_path6.dirname)(hookPath), `.${(0, import_node_path6.basename)(hookPath)}.${(0, import_node_crypto2.randomUUID)()}.tmp`);
   let temporaryExists = false;
   try {
-    const temporary = await (0, import_promises4.open)(temporaryPath, "wx", mode);
+    const temporary = await (0, import_promises5.open)(temporaryPath, "wx", mode);
     temporaryExists = true;
     try {
       await temporary.writeFile(content);
@@ -3108,11 +3290,11 @@ async function writeHookAtomically(hookPath, content, snapshot, mode) {
     if (!sameHookSnapshot(snapshot, current)) {
       throw new ConcurrentHookModificationError(hookPath);
     }
-    await (0, import_promises4.rename)(temporaryPath, hookPath);
+    await (0, import_promises5.rename)(temporaryPath, hookPath);
     temporaryExists = false;
   } finally {
     if (temporaryExists) {
-      await (0, import_promises4.unlink)(temporaryPath).catch((error) => {
+      await (0, import_promises5.unlink)(temporaryPath).catch((error) => {
         if (error.code !== "ENOENT") {
           throw error;
         }
@@ -3138,14 +3320,14 @@ function findManagedRange(content, begin, end) {
     end: endLine < 0 ? content.length : endLine + 1
   };
 }
-var import_node_fs3, import_node_crypto2, import_promises4, import_node_path5, DEFAULT_MARKER_ID, MANAGED_STATE_PREFIX, UnsupportedHookInterpreterError, SymlinkHookUnsupportedError, UnsupportedHookTypeError, InvalidManagedHookStateError, ConcurrentHookModificationError, HookTransactionRollbackError;
+var import_node_fs3, import_node_crypto2, import_promises5, import_node_path6, DEFAULT_MARKER_ID, MANAGED_STATE_PREFIX, UnsupportedHookInterpreterError, SymlinkHookUnsupportedError, UnsupportedHookTypeError, InvalidManagedHookStateError, ConcurrentHookModificationError, HookTransactionRollbackError;
 var init_hook_installer = __esm({
   "src/hook-installer.ts"() {
     "use strict";
     import_node_fs3 = require("fs");
     import_node_crypto2 = require("crypto");
-    import_promises4 = require("fs/promises");
-    import_node_path5 = require("path");
+    import_promises5 = require("fs/promises");
+    import_node_path6 = require("path");
     DEFAULT_MARKER_ID = "artifact-chain-assistant";
     MANAGED_STATE_PREFIX = "# artifact-chain-assistant managed state v1:";
     UnsupportedHookInterpreterError = class extends Error {
@@ -3812,7 +3994,7 @@ function validatePolicyCompatibility(policy, baseContract) {
   };
 }
 async function loadContract(contractPath, options) {
-  const rawContent = await (0, import_promises5.readFile)(contractPath, "utf-8");
+  const rawContent = await (0, import_promises6.readFile)(contractPath, "utf-8");
   let schema;
   try {
     schema = JSON.parse(rawContent);
@@ -3860,10 +4042,10 @@ async function loadContract(contractPath, options) {
 }
 async function loadContractsFromDirectory(contractsDir, options) {
   const contracts = [];
-  const entries = await (0, import_promises5.readdir)(contractsDir, { withFileTypes: true });
+  const entries = await (0, import_promises6.readdir)(contractsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const schemaPath = (0, import_node_path6.join)(contractsDir, entry.name, "schema.json");
+      const schemaPath = (0, import_node_path7.join)(contractsDir, entry.name, "schema.json");
       const contract = await loadContract(schemaPath, options);
       contracts.push(contract);
     }
@@ -3978,13 +4160,13 @@ async function loadContractCatalog(contractsDir, options) {
   }
   return catalog;
 }
-var import_node_crypto3, import_promises5, import_node_path6, import_ajv, CONTRACT_ERROR_CODES, ContractError, OFFICIAL_AUTHORITY, OFFICIAL_NAMESPACE_PATTERN, ContractRegistry, _validatorCache, E2E_NORMALIZER_CONFIG, ContractCatalog;
+var import_node_crypto3, import_promises6, import_node_path7, import_ajv, 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";
     import_node_crypto3 = require("crypto");
-    import_promises5 = require("fs/promises");
-    import_node_path6 = require("path");
+    import_promises6 = require("fs/promises");
+    import_node_path7 = require("path");
     import_ajv = __toESM(require("ajv"), 1);
     CONTRACT_ERROR_CODES = {
       /** Contract identity not found */
@@ -4337,11 +4519,11 @@ __export(index_exports, {
   collectChangedPaths: () => collectChangedPaths,
   computeE2eCoverageStats: () => computeE2eCoverageStats,
   computeRevisionDigest: () => computeRevisionDigest,
-  dirname: () => import_node_path7.dirname,
+  dirname: () => import_node_path8.dirname,
   discoverAndAuditPackets: () => discoverAndAuditPackets,
   discoverTargets: () => discoverTargets,
   doctorArtifactChain: () => doctorArtifactChain,
-  extname: () => import_node_path7.extname,
+  extname: () => import_node_path8.extname,
   formatContextMarkdown: () => formatContextMarkdown,
   generateE2eRegistry: () => generateE2eRegistry,
   getArtifactTypeMetadata: () => getArtifactTypeMetadata,
@@ -4351,10 +4533,12 @@ __export(index_exports, {
   isPacketTargetType: () => isPacketTargetType,
   isPacketTargetTypeDynamic: () => isPacketTargetTypeDynamic,
   isTargetArtifactType: () => isTargetArtifactType,
+  isVersionLockIssueBlocking: () => isVersionLockIssueBlocking,
   loadConfig: () => loadConfig,
   loadContract: () => loadContract,
   loadContractCatalog: () => loadContractCatalog,
   loadContractsFromDirectory: () => loadContractsFromDirectory,
+  matchesConfiguredArtifactPath: () => matchesConfiguredArtifactPath,
   nextId: () => nextId,
   normalizeE2eLegacyArtifact: () => normalizeE2eLegacyArtifact,
   normalizeToCanonical: () => normalizeToCanonical,
@@ -4391,6 +4575,7 @@ __export(index_exports, {
   validateScenarioPrdLinkIndex: () => validateScenarioPrdLinkIndex,
   validateScenarioPrdLinks: () => validateScenarioPrdLinks,
   verifyDigest: () => verifyDigest,
+  versionLockIssueSeverity: () => versionLockIssueSeverity,
   writeGraphCache: () => writeGraphCache
 });
 module.exports = __toCommonJS(index_exports);
@@ -4435,10 +4620,10 @@ function resolveArtifactTypeName(schema, token) {
   return void 0;
 }
 async function loadConfig(root) {
-  const configPath = (0, import_node_path7.join)(root, "artifact-graph.config.yaml");
+  const configPath = (0, import_node_path8.join)(root, "artifact-graph.config.yaml");
   let parsed = {};
   try {
-    const raw = await (0, import_promises6.readFile)(configPath, "utf-8");
+    const raw = await (0, import_promises7.readFile)(configPath, "utf-8");
     parsed = import_js_yaml.default.load(raw) ?? {};
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -4528,7 +4713,7 @@ function validateE2eConfig(e2e) {
       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_path7.isAbsolute)(runner.root)) {
+      if ((0, import_node_path8.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("..")) {
@@ -4612,14 +4797,14 @@ async function scanArtifacts(root, schema) {
         continue;
       }
       scannedFiles.set(file, type);
-      const raw = await (0, import_promises6.readFile)((0, import_node_path7.join)(root, file), "utf-8");
+      const raw = await (0, import_promises7.readFile)((0, import_node_path8.join)(root, file), "utf-8");
       const parsed = parseFile(type, file, raw, config);
       nodes.push(...parsed.nodes);
       edges.push(...parsed.edges);
       scanDiagnostics.push(...parsed.diagnostics);
     }
   }
-  const absoluteRoot = (0, import_node_path7.isAbsolute)(root) ? root : (0, import_node_path7.resolve)(root);
+  const absoluteRoot = (0, import_node_path8.isAbsolute)(root) ? root : (0, import_node_path8.resolve)(root);
   const graph = buildGraph(nodes, edges, scanDiagnostics, absoluteRoot);
   return resolveMatrixEdges(graph);
 }
@@ -4924,7 +5109,7 @@ async function validateScenarioPrdLinkIndex(root, graph) {
   const indexPath = "artifacts/prd/feature-index.md";
   let raw = "";
   try {
-    raw = await (0, import_promises6.readFile)((0, import_node_path7.join)(root, indexPath), "utf-8");
+    raw = await (0, import_promises7.readFile)((0, import_node_path8.join)(root, indexPath), "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -5114,11 +5299,11 @@ function nextId(graph, schema, type, rangeName) {
   throw new Error(`ID range ${type}.${rangeName} is exhausted`);
 }
 async function writeGraphCache(root, graph) {
-  const cacheDir = (0, import_node_path7.join)(root, ".artifact-graph");
-  await (0, import_promises6.mkdir)(cacheDir, { recursive: true });
-  await (0, import_promises6.writeFile)((0, import_node_path7.join)(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
+  const cacheDir = (0, import_node_path8.join)(root, ".artifact-graph");
+  await (0, import_promises7.mkdir)(cacheDir, { recursive: true });
+  await (0, import_promises7.writeFile)((0, import_node_path8.join)(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
 `);
-  const db = new import_better_sqlite3.default((0, import_node_path7.join)(cacheDir, "graph.sqlite"));
+  const db = new import_better_sqlite3.default((0, import_node_path8.join)(cacheDir, "graph.sqlite"));
   try {
     db.exec(`
       DROP TABLE IF EXISTS nodes;
@@ -5229,7 +5414,7 @@ function parseFile(type, path, raw, schema = DEFAULT_SCHEMA) {
 }
 function parseGenericMarkdown(type, path, raw, schema) {
   const diagnostics = [];
-  const ext = (0, import_node_path7.extname)(path).toLowerCase();
+  const ext = (0, import_node_path8.extname)(path).toLowerCase();
   if (ext !== ".md" && ext !== ".markdown") {
     diagnostics.push(issue(
       "UNSUPPORTED_FORMAT",
@@ -5456,7 +5641,7 @@ function parseDecisions(path, raw) {
 }
 function isTestFile(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const name = (0, import_node_path7.basename)(normalized);
+  const name = (0, import_node_path8.basename)(normalized);
   if (/\.(test|spec)\.[^.]+$/.test(name)) return true;
   if (/(^|\/)(tests|test|__tests__)\//.test(normalized)) return true;
   if (/\w+Tests?\.java$/.test(name)) return true;
@@ -5747,7 +5932,7 @@ function parseE2eTest(path, raw) {
   });
   const nodes = [];
   const edges = [];
-  const batch = String(data.test_batch ?? (0, import_node_path7.basename)(path, (0, import_node_path7.extname)(path))).trim();
+  const batch = String(data.test_batch ?? (0, import_node_path8.basename)(path, (0, import_node_path8.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])];
@@ -5820,7 +6005,7 @@ function parseE2eRegistry(path, raw) {
     data = { parseError: error.message };
   }
   return {
-    nodes: [{ type: "e2e_registry", code: (0, import_node_path7.basename)(path, (0, import_node_path7.extname)(path)), title: "E2E Test Registry", path, line: 1, attrs: data }],
+    nodes: [{ type: "e2e_registry", code: (0, import_node_path8.basename)(path, (0, import_node_path8.extname)(path)), title: "E2E Test Registry", path, line: 1, attrs: data }],
     edges: []
   };
 }
@@ -6801,10 +6986,10 @@ function validateE2eRegistry(graph) {
 async function validateExecutableTraceability(root, config) {
   const issues = [];
   const schema = config ?? await loadConfig(root);
-  const e2eDir = (0, import_node_path7.join)(root, "artifacts", "tests", "e2e");
+  const e2eDir = (0, import_node_path8.join)(root, "artifacts", "tests", "e2e");
   let e2eFiles;
   try {
-    e2eFiles = (await (0, import_promises6.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path7.join)(e2eDir, name));
+    e2eFiles = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path8.join)(e2eDir, name));
   } catch {
     return [];
   }
@@ -6813,11 +6998,11 @@ async function validateExecutableTraceability(root, config) {
   const tcKeyToFields = /* @__PURE__ */ new Map();
   const mdBatches = /* @__PURE__ */ new Set();
   for (const filePath of e2eFiles) {
-    const raw = await (0, import_promises6.readFile)(filePath, "utf-8");
-    const relPath = (0, import_node_path7.relative)(root, filePath).split("\\").join("/");
+    const raw = await (0, import_promises7.readFile)(filePath, "utf-8");
+    const relPath = (0, import_node_path8.relative)(root, filePath).split("\\").join("/");
     const parsed = (0, import_gray_matter.default)(raw);
     const data = parsed.data;
-    const batch = String(data.test_batch ?? (0, import_node_path7.basename)(filePath, (0, import_node_path7.extname)(filePath))).trim();
+    const batch = String(data.test_batch ?? (0, import_node_path8.basename)(filePath, (0, import_node_path8.extname)(filePath))).trim();
     const lines = raw.split(/\r?\n/);
     const tcStarts = [];
     lines.forEach((line, index) => {
@@ -6842,7 +7027,7 @@ async function validateExecutableTraceability(root, config) {
       }
     }
   }
-  const allFiles = await walk(root);
+  const allFiles = await walkFiles(root);
   const specFiles = /* @__PURE__ */ new Set();
   const configuredRunners = schema.e2e?.runners ?? [];
   if (configuredRunners.length > 0) {
@@ -6862,23 +7047,25 @@ 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 = (0, import_node_path7.join)(root, specFile);
+    const fullSpecPath = (0, import_node_path8.join)(root, specFile);
     let content;
     try {
-      content = await (0, import_promises6.readFile)(fullSpecPath, "utf-8");
+      content = await (0, import_promises7.readFile)(fullSpecPath, "utf-8");
     } catch {
       continue;
     }
     const level = detectTestLevel(specFile, content);
     const specLines = content.split(/\r?\n/);
-    for (let lineIndex = 0; lineIndex < specLines.length; lineIndex += 1) {
-      const line = specLines[lineIndex];
-      let match = tcAnnotationRegex.exec(line);
+    const lineComments = scanCodeComments(content).filter((comment) => comment.kind === "line" && comment.standalone);
+    for (const comment of lineComments) {
+      const lineIndex = comment.lineNumber - 1;
+      const commentText = comment.text.replace(/^!/, "");
+      let match = tcAnnotationRegex.exec(`//${commentText}`);
       let annotatedLevel = "";
       if (match) {
         annotatedLevel = match[2];
       } else {
-        match = tcAnnotationNoLevelRegex.exec(line);
+        match = tcAnnotationNoLevelRegex.exec(`//${commentText}`);
       }
       if (!match) {
         continue;
@@ -6905,7 +7092,7 @@ async function validateExecutableTraceability(root, config) {
         level: effectiveLevel,
         file: specFile,
         testName,
-        line: lineIndex + 1
+        line: comment.lineNumber
       };
       const key = `${batch}:${tcId}`;
       const existing = refToSource.get(key) ?? [];
@@ -6942,7 +7129,7 @@ async function validateExecutableTraceability(root, config) {
       if (entry.testId) {
         let content;
         try {
-          content = await (0, import_promises6.readFile)((0, import_node_path7.join)(root, normalizedRefFile), "utf-8");
+          content = await (0, import_promises7.readFile)((0, import_node_path8.join)(root, normalizedRefFile), "utf-8");
         } catch {
           continue;
         }
@@ -7119,16 +7306,16 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   let withExecutableRef = 0;
   const statusBreakdown = {};
   const chainTypeBreakdown = {};
-  const e2eDir = (0, import_node_path7.join)(root, "artifacts", "tests", "e2e");
+  const e2eDir = (0, import_node_path8.join)(root, "artifacts", "tests", "e2e");
   const tcFieldsMap = /* @__PURE__ */ new Map();
   let e2eFiles;
   try {
-    e2eFiles = (await (0, import_promises6.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path7.join)(e2eDir, name));
+    e2eFiles = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path8.join)(e2eDir, name));
   } catch {
     e2eFiles = [];
   }
   for (const filePath of e2eFiles) {
-    const raw = await (0, import_promises6.readFile)(filePath, "utf-8");
+    const raw = await (0, import_promises7.readFile)(filePath, "utf-8");
     const lines = raw.split(/\r?\n/);
     const tcStarts = [];
     lines.forEach((line, index) => {
@@ -7138,7 +7325,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
       }
     });
     const parsed = (0, import_gray_matter.default)(raw);
-    const batch = String(parsed.data.test_batch ?? (0, import_node_path7.basename)(filePath, (0, import_node_path7.extname)(filePath))).trim();
+    const batch = String(parsed.data.test_batch ?? (0, import_node_path8.basename)(filePath, (0, import_node_path8.extname)(filePath))).trim();
     for (let i = 0; i < tcStarts.length; i++) {
       const start = tcStarts[i];
       const end = tcStarts[i + 1]?.index ?? lines.length;
@@ -7190,7 +7377,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
     }
   }
   const runners = (await loadConfig(root)).e2e?.runners ?? [];
-  const allProjectFiles = await walk(root);
+  const allProjectFiles = await walkFiles(root);
   for (const node of e2eNodes) {
     const fields = tcFieldsMap.get(node.code) ?? asRecord(node.attrs?.tcFields);
     const status = String(fields["status"] ?? "").trim().toLowerCase();
@@ -7201,7 +7388,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
     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_path7.join)(root, normalized))) continue;
+      if (!normalized || !(0, import_node_fs4.existsSync)((0, import_node_path8.join)(root, normalized))) continue;
       const accepting = await getAcceptingRunners(root, normalized, runners);
       if (accepting.some((runner) => runner.kind === "e2e")) {
         hasActiveE2eRef = true;
@@ -7260,7 +7447,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   const acCoverageRateByFeature = {};
   const featureAcMap = /* @__PURE__ */ new Map();
   for (const node of featureNodes) {
-    const acs = parseAcceptanceCriteria(await (0, import_promises6.readFile)((0, import_node_path7.join)(root, node.path), "utf-8"));
+    const acs = parseAcceptanceCriteria(await (0, import_promises7.readFile)((0, import_node_path8.join)(root, node.path), "utf-8"));
     featureAcMap.set(node.code, new Set(acs));
   }
   const coveredAcByFeature = /* @__PURE__ */ new Map();
@@ -7302,10 +7489,10 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   };
 }
 async function generateE2eRegistry(root, opts) {
-  const e2eDir = (0, import_node_path7.join)(root, "artifacts", "tests", "e2e");
+  const e2eDir = (0, import_node_path8.join)(root, "artifacts", "tests", "e2e");
   let files;
   try {
-    files = (await (0, import_promises6.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
+    files = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
   } catch {
     return {
       registry_version: "1.0",
@@ -7318,11 +7505,11 @@ async function generateE2eRegistry(root, opts) {
   const batches = [];
   let totalTestCases = 0;
   for (const file of files) {
-    const filePath = (0, import_node_path7.join)(e2eDir, file);
-    const raw = await (0, import_promises6.readFile)(filePath, "utf-8");
+    const filePath = (0, import_node_path8.join)(e2eDir, file);
+    const raw = await (0, import_promises7.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_path7.basename)(file, (0, import_node_path7.extname)(file))).trim();
+    const batch = String(data.test_batch ?? (0, import_node_path8.basename)(file, (0, import_node_path8.extname)(file))).trim();
     const relPath = `artifacts/tests/e2e/${file}`;
     const scope = String(data.scope ?? "").trim();
     const acCoverage = normalizeAcCoverageForRegistry(data.ac_coverage);
@@ -7446,10 +7633,10 @@ async function validatePartialRustEvidence(tcFields, tcKey, root, allFiles) {
     if (!normalizedPath) {
       return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
     }
-    const fullPath = (0, import_node_path7.join)(root, normalizedPath);
+    const fullPath = (0, import_node_path8.join)(root, normalizedPath);
     let content;
     try {
-      content = await (0, import_promises6.readFile)(fullPath, "utf-8");
+      content = await (0, import_promises7.readFile)(fullPath, "utf-8");
     } catch {
       return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
     }
@@ -7483,7 +7670,7 @@ function detectTestLevel(specFile, content) {
 }
 function resolveExecutableRefFile(refFile, allFiles) {
   const normalized = refFile.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (!normalized || (0, import_node_path7.isAbsolute)(refFile) || normalized.split("/").includes("..")) {
+  if (!normalized || (0, import_node_path8.isAbsolute)(refFile) || normalized.split("/").includes("..")) {
     return void 0;
   }
   if (allFiles.includes(normalized)) {
@@ -7558,9 +7745,9 @@ function escapeRegExp(value) {
 }
 async function hasMarkdownTc(tcKey, e2eDir) {
   const [batch, tcId] = tcKey.split(":");
-  const filePath = (0, import_node_path7.join)(e2eDir, `${batch}.md`);
+  const filePath = (0, import_node_path8.join)(e2eDir, `${batch}.md`);
   try {
-    const raw = await (0, import_promises6.readFile)(filePath, "utf-8");
+    const raw = await (0, import_promises7.readFile)(filePath, "utf-8");
     const tcRegex = new RegExp(`^#{2,3}\\s+${escapeRegExp(tcId)}\\s*[:\uFF1A]?`, "m");
     return tcRegex.test(raw);
   } catch {
@@ -7568,7 +7755,7 @@ async function hasMarkdownTc(tcKey, e2eDir) {
   }
 }
 async function findFiles(root, patterns) {
-  const all = await walk(root);
+  const all = await walkFiles(root);
   const matched = /* @__PURE__ */ new Set();
   for (const pattern of patterns) {
     for (const file of all) {
@@ -7579,21 +7766,9 @@ async function findFiles(root, patterns) {
   }
   return [...matched].sort();
 }
-async function walk(root, current = root) {
-  const entries = await (0, import_promises6.readdir)(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 = (0, import_node_path7.join)(current, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await walk(root, fullPath));
-    } else {
-      files.push((0, import_node_path7.relative)(root, fullPath).split("\\").join("/"));
-    }
-  }
-  return files;
+function matchesConfiguredArtifactPath(path, schema) {
+  const normalizedPath = path.replace(/\\/g, "/").replace(/^\.\//, "");
+  return Object.values(schema.types).some((definition) => definition.paths.some((pattern) => matchesPattern(normalizedPath, pattern)));
 }
 function matchesPattern(file, pattern) {
   if (!pattern.includes("*")) {
@@ -7805,7 +7980,7 @@ function normalizeDesignCode(value) {
   if (!raw) {
     return "";
   }
-  return (0, import_node_path7.basename)(raw, (0, import_node_path7.extname)(raw));
+  return (0, import_node_path8.basename)(raw, (0, import_node_path8.extname)(raw));
 }
 function toUid(type, code) {
   return `${type}:${code}`;
@@ -8070,7 +8245,7 @@ function resolveArtifactContext(graph, opts) {
     }
     if (root) {
       for (const ap of ALWAYS_PRESENT_ITEMS) {
-        const fullPath = (0, import_node_path7.join)(root, ap.path);
+        const fullPath = (0, import_node_path8.join)(root, ap.path);
         let stat;
         try {
           stat = (0, import_node_fs4.statSync)(fullPath);
@@ -8300,18 +8475,19 @@ function formatContextMarkdown(manifest) {
   }
   return lines.join("\n");
 }
-var import_better_sqlite3, import_gray_matter, import_js_yaml, import_node_fs4, import_promises6, import_node_path7, TARGET_ARTIFACT_TYPES, NON_TARGET_ROLES, DEFAULT_SCHEMA, VALID_TC_STATUSES, VALID_CHAIN_TYPES, DEPRECATED_CHAIN_TYPE_ALIASES, CONTEXT_CATEGORIES, TIER_ORDER;
+var import_better_sqlite3, import_gray_matter, import_js_yaml, import_node_fs4, import_promises7, import_node_path8, 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"() {
     import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
     import_gray_matter = __toESM(require("gray-matter"), 1);
     import_js_yaml = __toESM(require("js-yaml"), 1);
     import_node_fs4 = require("fs");
-    import_promises6 = require("fs/promises");
-    import_node_path7 = require("path");
+    import_promises7 = require("fs/promises");
+    import_node_path8 = require("path");
     init_packet_constants();
     init_packet_validator();
     init_glob_matcher();
+    init_file_walker();
     init_packet_constants();
     init_target_selector();
     init_packet_assembler();
@@ -8457,10 +8633,12 @@ init_index();
   isPacketTargetType,
   isPacketTargetTypeDynamic,
   isTargetArtifactType,
+  isVersionLockIssueBlocking,
   loadConfig,
   loadContract,
   loadContractCatalog,
   loadContractsFromDirectory,
+  matchesConfiguredArtifactPath,
   nextId,
   normalizeE2eLegacyArtifact,
   normalizeToCanonical,
@@ -8497,5 +8675,6 @@ init_index();
   validateScenarioPrdLinkIndex,
   validateScenarioPrdLinks,
   verifyDigest,
+  versionLockIssueSeverity,
   writeGraphCache
 });