artifact-graph 0.9.3 → 0.10.0

package/dist/cli.js

@@ -2649,11 +2649,215 @@ var init_versioned_traceability = __esm({
   }
 });
 
+// src/native-binding-diagnostics.ts
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath } from "url";
+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 () => createRequire(installBase)("better-sqlite3");
+}
+function defaultBindingLoaderImpl() {
+  const base = typeof __filename === "string" ? __filename : import.meta.url;
+  return 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 = dirname2(anchorFile);
+  for (; ; ) {
+    if (existsSync2(join4(dir, "package.json"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function runningArtifactGraphInstallRoot() {
+  const anchor = typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
+  return findPackageRoot(anchor);
+}
+function structuredNativeBindingError(failure, context = {}) {
+  return {
+    error: "native_binding_unavailable",
+    stage: failure.failedStage,
+    cause: failure.cause,
+    detail: failure.detail,
+    suggestion: failure.suggestion,
+    doctorHint: "artifact-graph doctor --format json",
+    // F-10-P01/F-10-P03：机器读取错误包络也暴露实际探测来源，使 scan/query
+    // 与 doctor 的分类依据（同一运行安装根）可被自动测试断言。
+    probedFrom: context.probedFrom ?? "(current artifact-graph package)"
+  };
+}
+function renderStructuredNativeBindingError(failure, context = {}) {
+  return `${JSON.stringify(structuredNativeBindingError(failure, context), null, 2)}
+`;
+}
+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 = join4(root, "node_modules", "better-sqlite3", "package.json");
+  if (existsSync2(direct)) return true;
+  const pnpmDir = join4(root, "node_modules", ".pnpm");
+  let entries;
+  try {
+    entries = readdirSync(pnpmDir);
+  } catch {
+    return false;
+  }
+  return entries.some((entry) => {
+    if (!entry.startsWith("better-sqlite3@")) return false;
+    return existsSync2(join4(pnpmDir, entry, "node_modules", "better-sqlite3", "package.json"));
+  });
+}
+var PNPM_ALLOW_BUILDS_SNIPPET;
+var init_native_binding_diagnostics = __esm({
+  "src/native-binding-diagnostics.ts"() {
+    "use strict";
+    PNPM_ALLOW_BUILDS_SNIPPET = "pnpm-workspace.yaml:\nallowBuilds:\n  better-sqlite3: true";
+  }
+});
+
 // src/cli-resolver.ts
 import { execFile } from "child_process";
-import { constants } from "fs";
+import { constants, readFileSync, realpathSync } from "fs";
 import { access } from "fs/promises";
-import { isAbsolute, join as join4, resolve } from "path";
+import { basename, dirname as dirname3, isAbsolute, join as join5, resolve } from "path";
 import { promisify } from "util";
 async function resolveArtifactGraphCli(root, options = {}) {
   const pathCli = await findCommandOnPath("artifact-graph");
@@ -2661,7 +2865,7 @@ async function resolveArtifactGraphCli(root, options = {}) {
   const candidates = [
     {
       source: "node_modules",
-      path: join4(root, "node_modules/.bin/artifact-graph"),
+      path: join5(root, "node_modules/.bin/artifact-graph"),
       exists: false
     },
     {
@@ -2694,13 +2898,33 @@ async function resolveArtifactGraphCli(root, options = {}) {
 }
 async function doctorArtifactChain(root, options = {}) {
   const cli = await resolveArtifactGraphCli(root, options);
-  const configPath = join4(root, "artifact-graph.config.yaml");
-  const lockPath = join4(root, VERSION_LOCK_PATH);
+  const configPath = join5(root, "artifact-graph.config.yaml");
+  const lockPath = join5(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",
@@ -2719,6 +2943,7 @@ async function doctorArtifactChain(root, options = {}) {
       path: lockPath,
       exists: await pathExists(lockPath)
     },
+    nativeBinding,
     supportedCommands,
     warnings
   };
@@ -2734,6 +2959,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) {
@@ -2790,11 +3040,71 @@ function isNodeCompatible(version) {
   const major = Number(version.split(".")[0]);
   return Number.isFinite(major) && major >= 22;
 }
+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 join5(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 (basename(dirname3(real)) !== ".bin") return real;
+  const shimTarget = readBinShimTarget(real);
+  return shimTarget ? safeRealpath(shimTarget) : real;
+}
+function readBinShimTarget(shimPath) {
+  let content;
+  try {
+    content = 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 resolve(dirname3(shimPath), match[1]);
+}
+function safeRealpath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
 var execFileAsync, KNOWN_COMMANDS;
 var init_cli_resolver = __esm({
   "src/cli-resolver.ts"() {
     "use strict";
     init_versioned_traceability();
+    init_native_binding_diagnostics();
     execFileAsync = promisify(execFile);
     KNOWN_COMMANDS = [
       "init",
@@ -2813,6 +3123,7 @@ var init_cli_resolver = __esm({
       "version-lock refresh",
       "trace-version",
       "next-id",
+      "refactor-id",
       "render",
       "doctor"
     ];
@@ -2920,7 +3231,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 join5 } from "path";
+import { basename as basename2, dirname as dirname4, join as join6 } from "path";
 function detectHookInterpreter(content) {
   if (content.trim().length === 0) {
     return "empty";
@@ -3227,8 +3538,8 @@ async function removeHookAtomically(hookPath, snapshot) {
   }
 }
 async function writeHookAtomically(hookPath, content, snapshot, mode) {
-  await mkdir3(dirname2(hookPath), { recursive: true });
-  const temporaryPath = join5(dirname2(hookPath), `.${basename(hookPath)}.${randomUUID()}.tmp`);
+  await mkdir3(dirname4(hookPath), { recursive: true });
+  const temporaryPath = join6(dirname4(hookPath), `.${basename2(hookPath)}.${randomUUID()}.tmp`);
   let temporaryExists = false;
   try {
     const temporary = await open(temporaryPath, "wx", mode);
@@ -3694,7 +4005,7 @@ __export(contract_kernel_exports, {
 });
 import { createHash as createHash2 } from "crypto";
 import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import _AjvModule from "ajv";
 function isOfficialNamespace(namespace) {
   return OFFICIAL_NAMESPACE_PATTERN.test(namespace);
@@ -4107,7 +4418,7 @@ async function loadContractsFromDirectory(contractsDir, options) {
   const entries = await readdir2(contractsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const schemaPath = join6(contractsDir, entry.name, "schema.json");
+      const schemaPath = join7(contractsDir, entry.name, "schema.json");
       const contract = await loadContract(schemaPath, options);
       contracts.push(contract);
     }
@@ -4595,12 +4906,11 @@ var init_contract_kernel = __esm({
 });
 
 // src/index.ts
-import Database from "better-sqlite3";
 import matter from "gray-matter";
 import yaml from "js-yaml";
-import { accessSync, constants as fsConstants, existsSync as existsSync2, statSync } from "fs";
+import { accessSync, constants as fsConstants, existsSync as existsSync3, statSync } from "fs";
 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";
+import { basename as basename4, dirname as dirname5, extname, isAbsolute as isAbsolute3, join as join8, relative as relative3, resolve as resolve3 } from "path";
 function isTargetArtifactType(type) {
   return isPacketTargetType(type);
 }
@@ -4642,7 +4952,7 @@ function resolveArtifactTypeName(schema, token) {
   return void 0;
 }
 async function loadConfig(root) {
-  const configPath = join7(root, "artifact-graph.config.yaml");
+  const configPath = join8(root, "artifact-graph.config.yaml");
   let parsed = {};
   try {
     const raw = await readFile3(configPath, "utf-8");
@@ -4819,7 +5129,7 @@ async function scanArtifacts(root, schema) {
         continue;
       }
       scannedFiles.set(file, type);
-      const raw = await readFile3(join7(root, file), "utf-8");
+      const raw = await readFile3(join8(root, file), "utf-8");
       const parsed = parseFile(type, file, raw, config);
       nodes.push(...parsed.nodes);
       edges.push(...parsed.edges);
@@ -5132,7 +5442,7 @@ async function validateScenarioPrdLinkIndex(root, graph) {
   const indexPath = "artifacts/prd/feature-index.md";
   let raw = "";
   try {
-    raw = await readFile3(join7(root, indexPath), "utf-8");
+    raw = await readFile3(join8(root, indexPath), "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -5322,11 +5632,12 @@ function nextId(graph, schema, type, rangeName) {
   throw new Error(`ID range ${type}.${rangeName} is exhausted`);
 }
 async function writeGraphCache(root, graph) {
-  const cacheDir = join7(root, ".artifact-graph");
+  const cacheDir = join8(root, ".artifact-graph");
   await mkdir4(cacheDir, { recursive: true });
-  await writeFile3(join7(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
+  await writeFile3(join8(cacheDir, "index.json"), `${JSON.stringify(graph, null, 2)}
 `);
-  const db = new Database(join7(cacheDir, "graph.sqlite"));
+  const { default: Database } = await import("better-sqlite3");
+  const db = new Database(join8(cacheDir, "graph.sqlite"));
   try {
     db.exec(`
       DROP TABLE IF EXISTS nodes;
@@ -5680,7 +5991,7 @@ function parseDecisions(path, raw) {
 }
 function isTestFile(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const name = basename3(normalized);
+  const name = basename4(normalized);
   if (/\.(test|spec)\.[^.]+$/.test(name)) return true;
   if (/(^|\/)(tests|test|__tests__)\//.test(normalized)) return true;
   if (/\w+Tests?\.java$/.test(name)) return true;
@@ -6001,7 +6312,7 @@ function parseE2eTest(path, raw) {
   });
   const nodes = [];
   const edges = [];
-  const batch = String(data.test_batch ?? basename3(path, extname(path))).trim();
+  const batch = String(data.test_batch ?? basename4(path, extname(path))).trim();
   const frontmatterScenarios = toArray(data.related_scenarios).map((value) => String(value).trim()).filter(Boolean);
   const scopeFeatures = extractCodes(String(data.scope ?? ""), "feature");
   const frontmatterFeatures = [.../* @__PURE__ */ new Set([...Object.keys(asRecord(data.ac_coverage)), ...scopeFeatures])];
@@ -6074,7 +6385,7 @@ function parseE2eRegistry(path, raw) {
     data = { parseError: error.message };
   }
   return {
-    nodes: [{ type: "e2e_registry", code: basename3(path, extname(path)), title: "E2E Test Registry", path, line: 1, attrs: data }],
+    nodes: [{ type: "e2e_registry", code: basename4(path, extname(path)), title: "E2E Test Registry", path, line: 1, attrs: data }],
     edges: []
   };
 }
@@ -7100,10 +7411,10 @@ function validateE2eRegistry(graph) {
 async function validateExecutableTraceability(root, config) {
   const issues = [];
   const schema = config ?? await loadConfig(root);
-  const e2eDir = join7(root, "artifacts", "tests", "e2e");
+  const e2eDir = join8(root, "artifacts", "tests", "e2e");
   let e2eFiles;
   try {
-    e2eFiles = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join7(e2eDir, name));
+    e2eFiles = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join8(e2eDir, name));
   } catch {
     return [];
   }
@@ -7116,7 +7427,7 @@ async function validateExecutableTraceability(root, config) {
     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();
+    const batch = String(data.test_batch ?? basename4(filePath, extname(filePath))).trim();
     const lines = raw.split(/\r?\n/);
     const tcStarts = [];
     lines.forEach((line, index) => {
@@ -7161,7 +7472,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 = join7(root, specFile);
+    const fullSpecPath = join8(root, specFile);
     let content;
     try {
       content = await readFile3(fullSpecPath, "utf-8");
@@ -7243,7 +7554,7 @@ async function validateExecutableTraceability(root, config) {
       if (entry.testId) {
         let content;
         try {
-          content = await readFile3(join7(root, normalizedRefFile), "utf-8");
+          content = await readFile3(join8(root, normalizedRefFile), "utf-8");
         } catch {
           continue;
         }
@@ -7420,11 +7731,11 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   let withExecutableRef = 0;
   const statusBreakdown = {};
   const chainTypeBreakdown = {};
-  const e2eDir = join7(root, "artifacts", "tests", "e2e");
+  const e2eDir = join8(root, "artifacts", "tests", "e2e");
   const tcFieldsMap = /* @__PURE__ */ new Map();
   let e2eFiles;
   try {
-    e2eFiles = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join7(e2eDir, name));
+    e2eFiles = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).map((name) => join8(e2eDir, name));
   } catch {
     e2eFiles = [];
   }
@@ -7439,7 +7750,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
       }
     });
     const parsed = matter(raw);
-    const batch = String(parsed.data.test_batch ?? basename3(filePath, extname(filePath))).trim();
+    const batch = String(parsed.data.test_batch ?? basename4(filePath, extname(filePath))).trim();
     for (let i = 0; i < tcStarts.length; i++) {
       const start = tcStarts[i];
       const end = tcStarts[i + 1]?.index ?? lines.length;
@@ -7502,7 +7813,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(join7(root, normalized))) continue;
+      if (!normalized || !existsSync3(join8(root, normalized))) continue;
       const accepting = await getAcceptingRunners(root, normalized, runners);
       if (accepting.some((runner) => runner.kind === "e2e")) {
         hasActiveE2eRef = true;
@@ -7561,7 +7872,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   const acCoverageRateByFeature = {};
   const featureAcMap = /* @__PURE__ */ new Map();
   for (const node of featureNodes) {
-    const acs = parseAcceptanceCriteria(await readFile3(join7(root, node.path), "utf-8"));
+    const acs = parseAcceptanceCriteria(await readFile3(join8(root, node.path), "utf-8"));
     featureAcMap.set(node.code, new Set(acs));
   }
   const coveredAcByFeature = /* @__PURE__ */ new Map();
@@ -7603,7 +7914,7 @@ async function computeE2eCoverageStats(graph, root, thresholds = {}) {
   };
 }
 async function generateE2eRegistry(root, opts) {
-  const e2eDir = join7(root, "artifacts", "tests", "e2e");
+  const e2eDir = join8(root, "artifacts", "tests", "e2e");
   let files;
   try {
     files = (await readdir3(e2eDir)).filter((name) => /^test-.*\.md$/.test(name)).sort();
@@ -7619,11 +7930,11 @@ async function generateE2eRegistry(root, opts) {
   const batches = [];
   let totalTestCases = 0;
   for (const file of files) {
-    const filePath = join7(e2eDir, file);
+    const filePath = join8(e2eDir, file);
     const raw = await readFile3(filePath, "utf-8");
     const parsed = matter(raw);
     const data = parsed.data;
-    const batch = String(data.test_batch ?? basename3(file, extname(file))).trim();
+    const batch = String(data.test_batch ?? basename4(file, extname(file))).trim();
     const relPath = `artifacts/tests/e2e/${file}`;
     const scope = String(data.scope ?? "").trim();
     const acCoverage = normalizeAcCoverageForRegistry(data.ac_coverage);
@@ -7747,7 +8058,7 @@ async function validatePartialRustEvidence(tcFields, tcKey, root, allFiles) {
     if (!normalizedPath) {
       return { hasValidPartialRust: false, detail: `partial_rust file not found: ${ref.file}` };
     }
-    const fullPath = join7(root, normalizedPath);
+    const fullPath = join8(root, normalizedPath);
     let content;
     try {
       content = await readFile3(fullPath, "utf-8");
@@ -7859,7 +8170,7 @@ function escapeRegExp(value) {
 }
 async function hasMarkdownTc(tcKey, e2eDir) {
   const [batch, tcId] = tcKey.split(":");
-  const filePath = join7(e2eDir, `${batch}.md`);
+  const filePath = join8(e2eDir, `${batch}.md`);
   try {
     const raw = await readFile3(filePath, "utf-8");
     const tcRegex = new RegExp(`^#{2,3}\\s+${escapeRegExp(tcId)}\\s*[:\uFF1A]?`, "m");
@@ -8092,7 +8403,7 @@ function normalizeDesignCode(value) {
   if (!raw) {
     return "";
   }
-  return basename3(raw, extname(raw));
+  return basename4(raw, extname(raw));
 }
 function toUid(type, code) {
   return `${type}:${code}`;
@@ -8357,14 +8668,14 @@ function resolveArtifactContext(graph, opts) {
     }
     if (root) {
       for (const ap of ALWAYS_PRESENT_ITEMS) {
-        const fullPath = join7(root, ap.path);
-        let stat;
+        const fullPath = join8(root, ap.path);
+        let stat2;
         try {
-          stat = statSync(fullPath);
+          stat2 = statSync(fullPath);
         } catch {
-          stat = null;
+          stat2 = null;
         }
-        if (!stat) {
+        if (!stat2) {
           const msg = `Required baseline artifact not found: ${ap.path}`;
           if (!missing.includes(msg)) {
             missing.push(msg);
@@ -8376,7 +8687,7 @@ function resolveArtifactContext(graph, opts) {
               suggestedAction: `\u521B\u5EFA\u6587\u4EF6 ${ap.path} \u6216\u914D\u7F6E\u8DF3\u8FC7 universal baseline`
             });
           }
-        } else if (!stat.isFile()) {
+        } else if (!stat2.isFile()) {
           const msg = `Required baseline artifact is not a regular file: ${ap.path}`;
           if (!missing.includes(msg)) {
             missing.push(msg);
@@ -8700,7 +9011,7 @@ var init_index = __esm({
 
 // src/packet-prompt-audit.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function promptFilename(target) {
   return `prompt-${target.type}-${target.id}.md`;
 }
@@ -8752,7 +9063,7 @@ async function auditSinglePromptTarget(target, graph, options) {
     }
     if (options.outDir) {
       const filename = promptFilename(target);
-      const outPath = join8(options.outDir, filename);
+      const outPath = join9(options.outDir, filename);
       await writeFile4(outPath, prompt, "utf-8");
       entry.outputPath = outPath;
     }
@@ -8858,9 +9169,9 @@ async function auditPromptBatch(root, targets, options, graph) {
   };
   if (options.outDir) {
     await mkdir5(options.outDir, { recursive: true });
-    const jsonPath = join8(options.outDir, "prompt-audit-summary.json");
+    const jsonPath = join9(options.outDir, "prompt-audit-summary.json");
     await writeFile4(jsonPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
-    const mdPath = join8(options.outDir, "prompt-audit-summary.md");
+    const mdPath = join9(options.outDir, "prompt-audit-summary.md");
     await writeFile4(mdPath, renderPromptAuditSummaryMarkdown(summary), "utf-8");
   }
   return summary;
@@ -8894,22 +9205,649 @@ var init_packet_prompt_audit = __esm({
   }
 });
 
+// src/refactor-id.ts
+var refactor_id_exports = {};
+__export(refactor_id_exports, {
+  refactorId: () => refactorId,
+  renderRefactorIdMarkdown: () => renderRefactorIdMarkdown
+});
+import { chmod, readFile as readFile4, rename as rename2, rm, readdir as readdir4, stat, writeFile as writeFile5 } from "fs/promises";
+import { randomBytes } from "crypto";
+import { basename as basename5, dirname as dirname6, join as join10, relative as relative4 } from "path";
+import yaml2 from "js-yaml";
+function escapeRegExp2(value) {
+  return value.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function idTokenPattern(id) {
+  return new RegExp(`(?<![\\w-])${escapeRegExp2(id)}(?![\\w-])`, "g");
+}
+function replaceIdToken(text, oldId, newId) {
+  return text.replace(idTokenPattern(oldId), newId);
+}
+function containsIdToken(text, id) {
+  return idTokenPattern(id).test(text);
+}
+function lineEndingOf(line) {
+  if (line.endsWith("\r\n")) return "\r\n";
+  if (line.endsWith("\n")) return "\n";
+  if (line.endsWith("\r")) return "\r";
+  return "";
+}
+function splitLinesPreserveEndings(text) {
+  const lines = [];
+  const length = text.length;
+  let index = 0;
+  while (index < length) {
+    let cursor = index;
+    while (cursor < length && text[cursor] !== "\r" && text[cursor] !== "\n") cursor += 1;
+    let end = cursor;
+    if (cursor < length) {
+      end = text[cursor] === "\r" && text[cursor + 1] === "\n" ? cursor + 2 : cursor + 1;
+    }
+    lines.push(text.slice(index, end));
+    index = end;
+    if (cursor >= length) break;
+  }
+  return lines;
+}
+function sortEdges(edges) {
+  return edges.map((edge2) => ({ from: edge2.from, to: edge2.to, kind: edge2.kind, source: edge2.source, sourcePath: edge2.sourcePath, sourceLine: edge2.sourceLine })).sort((a, b) => a.sourcePath.localeCompare(b.sourcePath) || a.sourceLine - b.sourceLine || a.from.localeCompare(b.from) || a.kind.localeCompare(b.kind));
+}
+function frontmatterRelationFields(type, config) {
+  const fields = /* @__PURE__ */ new Set();
+  const declared = config.relationFields?.[type];
+  if (declared) {
+    for (const field of declared) {
+      if (!field.startsWith("@")) fields.add(field);
+    }
+  }
+  if (type === "feature") {
+    for (const field of ["scenarios", "decisions", "depends_on", "design_docs"]) fields.add(field);
+  }
+  if (type === "decision") {
+    for (const field of ["related_features", "related_scenarios"]) fields.add(field);
+  }
+  if (type === "design") {
+    for (const field of ["related_features", "related_scenarios", "related_decisions"]) fields.add(field);
+  }
+  if (!declared) {
+    fields.add("related_*");
+  }
+  return fields;
+}
+function fieldWhitelisted(fieldName, whitelist) {
+  if (whitelist.has(fieldName)) return true;
+  if (whitelist.has("related_*") && fieldName.startsWith("related_")) return true;
+  return false;
+}
+function findFrontmatterBlock(lines) {
+  if (lines[0]?.trim() !== "---") return null;
+  for (let index = 1; index < lines.length; index += 1) {
+    if (lines[index].trim() === "---") {
+      return { startLine: 0, endLine: index, text: lines.slice(1, index).join("\n") };
+    }
+  }
+  return null;
+}
+function artifactTypeOfPath(path, config) {
+  for (const [type, definition] of Object.entries(config.types)) {
+    for (const pattern of definition.paths) {
+      if (globLikeMatch(pattern, path)) return type;
+    }
+  }
+  return null;
+}
+function globLikeMatch(pattern, path) {
+  const regex = pattern.split("/").map((segment) => {
+    if (segment === "**") return "<<DOUBLESTAR>>";
+    return segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+  }).join("/");
+  const flattened = regex.replace(/<<DOUBLESTAR>>\//g, "(?:[^/]+/)*").replace(/\/<<DOUBLESTAR>>/g, "(?:/[^/]+)*").replace(/<<DOUBLESTAR>>/g, ".*");
+  return new RegExp(`^${flattened}$`).test(path);
+}
+function planFrontmatterEdits(path, raw, fileType, oldId, newId, config, isOwnFile) {
+  const lines = raw.split(/\r?\n/);
+  const block = findFrontmatterBlock(lines);
+  if (!block) return [];
+  let data;
+  try {
+    const loaded = yaml2.load(block.text);
+    if (typeof loaded !== "object" || loaded === null || Array.isArray(loaded)) return [];
+    data = loaded;
+  } catch {
+    return [];
+  }
+  const whitelist = frontmatterRelationFields(fileType, config);
+  const edits = [];
+  let currentField = null;
+  let inEligibleField = false;
+  const eligibleByValue = /* @__PURE__ */ new Set();
+  for (const [fieldName, fieldValue] of Object.entries(data)) {
+    if (fieldName === "title" || fieldName === "status") continue;
+    if (fieldName === "id") continue;
+    if (!fieldWhitelisted(fieldName, whitelist)) continue;
+    const serialized = JSON.stringify(fieldValue ?? null);
+    if (containsIdToken(serialized.replace(/\\u/g, "u"), oldId) || serialized.includes(`"${oldId}"`)) {
+      eligibleByValue.add(fieldName);
+    }
+  }
+  for (let index = block.startLine + 1; index < block.endLine; index += 1) {
+    const line = lines[index];
+    const topLevel = /^([A-Za-z_][\w-]*):(.*)$/.exec(line);
+    if (topLevel) {
+      currentField = topLevel[1];
+      const valueText = topLevel[2];
+      if (currentField === "id" && isOwnFile && valueText.trim().replace(/^["']|["']$/g, "") === oldId) {
+        const newLine = line.replace(valueText, ` ${newId}`);
+        edits.push({ path, line: index + 1, oldLine: line, newLine, kind: "frontmatter-id" });
+        inEligibleField = false;
+        continue;
+      }
+      inEligibleField = currentField !== null && eligibleByValue.has(currentField);
+      if (inEligibleField && containsIdToken(valueText, oldId)) {
+        edits.push({ path, line: index + 1, oldLine: line, newLine: replaceIdToken(line, oldId, newId), kind: "frontmatter-relation" });
+      }
+      continue;
+    }
+    if (!inEligibleField || currentField === null) continue;
+    if (/^\S/.test(line)) {
+      inEligibleField = false;
+      currentField = null;
+      continue;
+    }
+    if (!containsIdToken(line, oldId)) continue;
+    if (currentField === "ac_coverage") {
+      const keyMatch = /^(\s+)([^:\s]+)(\s*[:：].*)$/.exec(line);
+      if (keyMatch && keyMatch[2] === oldId) {
+        edits.push({ path, line: index + 1, oldLine: line, newLine: `${keyMatch[1]}${newId}${keyMatch[3]}`, kind: "frontmatter-relation" });
+      }
+      continue;
+    }
+    edits.push({ path, line: index + 1, oldLine: line, newLine: replaceIdToken(line, oldId, newId), kind: "frontmatter-relation" });
+  }
+  return edits;
+}
+function planE2eBlockEdits(path, raw, oldId, newId) {
+  const lines = raw.split(/\r?\n/);
+  const edits = [];
+  let tcHeadingIndex = -1;
+  lines.forEach((line, index) => {
+    if (/^#{2,3}\s+TC-\d+[a-z]?\s*[:：]?\s*/.test(line)) {
+      tcHeadingIndex = index;
+      return;
+    }
+    if (tcHeadingIndex < 0) return;
+    const field = /^\*\*(覆盖场景|覆盖功能)\*\*\s*[:：]\s*(.*)$/.exec(line);
+    if (field && containsIdToken(line, oldId)) {
+      edits.push({ path, line: index + 1, oldLine: line, newLine: replaceIdToken(line, oldId, newId), kind: "markdown-relation" });
+    }
+  });
+  return edits;
+}
+async function walkTextFiles(root) {
+  const found = [];
+  async function visit(dir) {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && PROSE_SCAN_SKIP_DIRS.has(entry.name)) continue;
+      if (PROSE_SCAN_SKIP_DIRS.has(entry.name)) continue;
+      const full = join10(dir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(full);
+      } else if (entry.isFile()) {
+        const ext = entry.name.includes(".") ? `.${entry.name.split(".").slice(-1)[0]}` : "";
+        if (TEXT_EXTENSIONS.has(ext.toLowerCase())) {
+          found.push(relative4(root, full).replace(/\\/g, "/"));
+        }
+      }
+    }
+  }
+  await visit(root);
+  return found.sort();
+}
+async function computeLockImpact(root, type, oldId) {
+  const lockPath = join10(root, VERSION_LOCK_PATH);
+  const impact = {
+    lockPath: VERSION_LOCK_PATH,
+    affectedImplementationLocks: [],
+    affectedRelationLocks: [],
+    suggestion: "artifact-graph version-lock refresh --root . --changed-only --worktree"
+  };
+  let raw;
+  try {
+    raw = await readFile4(lockPath, "utf-8");
+  } catch {
+    return impact;
+  }
+  let lockFile;
+  try {
+    lockFile = JSON.parse(raw);
+  } catch {
+    return impact;
+  }
+  for (const lock of lockFile.locks ?? []) {
+    if (lock.artifact && lock.artifact.type === type && lock.artifact.id === oldId) {
+      impact.affectedImplementationLocks.push(lock.edgeId);
+    }
+  }
+  for (const relation of lockFile.artifactRelations ?? []) {
+    const endpoints = [relation.source, relation.target];
+    if (endpoints.some((endpoint) => endpoint && endpoint.type === type && endpoint.id === oldId)) {
+      impact.affectedRelationLocks.push(relation.edgeId);
+    }
+  }
+  impact.affectedImplementationLocks.sort();
+  impact.affectedRelationLocks.sort();
+  return impact;
+}
+async function refactorId(options) {
+  const root = options.root;
+  const fail = (code, message, details) => ({
+    ok: false,
+    error: { code, message, ...details !== void 0 ? { details } : {} }
+  });
+  const colonIndex = options.from.indexOf(":");
+  const config = await loadConfig(root);
+  if (colonIndex <= 0) {
+    const graph2 = await scanArtifacts(root, config);
+    const candidates = graph2.nodes.filter((node) => node.code === options.from).map((node) => `${node.type}:${node.code}`);
+    if (candidates.length === 0) {
+      return fail("TARGET_MISSING", `\u65E7\u6807\u8BC6 "${options.from}" \u4E0D\u5B58\u5728\uFF1B--from \u5FC5\u987B\u4F7F\u7528\u7CBE\u786E type:id \u5F62\u5F0F`);
+    }
+    return fail("BARE_ID_AMBIGUOUS", `--from \u5FC5\u987B\u4F7F\u7528\u7CBE\u786E type:id \u5F62\u5F0F\uFF1B\u88F8\u7F16\u53F7 "${options.from}" \u5019\u9009\uFF1A${candidates.join(", ")}`, { candidates });
+  }
+  const typeToken = options.from.slice(0, colonIndex);
+  const oldId = options.from.slice(colonIndex + 1);
+  const resolvedType = resolveArtifactTypeName(config, typeToken);
+  if (!resolvedType) {
+    return fail("UNKNOWN_TYPE", `\u672A\u77E5\u5236\u54C1\u7C7B\u578B "${typeToken}"`);
+  }
+  if (!oldId) {
+    return fail("TARGET_MISSING", `--from \u7F3A\u5C11 ID \u90E8\u5206\uFF1A${options.from}`);
+  }
+  if (resolvedType !== "feature" && resolvedType !== "decision" && resolvedType !== "scenario") {
+    return fail(
+      "UNSUPPORTED_RENAME_TARGET",
+      `\u9996\u7248\u53EA\u652F\u6301 frontmatter/\u8282\u6807\u9898\u627F\u8F7D ID \u7684\u7C7B\u578B\u6539\u540D\uFF08feature/decision/scenario\uFF09\uFF1B${resolvedType} \u7684 ID \u7531\u8DEF\u5F84\u6D3E\u751F\uFF0C\u6539\u540D\u7B49\u4EF7\u4E8E\u6587\u4EF6\u6539\u540D\uFF0C\u4E0D\u5728\u9996\u7248\u8303\u56F4`
+    );
+  }
+  const newId = options.to.trim();
+  if (!newId || newId.includes(":")) {
+    return fail("INVALID_NEW_ID", "--to \u5FC5\u987B\u662F\u4E0D\u542B\u7C7B\u578B\u524D\u7F00\u7684\u65B0\u7F16\u53F7");
+  }
+  const idPattern = config.idPatterns?.[resolvedType];
+  if (idPattern && !new RegExp(idPattern).test(newId)) {
+    return fail("INVALID_NEW_ID", `\u65B0 ID "${newId}" \u4E0D\u7B26\u5408 ${resolvedType} \u7684 idPattern\uFF1A${idPattern}`);
+  }
+  if (newId === oldId) {
+    return fail("INVALID_NEW_ID", "\u65B0 ID \u4E0E\u65E7 ID \u76F8\u540C");
+  }
+  const graph = await scanArtifacts(root, config);
+  const oldUid = `${resolvedType}:${oldId}`;
+  const newUid = `${resolvedType}:${newId}`;
+  const oldNode = graph.nodes.find((node) => node.uid === oldUid);
+  if (!oldNode) {
+    return fail("TARGET_MISSING", `\u65E7\u6807\u8BC6 ${oldUid} \u5728\u56FE\u4E2D\u4E0D\u5B58\u5728`);
+  }
+  if (graph.nodes.some((node) => node.uid === newUid)) {
+    return fail("ID_CONFLICT", `\u65B0 ID ${newUid} \u5728\u56FE\u4E2D\u5DF2\u5B58\u5728`);
+  }
+  const incoming = graph.edges.filter((edge2) => edge2.to === oldUid);
+  const outgoing = graph.edges.filter((edge2) => edge2.from === oldUid);
+  const edits = [];
+  const fileContents = /* @__PURE__ */ new Map();
+  const readArtifactFile = async (path) => {
+    if (!fileContents.has(path)) {
+      fileContents.set(path, await readFile4(join10(root, path), "utf-8"));
+    }
+    return fileContents.get(path);
+  };
+  if (resolvedType === "scenario") {
+    const raw = await readArtifactFile(oldNode.path);
+    const lines = raw.split(/\r?\n/);
+    const headingIndex = lines.findIndex((line) => {
+      const match = /^#{2,3}\s+(S-\d+[a-z]?)\s*[:：]/.exec(line);
+      return match !== null && match[1] === oldId;
+    });
+    if (headingIndex < 0) {
+      return fail("PLAN_DRIFT", `\u573A\u666F ${oldUid} \u7684\u8282\u6807\u9898\u5728 ${oldNode.path} \u4E2D\u672A\u627E\u5230`);
+    }
+    edits.push({
+      path: oldNode.path,
+      line: headingIndex + 1,
+      oldLine: lines[headingIndex],
+      newLine: replaceIdToken(lines[headingIndex], oldId, newId),
+      kind: "frontmatter-id"
+    });
+  } else {
+    edits.push(...planFrontmatterEdits(oldNode.path, await readArtifactFile(oldNode.path), resolvedType, oldId, newId, config, true));
+  }
+  const frontmatterTargets = /* @__PURE__ */ new Set();
+  const lineEditsByFile = /* @__PURE__ */ new Map();
+  for (const edge2 of incoming) {
+    if (edge2.source === "frontmatter") {
+      frontmatterTargets.add(edge2.sourcePath);
+      continue;
+    }
+    const lines = lineEditsByFile.get(edge2.sourcePath) ?? /* @__PURE__ */ new Set();
+    lines.add(edge2.sourceLine);
+    lineEditsByFile.set(edge2.sourcePath, lines);
+  }
+  for (const path of [...frontmatterTargets].sort()) {
+    if (path === oldNode.path) continue;
+    const fileType = artifactTypeOfPath(path, config) ?? resolvedType;
+    edits.push(...planFrontmatterEdits(path, await readArtifactFile(path), fileType, oldId, newId, config, false));
+  }
+  for (const [path, lineNumbers] of [...lineEditsByFile.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const raw = await readArtifactFile(path);
+    const lines = raw.split(/\r?\n/);
+    const isE2eFile = artifactTypeOfPath(path, config) === "e2e_test";
+    if (isE2eFile) {
+      edits.push(...planE2eBlockEdits(path, raw, oldId, newId));
+      for (const lineNumber of [...lineNumbers].sort((a, b) => a - b)) {
+        const line = lines[lineNumber - 1];
+        if (line === void 0) continue;
+        if (/^#{2,3}\s+TC-\d+/.test(line)) continue;
+        if (containsIdToken(line, oldId)) {
+          edits.push({ path, line: lineNumber, oldLine: line, newLine: replaceIdToken(line, oldId, newId), kind: "markdown-relation" });
+        }
+      }
+      continue;
+    }
+    for (const lineNumber of [...lineNumbers].sort((a, b) => a - b)) {
+      const line = lines[lineNumber - 1];
+      if (line === void 0 || !containsIdToken(line, oldId)) continue;
+      const isComment = /^\s*(\/\/|<!--)/.test(line);
+      edits.push({
+        path,
+        line: lineNumber,
+        oldLine: line,
+        newLine: replaceIdToken(line, oldId, newId),
+        kind: isComment ? "traceability-comment" : "markdown-relation"
+      });
+    }
+  }
+  edits.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line);
+  const structuredPositions = new Set(edits.map((edit) => `${edit.path}:${edit.line}`));
+  const proseHits = [];
+  const approveSet = new Set((options.approveProse ?? []).map((entry) => entry.trim()));
+  for (const relativePath of await walkTextFiles(root)) {
+    if (relativePath === VERSION_LOCK_PATH) continue;
+    if (relativePath === "artifact-graph.config.yaml") continue;
+    const raw = await readFile4(join10(root, relativePath), "utf-8");
+    if (!containsIdToken(raw, oldId)) continue;
+    const lines = raw.split(/\r?\n/);
+    lines.forEach((line, index) => {
+      if (!containsIdToken(line, oldId)) return;
+      if (structuredPositions.has(`${relativePath}:${index + 1}`)) return;
+      proseHits.push({ path: relativePath, line: index + 1, context: line.trim().slice(0, 160), approved: false });
+    });
+  }
+  proseHits.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line);
+  const proseKeys = new Set(proseHits.map((hit) => `${hit.path}:${hit.line}`));
+  const unknownApprovals = [...approveSet].filter((entry) => entry && !proseKeys.has(entry)).sort();
+  if (unknownApprovals.length > 0) {
+    return fail("APPROVE_PROSE_MISMATCH", "--approve-prose \u5305\u542B\u4E0E\u5B9E\u9645 prose \u547D\u4E2D\u4E0D\u5339\u914D\u7684\u6761\u76EE", { unknownApprovals });
+  }
+  for (const hit of proseHits) {
+    hit.approved = approveSet.has(`${hit.path}:${hit.line}`);
+    if (hit.approved) {
+      const raw = await readArtifactFile(hit.path);
+      const oldLine = raw.split(/\r?\n/)[hit.line - 1] ?? "";
+      edits.push({
+        path: hit.path,
+        line: hit.line,
+        oldLine,
+        newLine: replaceIdToken(oldLine, oldId, newId),
+        kind: "prose-approved"
+      });
+    }
+  }
+  edits.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line);
+  const lockImpact = await computeLockImpact(root, resolvedType, oldId);
+  const targetFiles = [...new Set(edits.map((edit) => edit.path))].sort();
+  const plan = {
+    from: oldUid,
+    to: newUid,
+    type: resolvedType,
+    oldSummary: { type: resolvedType, id: oldId, title: oldNode.title, status: oldNode.status, path: oldNode.path },
+    targetFiles,
+    edits,
+    incomingEdges: sortEdges(incoming),
+    outgoingEdges: sortEdges(outgoing),
+    proseHits,
+    lockImpact
+  };
+  if (!options.apply) {
+    return { ok: true, mode: "dry-run", plan };
+  }
+  const newContents = /* @__PURE__ */ new Map();
+  for (const path of targetFiles) {
+    const original = fileContents.has(path) ? fileContents.get(path) : await readArtifactFile(path);
+    const linesWithEndings = splitLinesPreserveEndings(original);
+    const fileEdits = edits.filter((edit) => edit.path === path);
+    for (const edit of fileEdits) {
+      const currentIndex = edit.line - 1;
+      const element = linesWithEndings[currentIndex];
+      if (element === void 0) {
+        return fail("PLAN_DRIFT", `\u8BA1\u5212\u4E0E\u6587\u4EF6\u5185\u5BB9\u4E0D\u4E00\u81F4\uFF08apply \u4E2D\u6B62\uFF0C\u96F6\u5199\u5165\uFF09\uFF1A${path}:${edit.line}`, { path, line: edit.line });
+      }
+      const ending = lineEndingOf(element);
+      const content = element.slice(0, element.length - ending.length);
+      if (content !== edit.oldLine) {
+        return fail("PLAN_DRIFT", `\u8BA1\u5212\u4E0E\u6587\u4EF6\u5185\u5BB9\u4E0D\u4E00\u81F4\uFF08apply \u4E2D\u6B62\uFF0C\u96F6\u5199\u5165\uFF09\uFF1A${path}:${edit.line}`, { path, line: edit.line });
+      }
+      linesWithEndings[currentIndex] = `${edit.newLine}${ending}`;
+    }
+    const updated = linesWithEndings.join("");
+    for (const edit of fileEdits) {
+      const applied = updated.split(/\r?\n/)[edit.line - 1];
+      if (containsIdToken(applied ?? "", oldId)) {
+        return fail("WHITELIST_RESIDUE", `\u767D\u540D\u5355\u4F4D\u7F6E\u66FF\u6362\u6821\u9A8C\u5931\u8D25\uFF08apply \u4E2D\u6B62\uFF0C\u96F6\u5199\u5165\uFF09\uFF1A${path}:${edit.line}`);
+      }
+    }
+    newContents.set(path, updated);
+  }
+  if (options.__beforeWriteVerify) await options.__beforeWriteVerify();
+  for (const path of targetFiles) {
+    const disk = await readFile4(join10(root, path), "utf-8");
+    if (disk !== fileContents.get(path)) {
+      return fail("PLAN_DRIFT", `\u8BA1\u5212\u4E0E\u5199\u5165\u4E4B\u95F4\u76EE\u6807\u6587\u4EF6\u53D1\u751F\u53D8\u5316\uFF08apply \u4E2D\u6B62\uFF0C\u96F6\u5199\u5165\uFF09\uFF1A${path}`, { path });
+    }
+  }
+  const written = [];
+  const createdTempPaths = [];
+  let tempSequence = 0;
+  const tempPathFor = options.__tempPathFor ?? ((targetPath) => {
+    tempSequence += 1;
+    const suffix = randomBytes(4).toString("hex");
+    return join10(dirname6(targetPath), `.${basename5(targetPath)}.${process.pid}.${tempSequence}.${suffix}.refactor-id.tmp`);
+  });
+  let stage = "write";
+  try {
+    for (const path of targetFiles) {
+      stage = "write";
+      if (options.__injectWriteFailure?.(path)) {
+        throw Object.assign(new Error(`injected write failure: ${path}`), { code: "EINJECTED" });
+      }
+      const original = fileContents.has(path) ? fileContents.get(path) : await readFile4(join10(root, path), "utf-8");
+      const targetPath = join10(root, path);
+      const originalMode = (await stat(targetPath)).mode & 4095;
+      const tempPath = tempPathFor(targetPath);
+      await writeFile5(tempPath, newContents.get(path), { encoding: "utf-8", flag: "wx" });
+      createdTempPaths.push(tempPath);
+      await chmod(tempPath, originalMode);
+      stage = "rename";
+      if (options.__injectRenameFailure?.(tempPath, targetPath)) {
+        throw Object.assign(new Error(`injected rename failure: ${tempPath} -> ${targetPath}`), { code: "ERENAMEINJECTED" });
+      }
+      await rename2(tempPath, targetPath);
+      written.push({ path, original, originalMode });
+    }
+  } catch (error) {
+    for (const tempPath of createdTempPaths) {
+      await rm(tempPath, { force: true });
+    }
+    const rollbackErrors = [];
+    for (const entry of [...written].reverse()) {
+      try {
+        if (options.__injectRollbackFailure?.(entry.path)) {
+          throw Object.assign(new Error(`injected rollback failure: ${entry.path}`), { code: "EROLLBACKINJECTED" });
+        }
+        await writeFile5(join10(root, entry.path), entry.original, "utf-8");
+        await chmod(join10(root, entry.path), entry.originalMode);
+      } catch (rollbackError) {
+        rollbackErrors.push({ path: entry.path, message: rollbackError.message });
+      }
+    }
+    const failure = error;
+    const writeCode = failure.code === "EEXIST" ? "TEMP_FILE_COLLISION" : stage === "rename" || failure.code === "ERENAMEINJECTED" ? "RENAME_FAILED" : "WRITE_FAILED";
+    if (rollbackErrors.length > 0) {
+      return {
+        ok: false,
+        error: {
+          code: "ROLLBACK_FAILED",
+          message: `apply \u5199\u5165\u5931\u8D25\uFF08${writeCode}\uFF09\u4E14\u56DE\u6EDA\u672A\u5B8C\u5168\u6210\u529F\uFF0C\u9700\u4EBA\u5DE5\u590D\u6838\uFF1A${failure.message}`,
+          details: { writeError: { code: writeCode, message: failure.message }, rollbackErrors }
+        }
+      };
+    }
+    return {
+      ok: false,
+      error: {
+        code: writeCode,
+        message: `apply \u5199\u5165\u5931\u8D25\u5E76\u5DF2\u56DE\u6EDA\uFF1A${failure.message}`,
+        details: { stage }
+      }
+    };
+  }
+  const rescanGraph = await scanArtifacts(root, config);
+  const residue = [
+    ...rescanGraph.nodes.filter((node) => node.uid === oldUid)
+  ];
+  const residueEdges = rescanGraph.edges.filter((edge2) => edge2.to === oldUid || edge2.from === oldUid);
+  const newNodePresent = rescanGraph.nodes.some((node) => node.uid === newUid);
+  const mapEdgeForCompare = (edge2, renameFrom, renameTo) => `${edge2.from === renameFrom ? renameTo : edge2.from}->${edge2.to === renameFrom ? renameTo : edge2.to}:${edge2.kind}:${edge2.source}:${edge2.sourcePath}`;
+  const oldIncomingKeys = sortEdges(incoming).map((edge2) => mapEdgeForCompare(edge2, oldUid, newUid)).sort();
+  const newIncoming = sortEdges(rescanGraph.edges.filter((edge2) => edge2.to === newUid));
+  const newIncomingKeys = newIncoming.map((edge2) => mapEdgeForCompare(edge2, oldUid, newUid)).sort();
+  const incomingDiffs = symmetricDifference(oldIncomingKeys, newIncomingKeys);
+  const oldOutgoingKeys = sortEdges(outgoing).map((edge2) => mapEdgeForCompare(edge2, oldUid, newUid)).sort();
+  const newOutgoing = sortEdges(rescanGraph.edges.filter((edge2) => edge2.from === newUid));
+  const newOutgoingKeys = newOutgoing.map((edge2) => mapEdgeForCompare(edge2, oldUid, newUid)).sort();
+  const outgoingDiffs = symmetricDifference(oldOutgoingKeys, newOutgoingKeys);
+  const structuredResidue = residue.length + residueEdges.length;
+  const rescanResult = {
+    structuredResidue,
+    incomingEquivalence: incomingDiffs.length === 0 ? "equal" : incomingDiffs,
+    outgoingEquivalence: outgoingDiffs.length === 0 ? "equal" : outgoingDiffs,
+    newNodePresent
+  };
+  if (structuredResidue > 0 || incomingDiffs.length > 0 || outgoingDiffs.length > 0 || !newNodePresent) {
+    return {
+      ok: false,
+      error: {
+        code: "RESCAN_FAILED",
+        message: "apply \u5DF2\u5B8C\u6210\u4F46\u6539\u540E\u8BC1\u660E\u672A\u901A\u8FC7\uFF1A\u8BF7\u4EBA\u5DE5\u590D\u6838\u7ED3\u6784\u5316\u6B8B\u7559\u4E0E\u5173\u7CFB\u7B49\u4EF7\u6027",
+        details: rescanResult
+      }
+    };
+  }
+  return { ok: true, mode: "apply", plan, rescan: rescanResult };
+}
+function symmetricDifference(left, right) {
+  const leftSet = new Set(left);
+  const rightSet = new Set(right);
+  const diffs = [];
+  for (const item of leftSet) if (!rightSet.has(item)) diffs.push(`- ${item}`);
+  for (const item of rightSet) if (!leftSet.has(item)) diffs.push(`+ ${item}`);
+  return diffs.sort();
+}
+function renderRefactorIdMarkdown(result) {
+  if (!result.ok) {
+    return [`# refactor-id \u5931\u8D25`, "", `- \u9519\u8BEF\u7801\uFF1A${result.error.code}`, `- \u8BF4\u660E\uFF1A${result.error.message}`, ""].join("\n");
+  }
+  const { plan } = result;
+  const lines = [];
+  lines.push(`# refactor-id ${result.mode === "apply" ? "apply \u62A5\u544A" : "dry-run \u8BA1\u5212"}`);
+  lines.push("");
+  lines.push(`- \u65E7\u6807\u8BC6\uFF1A\`${plan.from}\``);
+  lines.push(`- \u65B0\u6807\u8BC6\uFF1A\`${plan.to}\``);
+  lines.push(`- \u65E7\u6458\u8981\uFF1A${plan.oldSummary.title}\uFF08status: ${plan.oldSummary.status ?? "\u672A\u58F0\u660E"}\uFF0C\u8DEF\u5F84\uFF1A${plan.oldSummary.path}\uFF09`);
+  lines.push("");
+  lines.push(`## \u76EE\u6807\u6587\u4EF6\uFF08${plan.targetFiles.length}\uFF09`);
+  for (const file of plan.targetFiles) lines.push(`- ${file}`);
+  lines.push("");
+  lines.push(`## \u62DF\u8BAE diff\uFF08${plan.edits.length} \u5904\uFF09`);
+  for (const edit of plan.edits) {
+    lines.push(`- ${edit.path}:${edit.line} [${edit.kind}]`);
+    lines.push(`  - \u65E7\uFF1A${edit.oldLine.trim()}`);
+    lines.push(`  - \u65B0\uFF1A${edit.newLine.trim()}`);
+  }
+  lines.push("");
+  lines.push(`## \u5165\u8FB9\uFF08${plan.incomingEdges.length}\uFF09`);
+  for (const edge2 of plan.incomingEdges) lines.push(`- ${edge2.from} --${edge2.kind}--> \uFF08${edge2.sourcePath}:${edge2.sourceLine}\uFF0C\u6765\u6E90 ${edge2.source}\uFF09`);
+  lines.push("");
+  lines.push(`## \u51FA\u8FB9\uFF08${plan.outgoingEdges.length}\uFF09`);
+  for (const edge2 of plan.outgoingEdges) lines.push(`- \uFF08${edge2.sourcePath}\uFF09--${edge2.kind}--> ${edge2.to}`);
+  lines.push("");
+  lines.push(`## prose \u7591\u4F3C\u547D\u4E2D\uFF08${plan.proseHits.length}\uFF0C\u9ED8\u8BA4\u53EA\u62A5\u544A\u4E0D\u66FF\u6362\uFF09`);
+  for (const hit of plan.proseHits) {
+    lines.push(`- ${hit.path}:${hit.line}${hit.approved ? "\uFF08\u5DF2\u6279\u51C6\u66FF\u6362\uFF09" : ""}\uFF1A${hit.context}`);
+  }
+  lines.push("");
+  lines.push("## \u7248\u672C\u9501\u5F71\u54CD");
+  lines.push(`- \u53D7\u5F71\u54CD\u5B9E\u73B0\u9501\uFF1A${plan.lockImpact.affectedImplementationLocks.length} \u6761`);
+  lines.push(`- \u53D7\u5F71\u54CD\u5173\u7CFB\u9501\uFF1A${plan.lockImpact.affectedRelationLocks.length} \u6761`);
+  lines.push(`- \u672C\u547D\u4EE4\u4E0D\u81EA\u52A8\u5237\u65B0\u9501\uFF1Bapply \u6210\u529F\u540E\u8BF7\u4EBA\u5DE5\u5BA1\u67E5\u5E76\u8FD0\u884C\uFF1A\`${plan.lockImpact.suggestion}\``);
+  if (result.mode === "apply" && result.rescan) {
+    lines.push("");
+    lines.push("## \u6539\u540E\u8BC1\u660E");
+    lines.push(`- \u65E7 ID \u7ED3\u6784\u5316\u6B8B\u7559\uFF1A${result.rescan.structuredResidue}`);
+    lines.push(`- \u5165\u8FB9\u96C6\u5408\u7B49\u4EF7\uFF1A${result.rescan.incomingEquivalence === "equal" ? "\u662F" : "\u5426"}`);
+    lines.push(`- \u51FA\u8FB9\u96C6\u5408\u7B49\u4EF7\uFF1A${result.rescan.outgoingEquivalence === "equal" ? "\u662F" : "\u5426"}`);
+    lines.push(`- \u65B0\u8282\u70B9\u5B58\u5728\uFF1A${result.rescan.newNodePresent ? "\u662F" : "\u5426"}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+var TEXT_EXTENSIONS, PROSE_SCAN_SKIP_DIRS;
+var init_refactor_id = __esm({
+  "src/refactor-id.ts"() {
+    "use strict";
+    init_index();
+    TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".ts", ".tsx", ".mts", ".mjs", ".js", ".yaml", ".yml", ".json"]);
+    PROSE_SCAN_SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "coverage", ".tmp", ".codex", ".worktrees", ".qoder", ".agents"]);
+  }
+});
+
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
   runCli: () => runCli
 });
-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 join9 } from "path";
-import { fileURLToPath } from "url";
+import yaml3 from "js-yaml";
+import { realpathSync as realpathSync2 } from "fs";
+import { access as access2, mkdir as mkdir6, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 async function runCli(argv, io = {}) {
   const parsed = parseArgs(argv);
   const cwd = io.cwd ?? process.cwd();
   const out = io.stdout ?? ((chunk) => process.stdout.write(chunk));
   const err = io.stderr ?? ((chunk) => process.stderr.write(chunk));
   const root = String(parsed.flags.root ?? cwd);
+  const sqliteBindingGate = () => {
+    const runningInstallRoot = runningArtifactGraphInstallRoot();
+    const probe = probeNativeBinding(runningInstallRoot ? { installRoot: runningInstallRoot } : {});
+    if (probe.ok) {
+      return void 0;
+    }
+    err(renderStructuredNativeBindingError(probe, {
+      probedFrom: runningInstallRoot ?? "(current artifact-graph package)"
+    }));
+    return 1;
+  };
   try {
     const hasHelpFlag = parsed.flags.help === true || parsed.positional.some((p) => p === "--help" || p === "-h");
     if (parsed.command === "--help" || parsed.command === "-h" || parsed.command === "help" || hasHelpFlag) {
@@ -8919,11 +9857,13 @@ async function runCli(argv, io = {}) {
     switch (parsed.command) {
       case "init": {
         await initConfig(root);
-        out(`Created ${join9(root, "artifact-graph.config.yaml")}
+        out(`Created ${join11(root, "artifact-graph.config.yaml")}
 `);
         return 0;
       }
       case "scan": {
+        const gate = sqliteBindingGate();
+        if (gate !== void 0) return gate;
         const graph = await scanArtifacts(root);
         await writeGraphCache(root, graph);
         out(`Scanned ${graph.nodes.length} artifacts and ${graph.edges.length} relations
@@ -9045,6 +9985,8 @@ async function runCli(argv, io = {}) {
         return issues.some((issue2) => issue2.severity === "error") && !parsed.flags["warning-only"] ? 1 : 0;
       }
       case "query": {
+        const gate = sqliteBindingGate();
+        if (gate !== void 0) return gate;
         const graph = await scanArtifacts(root);
         const result = queryGraph(graph, {
           from: typeof parsed.flags.from === "string" ? parsed.flags.from : void 0,
@@ -9170,7 +10112,7 @@ async function runCli(argv, io = {}) {
           err("\nFix the traceability gaps above before generating an implementation packet.\n");
           if (typeof parsed.flags.out === "string") {
             const errorReport = JSON.stringify({ error: "missing", missing: manifest.missing }, null, 2);
-            await writeFile5(parsed.flags.out, errorReport + "\n");
+            await writeFile6(parsed.flags.out, errorReport + "\n");
           }
           return 1;
         }
@@ -9204,7 +10146,7 @@ async function runCli(argv, io = {}) {
           return 1;
         }
         if (typeof parsed.flags.out === "string") {
-          await writeFile5(parsed.flags.out, output);
+          await writeFile6(parsed.flags.out, output);
           out(`Packet written to ${parsed.flags.out}
 `);
         } else {
@@ -9243,7 +10185,7 @@ async function runCli(argv, io = {}) {
         if (packetJsonPath) {
           let rawJson;
           try {
-            rawJson = await readFile4(packetJsonPath, "utf-8");
+            rawJson = await readFile5(packetJsonPath, "utf-8");
           } catch (readErr) {
             err(`\u9519\u8BEF\uFF1A\u65E0\u6CD5\u8BFB\u53D6 packet \u6587\u4EF6: "${packetJsonPath}" \u2014 ${readErr.message}
 `);
@@ -9333,7 +10275,7 @@ async function runCli(argv, io = {}) {
 `);
         }
         if (typeof parsed.flags.out === "string") {
-          await writeFile5(parsed.flags.out, prompt);
+          await writeFile6(parsed.flags.out, prompt);
           out(`Prompt written to ${parsed.flags.out}
 `);
         } else {
@@ -9444,7 +10386,7 @@ async function runCli(argv, io = {}) {
             universalBaseline: discoverConfig.context?.universal_baseline
           });
         } else {
-          const targetsContent = await readFile4(targetsFile, "utf-8");
+          const targetsContent = await readFile5(targetsFile, "utf-8");
           const auditConfig2 = await loadConfig(root);
           const parseResult = parseTargetsFile(targetsContent, auditConfig2);
           if (parseResult.errors.length > 0) {
@@ -9569,7 +10511,7 @@ async function runCli(argv, io = {}) {
         } else {
           let ppaTargetsContent;
           try {
-            ppaTargetsContent = await readFile4(ppaTargetsFile, "utf-8");
+            ppaTargetsContent = await readFile5(ppaTargetsFile, "utf-8");
           } catch (readErr) {
             err(`\u9519\u8BEF\uFF1A\u65E0\u6CD5\u8BFB\u53D6 targets \u6587\u4EF6: "${ppaTargetsFile}" \u2014 ${readErr.message}
 `);
@@ -9648,7 +10590,7 @@ async function runCli(argv, io = {}) {
         const output = `${JSON.stringify(index, null, 2)}
 `;
         if (typeof parsed.flags.out === "string") {
-          await writeFile5(parsed.flags.out, output);
+          await writeFile6(parsed.flags.out, output);
           out(`Version index written to ${parsed.flags.out}
 `);
         } else {
@@ -9816,8 +10758,8 @@ async function runCli(argv, io = {}) {
         const hooks = hookFlag === "all" ? ["pre-commit", "pre-push"] : [hookFlag];
         const prepared = [];
         for (const hookName of hooks) {
-          const templatePath = fileURLToPath(new URL(`../templates/git-hooks/${hookName}.sh`, import.meta.url));
-          const block = await readFile4(templatePath, "utf-8");
+          const templatePath = fileURLToPath2(new URL(`../templates/git-hooks/${hookName}.sh`, import.meta.url));
+          const block = await readFile5(templatePath, "utf-8");
           prepared.push(await prepareManagedHookBlock({
             hookPath: await resolveGitHookPath(root, hookName),
             block,
@@ -9850,6 +10792,9 @@ async function runCli(argv, io = {}) {
           out(`Forbidden edges: ${config.forbiddenEdges.length}
 `);
         }
+        if (!report.nativeBinding.ok) {
+          return 1;
+        }
         return 0;
       }
       case "validate-review-result": {
@@ -9858,10 +10803,10 @@ async function runCli(argv, io = {}) {
           err("Usage: artifact-graph validate-review-result --file <path> [--format json]\n");
           return 1;
         }
-        const resolvedPath = isAbsolute4(filePath) ? filePath : join9(root, filePath);
+        const resolvedPath = isAbsolute4(filePath) ? filePath : join11(root, filePath);
         let content;
         try {
-          content = await readFile4(resolvedPath, "utf-8");
+          content = await readFile5(resolvedPath, "utf-8");
         } catch (readErr) {
           err(`Error: Cannot read file: "${resolvedPath}" \u2014 ${readErr.message}
 `);
@@ -9896,11 +10841,11 @@ 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 : join9(root, "artifacts/tests/e2e/e2e-test-registry.json");
+        const outPath = typeof parsed.flags.out === "string" ? parsed.flags.out : join11(root, "artifacts/tests/e2e/e2e-test-registry.json");
         if (checkMode) {
           let existing = "";
           try {
-            existing = await readFile4(outPath, "utf-8");
+            existing = await readFile5(outPath, "utf-8");
           } catch {
             err(`Check failed: ${outPath} does not exist or is not readable
 `);
@@ -9916,7 +10861,7 @@ async function runCli(argv, io = {}) {
           return 0;
         }
         if (typeof parsed.flags.out === "string") {
-          await writeFile5(parsed.flags.out, output);
+          await writeFile6(parsed.flags.out, output);
           out(`Registry written to ${parsed.flags.out} (${registry.total_batches} batches, ${registry.total_test_cases} TCs)
 `);
         } else {
@@ -9932,8 +10877,8 @@ 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"] : join9(packageDir, "..", "contracts");
+        const packageDir = dirname7(fileURLToPath2(import.meta.url));
+        const contractsDir = typeof parsed.flags["contracts-dir"] === "string" ? parsed.flags["contracts-dir"] : join11(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);
@@ -10147,7 +11092,7 @@ async function runCli(argv, io = {}) {
           }
           let markdownContent;
           try {
-            markdownContent = await readFile4(markdownPath, "utf-8");
+            markdownContent = await readFile5(markdownPath, "utf-8");
           } catch {
             out(`${JSON.stringify({ ok: false, error: { code: "SCHEMA_VALIDATION_FAILED", path: "/markdown", message: `Could not read markdown file "${markdownPath}"` } }, null, 2)}
 `);
@@ -10168,6 +11113,52 @@ async function runCli(argv, io = {}) {
 `);
         return 1;
       }
+      case "refactor-id": {
+        const { refactorId: refactorId2, renderRefactorIdMarkdown: renderRefactorIdMarkdown2 } = await Promise.resolve().then(() => (init_refactor_id(), refactor_id_exports));
+        if (typeof parsed.flags.format !== "string" && parsed.flags.format !== void 0) {
+          out(`${JSON.stringify({ ok: false, error: { code: "INVALID_FORMAT", path: "/format", message: 'Invalid --format: "" (missing value). Allowed values: json, markdown' } }, null, 2)}
+`);
+          err('Invalid --format: "" (missing value). Allowed values: json, markdown\n');
+          return 1;
+        }
+        const refactorIdFormat = typeof parsed.flags.format === "string" ? parsed.flags.format : "markdown";
+        if (refactorIdFormat !== "json" && refactorIdFormat !== "markdown") {
+          out(`${JSON.stringify({ ok: false, error: { code: "INVALID_FORMAT", path: "/format", message: `Invalid --format: "${refactorIdFormat}". Allowed values: json, markdown` } }, null, 2)}
+`);
+          err(`Invalid --format: "${refactorIdFormat}". Allowed values: json, markdown
+`);
+          return 1;
+        }
+        for (const forbidden of ["force", "all", "recursive"]) {
+          if (parsed.flags[forbidden] !== void 0) {
+            err(`refactor-id \u4E0D\u652F\u6301 --${forbidden}\uFF1A\u9996\u7248\u53EA\u6709\u4E00\u5BF9\u4E00\u6539\u540D\uFF0CD-ACA-29 \u5DF2\u51BB\u7ED3\u547D\u4EE4\u9762
+`);
+            return 1;
+          }
+        }
+        const from = typeof parsed.flags.from === "string" ? parsed.flags.from : "";
+        const to = typeof parsed.flags.to === "string" ? parsed.flags.to : "";
+        if (!from || !to) {
+          err("Usage: artifact-graph refactor-id --from <type:id> --to <new-id> [--apply] [--approve-prose <file:line,...>] [--format json|markdown]\n");
+          return 1;
+        }
+        const approveProse = typeof parsed.flags["approve-prose"] === "string" ? String(parsed.flags["approve-prose"]).split(",").map((entry) => entry.trim()).filter(Boolean) : [];
+        const result = await refactorId2({
+          root,
+          from,
+          to,
+          apply: parsed.flags.apply === true,
+          approveProse,
+          format: refactorIdFormat
+        });
+        if (refactorIdFormat === "json") {
+          out(`${JSON.stringify(result, null, 2)}
+`);
+        } else {
+          out(renderRefactorIdMarkdown2(result));
+        }
+        return result.ok ? 0 : 1;
+      }
       default:
         err(helpText());
         return 1;
@@ -10200,7 +11191,7 @@ function isGraphRelevantPath(path, schema) {
   return path === "artifact-graph.config.yaml" || path === VERSION_LOCK_PATH || matchesConfiguredArtifactPath(path, schema);
 }
 async function initConfig(root) {
-  const configPath = join9(root, "artifact-graph.config.yaml");
+  const configPath = join11(root, "artifact-graph.config.yaml");
   try {
     await access2(configPath);
     throw new Error(`Config already exists: ${configPath}`);
@@ -10210,7 +11201,7 @@ async function initConfig(root) {
     }
   }
   await mkdir6(root, { recursive: true });
-  await writeFile5(configPath, yaml2.dump(DEFAULT_SCHEMA, { lineWidth: 120 }));
+  await writeFile6(configPath, yaml3.dump(DEFAULT_SCHEMA, { lineWidth: 120 }));
 }
 function parseArgs(argv) {
   const [command, ...rest] = argv;
@@ -10268,6 +11259,10 @@ Commands:
   next-id <type> --range <name>
   render [--format mermaid]
   doctor [--format json|markdown]
+  refactor-id --from <type:id> --to <new-id> [--apply] [--approve-prose <file:line,...>] [--format json|markdown]
+      \u5B89\u5168\u5236\u54C1\u6807\u8BC6\u4E00\u5BF9\u4E00\u91CD\u6784\uFF1A\u7F3A\u7701 dry-run \u53EA\u8F93\u51FA\u8BA1\u5212\uFF1B--apply \u4EE5\u5355\u4E00\u4E8B\u52A1\u6539\u5199\u7ED3\u6784\u5316
+      \u767D\u540D\u5355\u4F4D\u7F6E\u5E76\u81EA\u52A8 rescan \u8BC1\u660E\u3002\u9501\u4E0D\u81EA\u52A8\u5237\u65B0\uFF0Capply \u540E\u6309\u63D0\u793A\u8FD0\u884C
+      version-lock refresh --changed-only --worktree\u3002
   validate-review-result --file <path> [--format json]
   generate-e2e-registry [--deterministic] [--out <path>] [--check]
   contract list [--contracts-dir <path>] [--format json]
@@ -10283,7 +11278,7 @@ function isCliEntrypoint(argvPath) {
     return false;
   }
   try {
-    return realpathSync(argvPath) === realpathSync(fileURLToPath(import.meta.url));
+    return realpathSync2(argvPath) === realpathSync2(fileURLToPath2(import.meta.url));
   } catch {
     return false;
   }
@@ -10299,6 +11294,7 @@ var init_cli = __esm({
     init_packet_prompt_validator();
     init_packet_prompt_audit();
     init_cli_resolver();
+    init_native_binding_diagnostics();
     init_review_result_validator();
     init_git_changes();
     init_git_hook_path();