artifact-graph 0.9.3 → 0.10.0

package/dist/index.cjs

@@ -2695,6 +2695,190 @@ var init_versioned_traceability = __esm({
   }
 });
 
+// src/native-binding-diagnostics.ts
+function parsePnpmVersion(stdout) {
+  const trimmed = stdout.trim();
+  const segments = trimmed.split(".");
+  if (!/^\d+$/.test(segments[0] ?? "")) return void 0;
+  const major = Number(segments[0]);
+  const minorSegment = segments.length > 1 ? segments[1] : void 0;
+  const minor = minorSegment !== void 0 && /^\d+$/.test(minorSegment) ? Number(minorSegment) : void 0;
+  return minor === void 0 ? { major } : { major, minor };
+}
+function pnpmUsesAllowBuilds(version) {
+  if (!version) return false;
+  return version.major > 10 || version.major === 10 && (version.minor ?? 0) >= 26;
+}
+function createInstallBoundBindingLoader(installBase) {
+  return () => (0, import_node_module.createRequire)(installBase)("better-sqlite3");
+}
+function defaultBindingLoaderImpl() {
+  const base = typeof __filename === "string" ? __filename : import_meta.url;
+  return (0, import_node_module.createRequire)(base)("better-sqlite3");
+}
+function defaultBindingLoader() {
+  return defaultBindingLoaderImpl();
+}
+function classifyNativeBindingError(error, context = {}) {
+  const message = error instanceof Error ? error.message : String(error);
+  const code = error?.code;
+  if (/was compiled against a different Node\.js version|NODE_MODULE_VERSION|different ABI|Incompatible ABI/i.test(
+    message
+  )) {
+    return { cause: "ABI_MISMATCH", detail: message };
+  }
+  if (code === "MODULE_NOT_FOUND" || /Cannot find module|Cannot find package/i.test(message)) {
+    if (context.packagePresent) {
+      return {
+        cause: "BUILD_DISABLED",
+        detail: `${message}\uFF08better-sqlite3 \u5305\u76EE\u5F55\u5B58\u5728\u4F46\u539F\u751F\u4EA7\u7269\u7F3A\u5931\uFF0C\u7B26\u5408 lifecycle scripts \u88AB\u7981\u7684\u7279\u5F81\uFF09`
+      };
+    }
+    return { cause: "MISSING", detail: message };
+  }
+  if (/Could not locate the bindings file/i.test(message)) {
+    return {
+      cause: "BUILD_DISABLED",
+      detail: `${message}\uFF08better-sqlite3 \u5305\u5B58\u5728\u4F46\u539F\u751F .node \u4EA7\u7269\u672A\u6784\u5EFA\uFF0C\u7B26\u5408 lifecycle scripts \u88AB\u7981\u6216\u672A\u6784\u5EFA\u7684\u7279\u5F81\uFF09`
+    };
+  }
+  if (/invalid ELF|broken binary|failed to load native/i.test(message)) {
+    return { cause: "LOAD_ERROR", detail: message };
+  }
+  return { cause: "LOAD_ERROR", detail: message };
+}
+function buildNativeBindingSuggestion(cause, pnpmVersion) {
+  const allowlist = pnpmUsesAllowBuilds(pnpmVersion) ? `pnpm 10.26+ \u5728\u9879\u76EE\u6839 pnpm-workspace.yaml \u6DFB\u52A0 allowBuilds \u952E\uFF08${PNPM_ALLOW_BUILDS_SNIPPET.replace(/\n/g, "\uFF1B")}\uFF09` : `pnpm 10.0\u201310.25 \u5728 package.json \u914D\u7F6E pnpm.onlyBuiltDependencies: ["better-sqlite3"]\uFF08pnpm 10.26+ \u6539\u7528\u9879\u76EE\u6839 pnpm-workspace.yaml \u7684 allowBuilds \u952E\uFF09`;
+  switch (cause) {
+    case "MISSING":
+      return `better-sqlite3 \u539F\u751F\u4EA7\u7269\u7F3A\u5931\u3002\u6309 INSTALL.md \u58F0\u660E\u6784\u5EFA\u5141\u8BB8\u6E05\u5355\u540E\u91CD\u65B0\u5B89\u88C5\uFF1A${allowlist}\uFF0C\u7136\u540E pnpm install\u3002`;
+    case "ABI_MISMATCH":
+      return `\u5F53\u524D Node ABI \u4E0E better-sqlite3 prebuilt \u76EE\u6807\u4E0D\u4E00\u81F4\uFF08\u5F53\u524D process.versions.modules=${process.versions.modules}\uFF09\u3002\u5207\u6362\u5230\u4E0E\u5DF2\u5B89\u88C5 prebuilt \u5339\u914D\u7684 Node \u7248\u672C\uFF0C\u6216\u5BF9\u5F53\u524D Node \u91CD\u5EFA\uFF1Apnpm rebuild better-sqlite3\u3002\u4E0D\u8981\u624B\u5DE5\u7F16\u8BD1\u3002`;
+    case "BUILD_DISABLED":
+      return `pnpm lifecycle scripts \u88AB\u7981\u5BFC\u81F4 better-sqlite3 \u672A\u6784\u5EFA\u3002${allowlist}\uFF0C\u7136\u540E pnpm install \u91CD\u5EFA\u539F\u751F\u4EA7\u7269\u3002\u4E0D\u8981\u624B\u5DE5\u7F16\u8BD1\u3002`;
+    default:
+      return "better-sqlite3 \u52A0\u8F7D\u5931\u8D25\uFF08\u672A\u77E5\u539F\u751F\u9519\u8BEF\uFF09\u3002\u5148\u8FD0\u884C artifact-graph doctor --format json \u67E5\u770B\u63A2\u9488\u8BE6\u60C5\uFF0C\u518D\u6309 INSTALL.md \u91CD\u5EFA\u5F53\u524D\u9009\u4E2D\u8FD0\u884C\u65F6\u7684\u539F\u751F\u4EA7\u7269\u3002";
+  }
+}
+function probeNativeBinding(context = {}) {
+  const loader = context.loader ?? defaultBindingLoader;
+  const presenceRoot = context.installRoot ?? context.root;
+  const packagePresent = presenceRoot ? betterSqlite3PackagePresent(presenceRoot) : void 0;
+  const classify = (error) => classifyNativeBindingError(error, { packagePresent });
+  const fail = (failedStage, error) => {
+    const { cause, detail } = classify(error);
+    return { ok: false, failedStage, cause, detail, suggestion: buildNativeBindingSuggestion(cause, context.pnpmVersion) };
+  };
+  let DatabaseCtor;
+  try {
+    DatabaseCtor = loader();
+  } catch (error) {
+    return fail("load", error);
+  }
+  const Database = DatabaseCtor;
+  let db;
+  try {
+    db = new Database(":memory:");
+  } catch (error) {
+    return fail("open", error);
+  }
+  try {
+    db.exec("CREATE TABLE probe (id INTEGER PRIMARY KEY, value TEXT)");
+    db.prepare("INSERT INTO probe (id, value) VALUES (?, ?)").run(1, "ok");
+  } catch (error) {
+    safeClose(db);
+    return fail("write", error);
+  }
+  try {
+    const row = db.prepare("SELECT value FROM probe WHERE id = ?").get(1);
+    if (!row || row.value !== "ok") {
+      safeClose(db);
+      return {
+        ok: false,
+        failedStage: "read",
+        cause: "LOAD_ERROR",
+        detail: "probe \u56DE\u8BFB\u65AD\u8A00\u5931\u8D25\uFF1ASELECT \u7ED3\u679C\u4E0E\u5199\u5165\u503C\u4E0D\u4E00\u81F4\u3002",
+        suggestion: buildNativeBindingSuggestion("LOAD_ERROR", context.pnpmVersion)
+      };
+    }
+  } catch (error) {
+    safeClose(db);
+    return fail("read", error);
+  }
+  try {
+    db.close();
+  } catch (error) {
+    return fail("close", error);
+  }
+  return { ok: true };
+}
+function buildNativeBindingDiagnostic(failure, probeContext) {
+  return {
+    selectedCli: probeContext.selectedCli,
+    runtime: `${process.execPath} (v${process.versions.node})`,
+    abi: `process.versions.modules=${process.versions.modules}${abiPrebuiltHint(failure.detail)}`,
+    installSource: probeContext.installSource,
+    probedFrom: probeContext.probedFrom,
+    failedStage: failure.failedStage,
+    cause: failure.cause,
+    suggestion: failure.suggestion
+  };
+}
+function buildNativeBindingSuccessDiagnostic(probeContext) {
+  return {
+    selectedCli: probeContext.selectedCli,
+    runtime: `${process.execPath} (v${process.versions.node})`,
+    installSource: probeContext.installSource,
+    probedFrom: probeContext.probedFrom
+  };
+}
+function findPackageRoot(anchorFile) {
+  let dir = (0, import_node_path4.dirname)(anchorFile);
+  for (; ; ) {
+    if ((0, import_node_fs2.existsSync)((0, import_node_path4.join)(dir, "package.json"))) return dir;
+    const parent = (0, import_node_path4.dirname)(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function safeClose(db) {
+  try {
+    db?.close();
+  } catch {
+  }
+}
+function abiPrebuiltHint(detail) {
+  const match = /using NODE_MODULE_VERSION (\d+)/.exec(detail);
+  return match ? `\uFF1Bprebuilt \u76EE\u6807 NODE_MODULE_VERSION=${match[1]}` : "";
+}
+function betterSqlite3PackagePresent(root) {
+  const direct = (0, import_node_path4.join)(root, "node_modules", "better-sqlite3", "package.json");
+  if ((0, import_node_fs2.existsSync)(direct)) return true;
+  const pnpmDir = (0, import_node_path4.join)(root, "node_modules", ".pnpm");
+  let entries;
+  try {
+    entries = (0, import_node_fs2.readdirSync)(pnpmDir);
+  } catch {
+    return false;
+  }
+  return entries.some((entry) => {
+    if (!entry.startsWith("better-sqlite3@")) return false;
+    return (0, import_node_fs2.existsSync)((0, import_node_path4.join)(pnpmDir, entry, "node_modules", "better-sqlite3", "package.json"));
+  });
+}
+var import_node_fs2, import_node_module, import_node_path4, import_node_url, import_meta, PNPM_ALLOW_BUILDS_SNIPPET;
+var init_native_binding_diagnostics = __esm({
+  "src/native-binding-diagnostics.ts"() {
+    "use strict";
+    import_node_fs2 = require("fs");
+    import_node_module = require("module");
+    import_node_path4 = require("path");
+    import_node_url = require("url");
+    import_meta = {};
+    PNPM_ALLOW_BUILDS_SNIPPET = "pnpm-workspace.yaml:\nallowBuilds:\n  better-sqlite3: true";
+  }
+});
+
 // src/cli-resolver.ts
 async function resolveArtifactGraphCli(root, options = {}) {
   const pathCli = await findCommandOnPath("artifact-graph");
@@ -2702,7 +2886,7 @@ async function resolveArtifactGraphCli(root, options = {}) {
   const candidates = [
     {
       source: "node_modules",
-      path: (0, import_node_path4.join)(root, "node_modules/.bin/artifact-graph"),
+      path: (0, import_node_path5.join)(root, "node_modules/.bin/artifact-graph"),
       exists: false
     },
     {
@@ -2735,13 +2919,33 @@ async function resolveArtifactGraphCli(root, options = {}) {
 }
 async function doctorArtifactChain(root, options = {}) {
   const cli = await resolveArtifactGraphCli(root, options);
-  const configPath = (0, import_node_path4.join)(root, "artifact-graph.config.yaml");
-  const lockPath = (0, import_node_path4.join)(root, VERSION_LOCK_PATH);
+  const configPath = (0, import_node_path5.join)(root, "artifact-graph.config.yaml");
+  const lockPath = (0, import_node_path5.join)(root, VERSION_LOCK_PATH);
   const supportedCommands = cli.path ? await detectSupportedCommands(cli.path) : [];
   const nodeCompatible = isNodeCompatible(process.versions.node);
+  const pnpmVersion = await detectPnpmVersion();
+  const installBase = bindingInstallBase(cli, root);
+  const installRoot = bindingInstallRoot(cli, root);
+  const loader = options.bindingLoader ?? (installBase ? createInstallBoundBindingLoader(installBase) : void 0);
+  const probe = probeNativeBinding({
+    root,
+    ...installRoot ? { installRoot } : {},
+    pnpmVersion,
+    ...loader ? { loader } : {}
+  });
+  const probedFrom = installBase ?? "(current artifact-graph package)";
+  const probeContext = {
+    selectedCli: cli.path ? `${cli.path} (${cli.source})` : "not found",
+    installSource: cli.source ?? "unknown",
+    probedFrom
+  };
+  const nativeBinding = probe.ok ? { ok: true, ...buildNativeBindingSuccessDiagnostic(probeContext) } : { ok: false, ...buildNativeBindingDiagnostic(probe, probeContext) };
   const warnings = [
     ...cli.warnings,
-    ...nodeCompatible ? [] : [`Node.js ${process.versions.node} does not satisfy >=22.0.0.`]
+    ...nodeCompatible ? [] : [`Node.js ${process.versions.node} does not satisfy >=22.0.0.`],
+    ...probe.ok ? [] : [
+      `better-sqlite3 binding probe FAILED at stage "${probe.failedStage}" (cause ${probe.cause}): ${probe.suggestion}`
+    ]
   ];
   return {
     schemaVersion: "1.0",
@@ -2760,6 +2964,7 @@ async function doctorArtifactChain(root, options = {}) {
       path: lockPath,
       exists: await pathExists(lockPath)
     },
+    nativeBinding,
     supportedCommands,
     warnings
   };
@@ -2775,6 +2980,31 @@ function renderDoctorMarkdown(report) {
     `Lock: \`${report.lock.path}\` ${report.lock.exists ? "found" : "missing"}`,
     ""
   ];
+  lines.push("## Native Binding Probe");
+  if (report.nativeBinding.ok) {
+    const binding = report.nativeBinding;
+    lines.push(
+      "- better-sqlite3 probe: PASS",
+      `  - selectedCli: \`${binding.selectedCli}\``,
+      `  - runtime: \`${binding.runtime}\``,
+      `  - installSource: \`${binding.installSource}\``,
+      `  - probedFrom: \`${binding.probedFrom}\``
+    );
+  } else {
+    const binding = report.nativeBinding;
+    lines.push(
+      "- better-sqlite3 probe: **FAIL**",
+      `  - failedStage: \`${binding.failedStage}\``,
+      `  - cause: \`${binding.cause}\``,
+      `  - selectedCli: \`${binding.selectedCli}\``,
+      `  - runtime: \`${binding.runtime}\``,
+      `  - abi: \`${binding.abi}\``,
+      `  - installSource: \`${binding.installSource}\``,
+      `  - probedFrom: \`${binding.probedFrom}\``,
+      `  - suggestion: ${binding.suggestion}`
+    );
+  }
+  lines.push("");
   if (report.supportedCommands.length > 0) {
     lines.push("## Supported Commands");
     for (const command of report.supportedCommands) {
@@ -2809,7 +3039,7 @@ ${maybe.stderr ?? ""}`;
 }
 async function pathExists(path) {
   try {
-    await (0, import_promises4.access)(path, import_node_fs2.constants.R_OK);
+    await (0, import_promises4.access)(path, import_node_fs3.constants.R_OK);
     return true;
   } catch {
     return false;
@@ -2825,22 +3055,82 @@ async function findCommandOnPath(command) {
   }
 }
 function resolveCandidatePath(root, candidatePath) {
-  return (0, import_node_path4.isAbsolute)(candidatePath) ? candidatePath : (0, import_node_path4.resolve)(root, candidatePath);
+  return (0, import_node_path5.isAbsolute)(candidatePath) ? candidatePath : (0, import_node_path5.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_promises4, import_node_path4, import_node_util, execFileAsync, KNOWN_COMMANDS;
+async function detectPnpmVersion() {
+  try {
+    const result = await execFileAsync("pnpm", ["--version"]);
+    return parsePnpmVersion(result.stdout);
+  } catch {
+    return void 0;
+  }
+}
+function bindingInstallBase(cli, root) {
+  if (!cli.path || !cli.source) return void 0;
+  switch (cli.source) {
+    case "node_modules":
+      return (0, import_node_path5.join)(root, "package.json");
+    case "plugin-bundled":
+    case "path":
+    case "legacy":
+      return resolveCliInstallAnchor(cli.path);
+    default:
+      return void 0;
+  }
+}
+function bindingInstallRoot(cli, root) {
+  if (!cli.path || !cli.source) return void 0;
+  switch (cli.source) {
+    case "node_modules":
+      return root;
+    case "plugin-bundled":
+    case "path":
+    case "legacy":
+      return findPackageRoot(resolveCliInstallAnchor(cli.path));
+    default:
+      return void 0;
+  }
+}
+function resolveCliInstallAnchor(cliPath) {
+  const real = safeRealpath(cliPath);
+  if ((0, import_node_path5.basename)((0, import_node_path5.dirname)(real)) !== ".bin") return real;
+  const shimTarget = readBinShimTarget(real);
+  return shimTarget ? safeRealpath(shimTarget) : real;
+}
+function readBinShimTarget(shimPath) {
+  let content;
+  try {
+    content = (0, import_node_fs3.readFileSync)(shimPath, "utf-8");
+  } catch {
+    return void 0;
+  }
+  if (!content.startsWith("#!")) return void 0;
+  const match = /\$basedir\/(\.\.(?:\/[^"'\s]+)+\.js)/.exec(content);
+  if (!match) return void 0;
+  return (0, import_node_path5.resolve)((0, import_node_path5.dirname)(shimPath), match[1]);
+}
+function safeRealpath(path) {
+  try {
+    return (0, import_node_fs3.realpathSync)(path);
+  } catch {
+    return path;
+  }
+}
+var import_node_child_process, import_node_fs3, import_promises4, import_node_path5, 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_node_fs3 = require("fs");
     import_promises4 = require("fs/promises");
-    import_node_path4 = require("path");
+    import_node_path5 = require("path");
     import_node_util = require("util");
     init_versioned_traceability();
+    init_native_binding_diagnostics();
     execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
     KNOWN_COMMANDS = [
       "init",
@@ -2859,6 +3149,7 @@ var init_cli_resolver = __esm({
       "version-lock refresh",
       "trace-version",
       "next-id",
+      "refactor-id",
       "render",
       "doctor"
     ];
@@ -2949,14 +3240,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_path5.isAbsolute)(value) ? (0, import_node_path5.resolve)(value) : (0, import_node_path5.resolve)(root, value);
+  return (0, import_node_path6.isAbsolute)(value) ? (0, import_node_path6.resolve)(value) : (0, import_node_path6.resolve)(root, value);
 }
-var import_node_child_process3, import_node_path5, import_node_util3, execFileAsync3;
+var import_node_child_process3, import_node_path6, 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_path5 = require("path");
+    import_node_path6 = require("path");
     import_node_util3 = require("util");
     execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
   }
@@ -3211,7 +3502,7 @@ async function readHookSnapshot(hookPath) {
     }
     let handle;
     try {
-      handle = await (0, import_promises5.open)(hookPath, import_node_fs3.constants.O_RDONLY | (import_node_fs3.constants.O_NOFOLLOW ?? 0));
+      handle = await (0, import_promises5.open)(hookPath, import_node_fs4.constants.O_RDONLY | (import_node_fs4.constants.O_NOFOLLOW ?? 0));
       const opened = await handle.stat({ bigint: true });
       if (opened.dev !== metadata.dev || opened.ino !== metadata.ino) {
         await handle.close();
@@ -3273,8 +3564,8 @@ async function removeHookAtomically(hookPath, snapshot) {
   }
 }
 async function writeHookAtomically(hookPath, content, snapshot, mode) {
-  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`);
+  await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(hookPath), { recursive: true });
+  const temporaryPath = (0, import_node_path7.join)((0, import_node_path7.dirname)(hookPath), `.${(0, import_node_path7.basename)(hookPath)}.${(0, import_node_crypto2.randomUUID)()}.tmp`);
   let temporaryExists = false;
   try {
     const temporary = await (0, import_promises5.open)(temporaryPath, "wx", mode);
@@ -3320,14 +3611,14 @@ function findManagedRange(content, begin, end) {
     end: endLine < 0 ? content.length : endLine + 1
   };
 }
-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 import_node_fs4, import_node_crypto2, import_promises5, import_node_path7, 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_fs4 = require("fs");
     import_node_crypto2 = require("crypto");
     import_promises5 = require("fs/promises");
-    import_node_path6 = require("path");
+    import_node_path7 = require("path");
     DEFAULT_MARKER_ID = "artifact-chain-assistant";
     MANAGED_STATE_PREFIX = "# artifact-chain-assistant managed state v1:";
     UnsupportedHookInterpreterError = class extends Error {
@@ -4045,7 +4336,7 @@ async function loadContractsFromDirectory(contractsDir, options) {
   const entries = await (0, import_promises6.readdir)(contractsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const schemaPath = (0, import_node_path7.join)(contractsDir, entry.name, "schema.json");
+      const schemaPath = (0, import_node_path8.join)(contractsDir, entry.name, "schema.json");
       const contract = await loadContract(schemaPath, options);
       contracts.push(contract);
     }
@@ -4160,13 +4451,13 @@ async function loadContractCatalog(contractsDir, options) {
   }
   return catalog;
 }
-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 import_node_crypto3, import_promises6, import_node_path8, 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_promises6 = require("fs/promises");
-    import_node_path7 = require("path");
+    import_node_path8 = require("path");
     import_ajv = __toESM(require("ajv"), 1);
     CONTRACT_ERROR_CODES = {
       /** Contract identity not found */
@@ -4519,11 +4810,11 @@ __export(index_exports, {
   collectChangedPaths: () => collectChangedPaths,
   computeE2eCoverageStats: () => computeE2eCoverageStats,
   computeRevisionDigest: () => computeRevisionDigest,
-  dirname: () => import_node_path8.dirname,
+  dirname: () => import_node_path9.dirname,
   discoverAndAuditPackets: () => discoverAndAuditPackets,
   discoverTargets: () => discoverTargets,
   doctorArtifactChain: () => doctorArtifactChain,
-  extname: () => import_node_path8.extname,
+  extname: () => import_node_path9.extname,
   formatContextMarkdown: () => formatContextMarkdown,
   generateE2eRegistry: () => generateE2eRegistry,
   getArtifactTypeMetadata: () => getArtifactTypeMetadata,
@@ -4620,7 +4911,7 @@ function resolveArtifactTypeName(schema, token) {
   return void 0;
 }
 async function loadConfig(root) {
-  const configPath = (0, import_node_path8.join)(root, "artifact-graph.config.yaml");
+  const configPath = (0, import_node_path9.join)(root, "artifact-graph.config.yaml");
   let parsed = {};
   try {
     const raw = await (0, import_promises7.readFile)(configPath, "utf-8");
@@ -4713,7 +5004,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_path8.isAbsolute)(runner.root)) {
+      if ((0, import_node_path9.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("..")) {
@@ -4797,14 +5088,14 @@ async function scanArtifacts(root, schema) {
         continue;
       }
       scannedFiles.set(file, type);
-      const raw = await (0, import_promises7.readFile)((0, import_node_path8.join)(root, file), "utf-8");
+      const raw = await (0, import_promises7.readFile)((0, import_node_path9.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_path8.isAbsolute)(root) ? root : (0, import_node_path8.resolve)(root);
+  const absoluteRoot = (0, import_node_path9.isAbsolute)(root) ? root : (0, import_node_path9.resolve)(root);
   const graph = buildGraph(nodes, edges, scanDiagnostics, absoluteRoot);
   return resolveMatrixEdges(graph);
 }
@@ -5113,7 +5404,7 @@ async function validateScenarioPrdLinkIndex(root, graph) {
   const indexPath = "artifacts/prd/feature-index.md";
   let raw = "";
   try {
-    raw = await (0, import_promises7.readFile)((0, import_node_path8.join)(root, indexPath), "utf-8");
+    raw = await (0, import_promises7.readFile)((0, import_node_path9.join)(root, indexPath), "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -5303,11 +5594,12 @@ 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_path8.join)(root, ".artifact-graph");
+  const cacheDir = (0, import_node_path9.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)}
+  await (0, import_promises7.writeFile)((0, import_node_path9.join)(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
 `);
-  const db = new import_better_sqlite3.default((0, import_node_path8.join)(cacheDir, "graph.sqlite"));
+  const { default: Database } = await import("better-sqlite3");
+  const db = new Database((0, import_node_path9.join)(cacheDir, "graph.sqlite"));
   try {
     db.exec(`
       DROP TABLE IF EXISTS nodes;
@@ -5418,7 +5710,7 @@ function parseFile(type, path, raw, schema = DEFAULT_SCHEMA) {
 }
 function parseGenericMarkdown(type, path, raw, schema) {
   const diagnostics = [];
-  const ext = (0, import_node_path8.extname)(path).toLowerCase();
+  const ext = (0, import_node_path9.extname)(path).toLowerCase();
   if (ext !== ".md" && ext !== ".markdown") {
     diagnostics.push(issue(
       "UNSUPPORTED_FORMAT",
@@ -5661,7 +5953,7 @@ function parseDecisions(path, raw) {
 }
 function isTestFile(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const name = (0, import_node_path8.basename)(normalized);
+  const name = (0, import_node_path9.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;
@@ -5982,7 +6274,7 @@ function parseE2eTest(path, raw) {
   });
   const nodes = [];
   const edges = [];
-  const batch = String(data.test_batch ?? (0, import_node_path8.basename)(path, (0, import_node_path8.extname)(path))).trim();
+  const batch = String(data.test_batch ?? (0, import_node_path9.basename)(path, (0, import_node_path9.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])];
@@ -6055,7 +6347,7 @@ function parseE2eRegistry(path, raw) {
     data = { parseError: error.message };
   }
   return {
-    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 }],
+    nodes: [{ type: "e2e_registry", code: (0, import_node_path9.basename)(path, (0, import_node_path9.extname)(path)), title: "E2E Test Registry", path, line: 1, attrs: data }],
     edges: []
   };
 }
@@ -7081,10 +7373,10 @@ function validateE2eRegistry(graph) {
 async function validateExecutableTraceability(root, config) {
   const issues = [];
   const schema = config ?? await loadConfig(root);
-  const e2eDir = (0, import_node_path8.join)(root, "artifacts", "tests", "e2e");
+  const e2eDir = (0, import_node_path9.join)(root, "artifacts", "tests", "e2e");
   let e2eFiles;
   try {
-    e2eFiles = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path8.join)(e2eDir, name));
+    e2eFiles = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path9.join)(e2eDir, name));
   } catch {
     return [];
   }
@@ -7094,10 +7386,10 @@ async function validateExecutableTraceability(root, config) {
   const mdBatches = /* @__PURE__ */ new Set();
   for (const filePath of e2eFiles) {
     const raw = await (0, import_promises7.readFile)(filePath, "utf-8");
-    const relPath = (0, import_node_path8.relative)(root, filePath).split("\\").join("/");
+    const relPath = (0, import_node_path9.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_path8.basename)(filePath, (0, import_node_path8.extname)(filePath))).trim();
+    const batch = String(data.test_batch ?? (0, import_node_path9.basename)(filePath, (0, import_node_path9.extname)(filePath))).trim();
     const lines = raw.split(/\r?\n/);
     const tcStarts = [];
     lines.forEach((line, index) => {
@@ -7142,7 +7434,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 = (0, import_node_path8.join)(root, specFile);
+    const fullSpecPath = (0, import_node_path9.join)(root, specFile);
     let content;
     try {
       content = await (0, import_promises7.readFile)(fullSpecPath, "utf-8");
@@ -7224,7 +7516,7 @@ async function validateExecutableTraceability(root, config) {
       if (entry.testId) {
         let content;
         try {
-          content = await (0, import_promises7.readFile)((0, import_node_path8.join)(root, normalizedRefFile), "utf-8");
+          content = await (0, import_promises7.readFile)((0, import_node_path9.join)(root, normalizedRefFile), "utf-8");
         } catch {
           continue;
         }
@@ -7401,11 +7693,11 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   let withExecutableRef = 0;
   const statusBreakdown = {};
   const chainTypeBreakdown = {};
-  const e2eDir = (0, import_node_path8.join)(root, "artifacts", "tests", "e2e");
+  const e2eDir = (0, import_node_path9.join)(root, "artifacts", "tests", "e2e");
   const tcFieldsMap = /* @__PURE__ */ new Map();
   let e2eFiles;
   try {
-    e2eFiles = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path8.join)(e2eDir, name));
+    e2eFiles = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => (0, import_node_path9.join)(e2eDir, name));
   } catch {
     e2eFiles = [];
   }
@@ -7420,7 +7712,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_path8.basename)(filePath, (0, import_node_path8.extname)(filePath))).trim();
+    const batch = String(parsed.data.test_batch ?? (0, import_node_path9.basename)(filePath, (0, import_node_path9.extname)(filePath))).trim();
     for (let i = 0; i < tcStarts.length; i++) {
       const start = tcStarts[i];
       const end = tcStarts[i + 1]?.index ?? lines.length;
@@ -7483,7 +7775,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_path8.join)(root, normalized))) continue;
+      if (!normalized || !(0, import_node_fs5.existsSync)((0, import_node_path9.join)(root, normalized))) continue;
       const accepting = await getAcceptingRunners(root, normalized, runners);
       if (accepting.some((runner) => runner.kind === "e2e")) {
         hasActiveE2eRef = true;
@@ -7542,7 +7834,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_promises7.readFile)((0, import_node_path8.join)(root, node.path), "utf-8"));
+    const acs = parseAcceptanceCriteria(await (0, import_promises7.readFile)((0, import_node_path9.join)(root, node.path), "utf-8"));
     featureAcMap.set(node.code, new Set(acs));
   }
   const coveredAcByFeature = /* @__PURE__ */ new Map();
@@ -7584,7 +7876,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   };
 }
 async function generateE2eRegistry(root, opts) {
-  const e2eDir = (0, import_node_path8.join)(root, "artifacts", "tests", "e2e");
+  const e2eDir = (0, import_node_path9.join)(root, "artifacts", "tests", "e2e");
   let files;
   try {
     files = (await (0, import_promises7.readdir)(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
@@ -7600,11 +7892,11 @@ async function generateE2eRegistry(root, opts) {
   const batches = [];
   let totalTestCases = 0;
   for (const file of files) {
-    const filePath = (0, import_node_path8.join)(e2eDir, file);
+    const filePath = (0, import_node_path9.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_path8.basename)(file, (0, import_node_path8.extname)(file))).trim();
+    const batch = String(data.test_batch ?? (0, import_node_path9.basename)(file, (0, import_node_path9.extname)(file))).trim();
     const relPath = `artifacts/tests/e2e/${file}`;
     const scope = String(data.scope ?? "").trim();
     const acCoverage = normalizeAcCoverageForRegistry(data.ac_coverage);
@@ -7728,7 +8020,7 @@ 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_path8.join)(root, normalizedPath);
+    const fullPath = (0, import_node_path9.join)(root, normalizedPath);
     let content;
     try {
       content = await (0, import_promises7.readFile)(fullPath, "utf-8");
@@ -7765,7 +8057,7 @@ function detectTestLevel(specFile, content) {
 }
 function resolveExecutableRefFile(refFile, allFiles) {
   const normalized = refFile.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (!normalized || (0, import_node_path8.isAbsolute)(refFile) || normalized.split("/").includes("..")) {
+  if (!normalized || (0, import_node_path9.isAbsolute)(refFile) || normalized.split("/").includes("..")) {
     return void 0;
   }
   if (allFiles.includes(normalized)) {
@@ -7840,7 +8132,7 @@ function escapeRegExp(value) {
 }
 async function hasMarkdownTc(tcKey, e2eDir) {
   const [batch, tcId] = tcKey.split(":");
-  const filePath = (0, import_node_path8.join)(e2eDir, `${batch}.md`);
+  const filePath = (0, import_node_path9.join)(e2eDir, `${batch}.md`);
   try {
     const raw = await (0, import_promises7.readFile)(filePath, "utf-8");
     const tcRegex = new RegExp(`^#{2,3}\\s+${escapeRegExp(tcId)}\\s*[:\uFF1A]?`, "m");
@@ -8073,7 +8365,7 @@ function normalizeDesignCode(value) {
   if (!raw) {
     return "";
   }
-  return (0, import_node_path8.basename)(raw, (0, import_node_path8.extname)(raw));
+  return (0, import_node_path9.basename)(raw, (0, import_node_path9.extname)(raw));
 }
 function toUid(type, code) {
   return `${type}:${code}`;
@@ -8338,10 +8630,10 @@ function resolveArtifactContext(graph, opts) {
     }
     if (root) {
       for (const ap of ALWAYS_PRESENT_ITEMS) {
-        const fullPath = (0, import_node_path8.join)(root, ap.path);
+        const fullPath = (0, import_node_path9.join)(root, ap.path);
         let stat;
         try {
-          stat = (0, import_node_fs4.statSync)(fullPath);
+          stat = (0, import_node_fs5.statSync)(fullPath);
         } catch {
           stat = null;
         }
@@ -8371,7 +8663,7 @@ function resolveArtifactContext(graph, opts) {
           }
         } else {
           try {
-            (0, import_node_fs4.accessSync)(fullPath, import_node_fs4.constants.R_OK);
+            (0, import_node_fs5.accessSync)(fullPath, import_node_fs5.constants.R_OK);
           } catch {
             const msg = `Required baseline artifact is not readable: ${ap.path}`;
             if (!missing.includes(msg)) {
@@ -8568,15 +8860,14 @@ function formatContextMarkdown(manifest) {
   }
   return lines.join("\n");
 }
-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, EMPTY_RELATION_FIELD_VALUES, VALID_TC_STATUSES, VALID_CHAIN_TYPES, DEPRECATED_CHAIN_TYPE_ALIASES, CONTEXT_CATEGORIES, TIER_ORDER;
+var import_gray_matter, import_js_yaml, import_node_fs5, import_promises7, import_node_path9, TARGET_ARTIFACT_TYPES, NON_TARGET_ROLES, DEFAULT_SCHEMA, EMPTY_RELATION_FIELD_VALUES, 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_node_fs5 = require("fs");
     import_promises7 = require("fs/promises");
-    import_node_path8 = require("path");
+    import_node_path9 = require("path");
     init_packet_constants();
     init_packet_validator();
     init_glob_matcher();