artifact-graph 0.8.4 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.9.0
+
+### Changed
+
+- Version synchronized with `artifact-chain-assistant@0.9.0` (suite lockstep release). No runtime
+  behavior changes.
+
+## 0.8.5
+
+### Fixed
+
+- E2E trace validation now accepts only real standalone line comments. Annotation-shaped text in
+  source strings and template literals is ignored, eliminating false `E2E-TRACE-002` findings from
+  test fixtures.
+- Staged version-lock refresh now blocks only for unstaged files matched by the project's configured
+  artifact paths (plus the graph config and lock file). Unrelated Markdown or source files no longer
+  prevent a valid split commit, while genuine graph-relevant divergence remains fail-closed.
+
 ## 0.8.4
 
 ### Changed

package/dist/cli.js

@@ -316,6 +316,41 @@ var init_glob_matcher = __esm({
   }
 });
 
+// src/file-walker.ts
+import { readdir } from "fs/promises";
+import { join, relative } from "path";
+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 = join(current, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFiles(root, fullPath, readDirectory));
+    } else {
+      files.push(relative(root, fullPath).split("\\").join("/"));
+    }
+  }
+  return files;
+}
+var defaultReadDirectory;
+var init_file_walker = __esm({
+  "src/file-walker.ts"() {
+    "use strict";
+    defaultReadDirectory = readdir;
+  }
+});
+
 // src/target-selector.ts
 function parseTargetSelector(value) {
   const separator = value.indexOf(":");
@@ -830,7 +865,7 @@ var init_packet_assembler = __esm({
 
 // src/packet-audit.ts
 import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
+import { join as join2 } from "path";
 function parseTargetsFile(content, schema) {
   const validTypes = schema ? new Set(getTargetArtifactTypes(schema)) : VALID_TYPES;
   const validTypesLabel = [...validTypes].join(", ");
@@ -921,7 +956,7 @@ 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 = join(options.outDir, filename);
+      const outPath = join2(options.outDir, filename);
       let content;
       if (fmt === "json") {
         content = JSON.stringify(packet, null, 2) + "\n";
@@ -1001,7 +1036,7 @@ async function auditPackets(root, targets, options, graph) {
     ...isCompact ? { summaryDetail: "compact", countsByType } : {}
   };
   if (options.outDir) {
-    const summaryPath = join(options.outDir, "summary.json");
+    const summaryPath = join2(options.outDir, "summary.json");
     await writeFile(summaryPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
   }
   return summary;
@@ -1373,7 +1408,7 @@ var init_packet_prompt_validator = __esm({
 import { createHash } from "crypto";
 import { existsSync } from "fs";
 import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join2, relative } from "path";
+import { dirname, join as join3, relative as relative2 } from "path";
 async function buildVersionIndex(root, graph) {
   const scannedGraph = graph ?? await scanArtifacts(root);
   const hashCache = /* @__PURE__ */ new Map();
@@ -1509,7 +1544,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 = join2(root, sourcePath);
+    const fullSourcePath = join3(root, sourcePath);
     if (!existsSync(fullSourcePath)) continue;
     let liveness = livenessCache.get(sourcePath);
     if (liveness === void 0) {
@@ -1604,14 +1639,14 @@ async function auditVersionLock(root, lockPath = VERSION_LOCK_PATH, graph, confi
         currentArtifactHash: targetNode.contentHash
       });
     }
-    if (!existsSync(join2(root, sourceNode.path))) {
+    if (!existsSync(join3(root, sourceNode.path))) {
       entryIssues.push({
         status: "orphan_lock",
         edgeId: relEdgeId,
         message: `Artifact relation source file ${sourceNode.path} no longer exists`
       });
     }
-    if (!existsSync(join2(root, targetNode.path))) {
+    if (!existsSync(join3(root, targetNode.path))) {
       entryIssues.push({
         status: "orphan_lock",
         edgeId: relEdgeId,
@@ -2184,7 +2219,7 @@ function renderTraceVersionMarkdown(result) {
 async function readVersionLock(root, lockPath) {
   const safeLockPath = normalizeRelativePath(root, lockPath);
   try {
-    const raw = await readFile(join2(root, safeLockPath), "utf-8");
+    const raw = await readFile(join3(root, safeLockPath), "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -2343,7 +2378,7 @@ function requireSafeRelativePath(value, path) {
 }
 async function writeVersionLock(root, lockPath, lock) {
   const safeLockPath = normalizeRelativePath(root, lockPath);
-  const fullPath = join2(root, safeLockPath);
+  const fullPath = join3(root, safeLockPath);
   await mkdir2(dirname(fullPath), { recursive: true });
   await writeFile2(fullPath, `${JSON.stringify(lock, null, 2)}
 `);
@@ -2526,14 +2561,14 @@ async function hashRelativePath(root, path, cache) {
   const normalized = normalizeRelativePath(root, path);
   const cached = cache.get(normalized);
   if (cached) return cached;
-  const content = await readFile(join2(root, normalized));
+  const content = await readFile(join3(root, normalized));
   const hash = `sha256:${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("/") ? relative(root, normalized).replace(/\\/g, "/") : normalized.replace(/^\.\//, "");
+  const relativePath = normalized.startsWith("/") ? relative2(root, normalized).replace(/\\/g, "/") : normalized.replace(/^\.\//, "");
   if (relativePath === ".." || relativePath.startsWith("../")) {
     throw new Error(`Path is outside root: ${path}`);
   }
@@ -2549,7 +2584,7 @@ async function getTestFileRunnerLiveness(root, filePath, config) {
     if (!/e2e/i.test(filePath) && !/\.e2e\./i.test(filePath)) {
       return "active";
     }
-    const fullSourcePath = join2(root, filePath);
+    const fullSourcePath = join3(root, filePath);
     if (!existsSync(fullSourcePath)) return "inactive";
     try {
       const content = await readFile(fullSourcePath, "utf-8");
@@ -2618,7 +2653,7 @@ var init_versioned_traceability = __esm({
 import { execFile } from "child_process";
 import { constants } from "fs";
 import { access } from "fs/promises";
-import { isAbsolute, join as join3, resolve } from "path";
+import { isAbsolute, join as join4, resolve } from "path";
 import { promisify } from "util";
 async function resolveArtifactGraphCli(root, options = {}) {
   const pathCli = await findCommandOnPath("artifact-graph");
@@ -2626,7 +2661,7 @@ async function resolveArtifactGraphCli(root, options = {}) {
   const candidates = [
     {
       source: "node_modules",
-      path: join3(root, "node_modules/.bin/artifact-graph"),
+      path: join4(root, "node_modules/.bin/artifact-graph"),
       exists: false
     },
     {
@@ -2659,8 +2694,8 @@ async function resolveArtifactGraphCli(root, options = {}) {
 }
 async function doctorArtifactChain(root, options = {}) {
   const cli = await resolveArtifactGraphCli(root, options);
-  const configPath = join3(root, "artifact-graph.config.yaml");
-  const lockPath = join3(root, VERSION_LOCK_PATH);
+  const configPath = join4(root, "artifact-graph.config.yaml");
+  const lockPath = join4(root, VERSION_LOCK_PATH);
   const supportedCommands = cli.path ? await detectSupportedCommands(cli.path) : [];
   const nodeCompatible = isNodeCompatible(process.versions.node);
   const warnings = [
@@ -2885,7 +2920,7 @@ var init_git_hook_path = __esm({
 import { constants as constants2 } from "fs";
 import { randomUUID } from "crypto";
 import { lstat, mkdir as mkdir3, open, readlink, rename, unlink } from "fs/promises";
-import { basename, dirname as dirname2, join as join4 } from "path";
+import { basename, dirname as dirname2, join as join5 } from "path";
 function detectHookInterpreter(content) {
   if (content.trim().length === 0) {
     return "empty";
@@ -3193,7 +3228,7 @@ async function removeHookAtomically(hookPath, snapshot) {
 }
 async function writeHookAtomically(hookPath, content, snapshot, mode) {
   await mkdir3(dirname2(hookPath), { recursive: true });
-  const temporaryPath = join4(dirname2(hookPath), `.${basename(hookPath)}.${randomUUID()}.tmp`);
+  const temporaryPath = join5(dirname2(hookPath), `.${basename(hookPath)}.${randomUUID()}.tmp`);
   let temporaryExists = false;
   try {
     const temporary = await open(temporaryPath, "wx", mode);
@@ -3658,8 +3693,8 @@ __export(contract_kernel_exports, {
   verifyDigest: () => verifyDigest
 });
 import { createHash as createHash2 } from "crypto";
-import { readFile as readFile2, readdir } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join6 } from "path";
 import _AjvModule from "ajv";
 function isOfficialNamespace(namespace) {
   return OFFICIAL_NAMESPACE_PATTERN.test(namespace);
@@ -4069,10 +4104,10 @@ async function loadContract(contractPath, options) {
 }
 async function loadContractsFromDirectory(contractsDir, options) {
   const contracts = [];
-  const entries = await readdir(contractsDir, { withFileTypes: true });
+  const entries = await readdir2(contractsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const schemaPath = join5(contractsDir, entry.name, "schema.json");
+      const schemaPath = join6(contractsDir, entry.name, "schema.json");
       const contract = await loadContract(schemaPath, options);
       contracts.push(contract);
     }
@@ -4564,8 +4599,8 @@ import Database from "better-sqlite3";
 import matter from "gray-matter";
 import yaml from "js-yaml";
 import { accessSync, constants as fsConstants, existsSync as existsSync2, statSync } from "fs";
-import { mkdir as mkdir4, readFile as readFile3, readdir as readdir2, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename3, dirname as dirname3, extname, isAbsolute as isAbsolute3, join as join6, relative as relative2, resolve as resolve3 } from "path";
+import { mkdir as mkdir4, readFile as readFile3, readdir as readdir3, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename3, dirname as dirname3, extname, isAbsolute as isAbsolute3, join as join7, relative as relative3, resolve as resolve3 } from "path";
 function isTargetArtifactType(type) {
   return isPacketTargetType(type);
 }
@@ -4607,7 +4642,7 @@ function resolveArtifactTypeName(schema, token) {
   return void 0;
 }
 async function loadConfig(root) {
-  const configPath = join6(root, "artifact-graph.config.yaml");
+  const configPath = join7(root, "artifact-graph.config.yaml");
   let parsed = {};
   try {
     const raw = await readFile3(configPath, "utf-8");
@@ -4784,7 +4819,7 @@ async function scanArtifacts(root, schema) {
         continue;
       }
       scannedFiles.set(file, type);
-      const raw = await readFile3(join6(root, file), "utf-8");
+      const raw = await readFile3(join7(root, file), "utf-8");
       const parsed = parseFile(type, file, raw, config);
       nodes.push(...parsed.nodes);
       edges.push(...parsed.edges);
@@ -5096,7 +5131,7 @@ async function validateScenarioPrdLinkIndex(root, graph) {
   const indexPath = "artifacts/prd/feature-index.md";
   let raw = "";
   try {
-    raw = await readFile3(join6(root, indexPath), "utf-8");
+    raw = await readFile3(join7(root, indexPath), "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -5286,11 +5321,11 @@ function nextId(graph, schema, type, rangeName) {
   throw new Error(`ID range ${type}.${rangeName} is exhausted`);
 }
 async function writeGraphCache(root, graph) {
-  const cacheDir = join6(root, ".artifact-graph");
+  const cacheDir = join7(root, ".artifact-graph");
   await mkdir4(cacheDir, { recursive: true });
-  await writeFile3(join6(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
+  await writeFile3(join7(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
 `);
-  const db = new Database(join6(cacheDir, "graph.sqlite"));
+  const db = new Database(join7(cacheDir, "graph.sqlite"));
   try {
     db.exec(`
       DROP TABLE IF EXISTS nodes;
@@ -6973,10 +7008,10 @@ function validateE2eRegistry(graph) {
 async function validateExecutableTraceability(root, config) {
   const issues = [];
   const schema = config ?? await loadConfig(root);
-  const e2eDir = join6(root, "artifacts", "tests", "e2e");
+  const e2eDir = join7(root, "artifacts", "tests", "e2e");
   let e2eFiles;
   try {
-    e2eFiles = (await readdir2(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join6(e2eDir, name));
+    e2eFiles = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join7(e2eDir, name));
   } catch {
     return [];
   }
@@ -6986,7 +7021,7 @@ async function validateExecutableTraceability(root, config) {
   const mdBatches = /* @__PURE__ */ new Set();
   for (const filePath of e2eFiles) {
     const raw = await readFile3(filePath, "utf-8");
-    const relPath = relative2(root, filePath).split("\\").join("/");
+    const relPath = relative3(root, filePath).split("\\").join("/");
     const parsed = matter(raw);
     const data = parsed.data;
     const batch = String(data.test_batch ?? basename3(filePath, extname(filePath))).trim();
@@ -7014,7 +7049,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) {
@@ -7034,7 +7069,7 @@ 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 = join6(root, specFile);
+    const fullSpecPath = join7(root, specFile);
     let content;
     try {
       content = await readFile3(fullSpecPath, "utf-8");
@@ -7043,14 +7078,16 @@ async function validateExecutableTraceability(root, config) {
     }
     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;
@@ -7077,7 +7114,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) ?? [];
@@ -7114,7 +7151,7 @@ async function validateExecutableTraceability(root, config) {
       if (entry.testId) {
         let content;
         try {
-          content = await readFile3(join6(root, normalizedRefFile), "utf-8");
+          content = await readFile3(join7(root, normalizedRefFile), "utf-8");
         } catch {
           continue;
         }
@@ -7291,11 +7328,11 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   let withExecutableRef = 0;
   const statusBreakdown = {};
   const chainTypeBreakdown = {};
-  const e2eDir = join6(root, "artifacts", "tests", "e2e");
+  const e2eDir = join7(root, "artifacts", "tests", "e2e");
   const tcFieldsMap = /* @__PURE__ */ new Map();
   let e2eFiles;
   try {
-    e2eFiles = (await readdir2(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join6(e2eDir, name));
+    e2eFiles = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join7(e2eDir, name));
   } catch {
     e2eFiles = [];
   }
@@ -7362,7 +7399,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();
@@ -7373,7 +7410,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
     let hasActiveE2eRef = false;
     for (const entry of parseExecutableRefLines(execRef)) {
       const normalized = resolveExecutableRefFile(entry.file, allProjectFiles);
-      if (!normalized || !existsSync2(join6(root, normalized))) continue;
+      if (!normalized || !existsSync2(join7(root, normalized))) continue;
       const accepting = await getAcceptingRunners(root, normalized, runners);
       if (accepting.some((runner) => runner.kind === "e2e")) {
         hasActiveE2eRef = true;
@@ -7432,7 +7469,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   const acCoverageRateByFeature = {};
   const featureAcMap = /* @__PURE__ */ new Map();
   for (const node of featureNodes) {
-    const acs = parseAcceptanceCriteria(await readFile3(join6(root, node.path), "utf-8"));
+    const acs = parseAcceptanceCriteria(await readFile3(join7(root, node.path), "utf-8"));
     featureAcMap.set(node.code, new Set(acs));
   }
   const coveredAcByFeature = /* @__PURE__ */ new Map();
@@ -7474,10 +7511,10 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   };
 }
 async function generateE2eRegistry(root, opts) {
-  const e2eDir = join6(root, "artifacts", "tests", "e2e");
+  const e2eDir = join7(root, "artifacts", "tests", "e2e");
   let files;
   try {
-    files = (await readdir2(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
+    files = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
   } catch {
     return {
       registry_version: "1.0",
@@ -7490,7 +7527,7 @@ async function generateE2eRegistry(root, opts) {
   const batches = [];
   let totalTestCases = 0;
   for (const file of files) {
-    const filePath = join6(e2eDir, file);
+    const filePath = join7(e2eDir, file);
     const raw = await readFile3(filePath, "utf-8");
     const parsed = matter(raw);
     const data = parsed.data;
@@ -7618,7 +7655,7 @@ async function validatePartialRustEvidence(tcFields, tcKey, root, allFiles) {
     if (!normalizedPath) {
       return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
     }
-    const fullPath = join6(root, normalizedPath);
+    const fullPath = join7(root, normalizedPath);
     let content;
     try {
       content = await readFile3(fullPath, "utf-8");
@@ -7730,7 +7767,7 @@ function escapeRegExp(value) {
 }
 async function hasMarkdownTc(tcKey, e2eDir) {
   const [batch, tcId] = tcKey.split(":");
-  const filePath = join6(e2eDir, `${batch}.md`);
+  const filePath = join7(e2eDir, `${batch}.md`);
   try {
     const raw = await readFile3(filePath, "utf-8");
     const tcRegex = new RegExp(`^#{2,3}\\s+${escapeRegExp(tcId)}\\s*[:\uFF1A]?`, "m");
@@ -7740,7 +7777,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) {
@@ -7751,21 +7788,9 @@ async function findFiles(root, patterns) {
   }
   return [...matched].sort();
 }
-async function walk(root, current = root) {
-  const entries = await readdir2(current, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git" || entry.name === ".artifact-graph") {
-      continue;
-    }
-    const fullPath = join6(current, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await walk(root, fullPath));
-    } else {
-      files.push(relative2(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("*")) {
@@ -8242,7 +8267,7 @@ function resolveArtifactContext(graph, opts) {
     }
     if (root) {
       for (const ap of ALWAYS_PRESENT_ITEMS) {
-        const fullPath = join6(root, ap.path);
+        const fullPath = join7(root, ap.path);
         let stat;
         try {
           stat = statSync(fullPath);
@@ -8479,6 +8504,7 @@ var init_index = __esm({
     init_packet_constants();
     init_packet_validator();
     init_glob_matcher();
+    init_file_walker();
     init_packet_constants();
     init_target_selector();
     init_packet_assembler();
@@ -8583,7 +8609,7 @@ var init_index = __esm({
 
 // src/packet-prompt-audit.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function promptFilename(target) {
   return `prompt-${target.type}-${target.id}.md`;
 }
@@ -8635,7 +8661,7 @@ async function auditSinglePromptTarget(target, graph, options) {
     }
     if (options.outDir) {
       const filename = promptFilename(target);
-      const outPath = join7(options.outDir, filename);
+      const outPath = join8(options.outDir, filename);
       await writeFile4(outPath, prompt, "utf-8");
       entry.outputPath = outPath;
     }
@@ -8741,9 +8767,9 @@ async function auditPromptBatch(root, targets, options, graph) {
   };
   if (options.outDir) {
     await mkdir5(options.outDir, { recursive: true });
-    const jsonPath = join7(options.outDir, "prompt-audit-summary.json");
+    const jsonPath = join8(options.outDir, "prompt-audit-summary.json");
     await writeFile4(jsonPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
-    const mdPath = join7(options.outDir, "prompt-audit-summary.md");
+    const mdPath = join8(options.outDir, "prompt-audit-summary.md");
     await writeFile4(mdPath, renderPromptAuditSummaryMarkdown(summary), "utf-8");
   }
   return summary;
@@ -8785,7 +8811,7 @@ __export(cli_exports, {
 import yaml2 from "js-yaml";
 import { realpathSync } from "fs";
 import { access as access2, mkdir as mkdir6, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join8 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join9 } from "path";
 import { fileURLToPath } from "url";
 async function runCli(argv, io = {}) {
   const parsed = parseArgs(argv);
@@ -8802,7 +8828,7 @@ async function runCli(argv, io = {}) {
     switch (parsed.command) {
       case "init": {
         await initConfig(root);
-        out(`Created ${join8(root, "artifact-graph.config.yaml")}
+        out(`Created ${join9(root, "artifact-graph.config.yaml")}
 `);
         return 0;
       }
@@ -9631,7 +9657,8 @@ async function runCli(argv, io = {}) {
               err("Stage or stash the unstaged changes before running changed-only staged refresh.\n");
               return 1;
             }
-            const unstagedGraphPaths = changeResult.unstagedPaths.filter(isGraphRelevantPath);
+            const schema = await loadConfig(root);
+            const unstagedGraphPaths = changeResult.unstagedPaths.filter((path) => isGraphRelevantPath(path, schema));
             if (unstagedGraphPaths.length > 0) {
               err("Cannot refresh staged version locks because graph-relevant unstaged changes may affect working-tree hashes:\n");
               for (const conflictPath of unstagedGraphPaths) {
@@ -9740,7 +9767,7 @@ async function runCli(argv, io = {}) {
           err("Usage: artifact-graph validate-review-result --file <path> [--format json]\n");
           return 1;
         }
-        const resolvedPath = isAbsolute4(filePath) ? filePath : join8(root, filePath);
+        const resolvedPath = isAbsolute4(filePath) ? filePath : join9(root, filePath);
         let content;
         try {
           content = await readFile4(resolvedPath, "utf-8");
@@ -9778,7 +9805,7 @@ async function runCli(argv, io = {}) {
         const deterministic = checkMode || parsed.flags.deterministic === true;
         const registry = await generateE2eRegistry(root, { deterministic });
         const output = JSON.stringify(registry, null, 2) + "\n";
-        const outPath = typeof parsed.flags.out === "string" ? parsed.flags.out : join8(root, "artifacts/tests/e2e/e2e-test-registry.json");
+        const outPath = typeof parsed.flags.out === "string" ? parsed.flags.out : join9(root, "artifacts/tests/e2e/e2e-test-registry.json");
         if (checkMode) {
           let existing = "";
           try {
@@ -9815,7 +9842,7 @@ async function runCli(argv, io = {}) {
           return 1;
         }
         const packageDir = dirname4(fileURLToPath(import.meta.url));
-        const contractsDir = typeof parsed.flags["contracts-dir"] === "string" ? parsed.flags["contracts-dir"] : join8(packageDir, "..", "contracts");
+        const contractsDir = typeof parsed.flags["contracts-dir"] === "string" ? parsed.flags["contracts-dir"] : join9(packageDir, "..", "contracts");
         const revisionDigest = typeof parsed.flags["revision-digest"] === "string" ? parsed.flags["revision-digest"] : void 0;
         async function resolveContract(contractId) {
           const catalog = await loadContractCatalog(contractsDir);
@@ -10078,11 +10105,11 @@ function hasBlockingVersionIssues(issues, strictMissingLock) {
     severity: issue2.severity
   }, strictMissingLock));
 }
-function isGraphRelevantPath(path) {
-  return path === "artifact-graph.config.yaml" || path === VERSION_LOCK_PATH || path.startsWith("artifacts/") || /\.(md|mdx|json|ya?ml|ts|tsx|js|jsx|mts|cts|rs|py|go)$/.test(path);
+function isGraphRelevantPath(path, schema) {
+  return path === "artifact-graph.config.yaml" || path === VERSION_LOCK_PATH || matchesConfiguredArtifactPath(path, schema);
 }
 async function initConfig(root) {
-  const configPath = join8(root, "artifact-graph.config.yaml");
+  const configPath = join9(root, "artifact-graph.config.yaml");
   try {
     await access2(configPath);
     throw new Error(`Config already exists: ${configPath}`);