@fenglimg/fabric-cli 2.0.0-rc.15 → 2.0.0-rc.22

package/dist/chunk-KZ2YITOS.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import {
+  resolveClients
+} from "./chunk-MF3OTILQ.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/config.ts
+import { existsSync, statSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { cancel, intro, isCancel, log, outro, select, text } from "@clack/prompts";
+import { getPanelFields } from "@fenglimg/fabric-shared";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+import { defineCommand } from "citty";
+async function loadFabricConfig(workspaceRoot) {
+  const configPath = resolve(workspaceRoot, "fabric.config.json");
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  const parsed = JSON.parse(await readFile(configPath, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
+  }
+  return parsed;
+}
+function resolveServerPath(override) {
+  if (override) return override;
+  if (process.env.FAB_SERVER_PATH) return resolve(process.env.FAB_SERVER_PATH);
+  return fileURLToPath(import.meta.resolve("@fenglimg/fabric-server"));
+}
+var PANEL_CONFIG_RELATIVE_PATH = [".fabric", "fabric-config.json"];
+var EXIT_CHOICE = "__exit__";
+var configCmd = defineCommand({
+  meta: {
+    name: "config",
+    description: t("cli.config.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.config.args.target.description"),
+      valueHint: "path"
+    }
+  },
+  async run({ args }) {
+    const workspaceRoot = resolve(args.target ?? process.cwd());
+    const configPath = join(workspaceRoot, ...PANEL_CONFIG_RELATIVE_PATH);
+    const fabricDir = join(workspaceRoot, ".fabric");
+    const fabricDirOk = existsSync(fabricDir) && statSync(fabricDir).isDirectory();
+    const configOk = fabricDirOk && existsSync(configPath);
+    if (!configOk) {
+      console.error(t("cli.config.errors.uninit-workspace.message"));
+      process.exitCode = 1;
+      return;
+    }
+    if (!isInteractiveConfig()) {
+      console.log(t("cli.config.intro"));
+      console.log(t("cli.config.non-tty-notice"));
+      return;
+    }
+    intro(t("cli.config.intro"));
+    let edited = false;
+    while (true) {
+      const current = await readPanelConfig(configPath);
+      const fields = getPanelFields();
+      const fieldChoice = await select({
+        message: t("cli.config.menu.field-select"),
+        options: [
+          ...fields.map((field2) => ({
+            value: field2.key,
+            label: formatFieldMenuLabel(field2, current)
+          })),
+          { value: EXIT_CHOICE, label: t("cli.config.menu.exit") }
+        ]
+      });
+      if (isCancel(fieldChoice)) {
+        cancel(t("cli.config.cancel"));
+        return;
+      }
+      if (fieldChoice === EXIT_CHOICE) {
+        outro(edited ? t("cli.config.outro") : t("cli.config.outro-no-changes"));
+        return;
+      }
+      const field = fields.find((f) => f.key === fieldChoice);
+      if (!field) {
+        log.warn(t("cli.config.errors.unknown-field"));
+        continue;
+      }
+      const newValue = await promptFieldValue(field, current);
+      if (newValue === CANCELLED) {
+        cancel(t("cli.config.cancel"));
+        return;
+      }
+      if (newValue === SKIPPED) {
+        continue;
+      }
+      try {
+        const refreshed = await readPanelConfig(configPath);
+        const merged = { ...refreshed, [field.key]: newValue };
+        await atomicWriteJson(configPath, merged);
+        edited = true;
+        log.success(
+          t("cli.config.write.success", {
+            key: field.key,
+            value: field.format_for_display(newValue)
+          })
+        );
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log.error(t("cli.config.write.failure", { message }));
+      }
+    }
+  }
+});
+var config_default = configCmd;
+var CANCELLED = /* @__PURE__ */ Symbol("config-cancelled");
+var SKIPPED = /* @__PURE__ */ Symbol("config-skipped");
+async function promptFieldValue(field, current) {
+  const currentValue = current[field.key];
+  const currentDisplay = field.format_for_display(currentValue);
+  if (field.widget === "select") {
+    const enumValues = field.enum_values ?? [];
+    if (enumValues.length === 0) {
+      log.warn(t("cli.config.errors.no-enum-options"));
+      return SKIPPED;
+    }
+    const initialValue = enumValues.includes(String(currentValue)) ? String(currentValue) : enumValues.includes(String(field.default)) ? String(field.default) : enumValues[0];
+    const picked = await select({
+      message: t("cli.config.prompt.select", {
+        key: field.key,
+        current: currentDisplay
+      }),
+      options: enumValues.map((value) => ({ value, label: value })),
+      initialValue
+    });
+    if (isCancel(picked)) {
+      return CANCELLED;
+    }
+    const result = field.validate(String(picked));
+    if (!result.ok) {
+      log.error(result.error);
+      return SKIPPED;
+    }
+    return result.value;
+  }
+  const entered = await text({
+    message: t("cli.config.prompt.text", {
+      key: field.key,
+      current: currentDisplay
+    }),
+    placeholder: currentDisplay,
+    initialValue: currentDisplay,
+    validate(raw) {
+      const result = field.validate(raw ?? "");
+      return result.ok ? void 0 : result.error;
+    }
+  });
+  if (isCancel(entered)) {
+    return CANCELLED;
+  }
+  const finalResult = field.validate(String(entered));
+  if (!finalResult.ok) {
+    log.error(finalResult.error);
+    return SKIPPED;
+  }
+  return finalResult.value;
+}
+function formatFieldMenuLabel(field, current) {
+  const key = field.key;
+  const rawValue = current[key];
+  const display = field.format_for_display(rawValue);
+  const isDefault = rawValue === void 0 || rawValue === null;
+  const labelText = t(field.label_i18n_key);
+  const valueLabel = isDefault ? `${display} ${t("cli.config.value.default-marker")}` : display;
+  return `[${field.group}] ${key} (${labelText}) \u2014 ${t("cli.config.value.current", { value: valueLabel })}`;
+}
+async function readPanelConfig(configPath) {
+  const raw = await readFile(configPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
+  }
+  return parsed;
+}
+function isInteractiveConfig() {
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+}
+async function installMcpClients(target, options = {}) {
+  const workspaceRoot = resolve(target);
+  const fabricConfig = await loadFabricConfig(workspaceRoot);
+  const selectedClients = options.clients === void 0 ? null : new Set(options.clients);
+  const serverPath = resolveServerPath(options.localServerPath);
+  const writers = resolveClients(workspaceRoot, fabricConfig, { claudeMcpScope: options.claudeMcpScope }).filter(
+    (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
+  );
+  const installed = [];
+  const skipped = [];
+  const details = [];
+  for (const writer of writers) {
+    const configPath = await writer.detect(workspaceRoot);
+    if (configPath === null) {
+      skipped.push(writer.clientKind);
+      details.push({ client: writer.clientKind, path: null, action: "skipped" });
+      continue;
+    }
+    if (options.dryRun) {
+      skipped.push(writer.clientKind);
+      details.push({ client: writer.clientKind, path: configPath, action: "dry-run" });
+      continue;
+    }
+    await writer.write(serverPath, workspaceRoot);
+    installed.push(writer.clientKind);
+    details.push({ client: writer.clientKind, path: configPath, action: "wrote" });
+  }
+  return { installed, skipped, details };
+}
+
+export {
+  configCmd,
+  config_default,
+  installMcpClients
+};

package/dist/{chunk-SKSYUHKK.js → chunk-MF3OTILQ.js}

@@ -479,7 +479,6 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
       clientKind: "ClaudeCodeCLI",
       label: "Claude Code CLI",
       detected: claudeDetected || hasExplicitPath(clientPaths, "claudeCodeCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
       configPath: "project .claude/settings.json",
       capabilities: {
         bootstrap: true,
@@ -496,7 +495,6 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
       clientKind: "ClaudeCodeDesktop",
       label: "Claude Code Desktop",
       detected: claudeDesktopDetected || hasExplicitPath(clientPaths, "claudeCodeDesktop"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
       configPath: "desktop Claude config",
       capabilities: {
         bootstrap: true,
@@ -509,7 +507,6 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
       clientKind: "Cursor",
       label: "Cursor",
       detected: cursorDetected || hasExplicitPath(clientPaths, "cursor"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
       configPath: ".cursor/mcp.json",
       capabilities: {
         bootstrap: true,
@@ -522,7 +519,6 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
       clientKind: "CodexCLI",
       label: "Codex CLI",
       detected: codexDetected || hasExplicitPath(clientPaths, "codexCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
       configPath: "~/.codex/config.toml",
       capabilities: {
         bootstrap: true,

package/dist/{chunk-AXIFEVAS.js → chunk-PSVKSMRO.js}

@@ -4,12 +4,12 @@ import {
 } from "./chunk-6ICJICVU.js";
 import {
   readFabricConfig
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-ZSESMG6L.js";
 
 // src/commands/scan.ts
 import { createHash } from "crypto";
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { mkdir, readFile } from "fs/promises";
+import { mkdir, readFile, unlink } from "fs/promises";
 import { dirname, isAbsolute, join, resolve } from "path";
 import {
   KnowledgeIdAllocator,
@@ -25,6 +25,30 @@ var SCAN_STATE_FILE = ".scan-state.json";
 var FORENSIC_FILE = ".fabric/forensic.json";
 var AGENTS_META_FILE = ".fabric/agents.meta.json";
 var LAYER_REASON = "project artifact (deterministic init scan)";
+var KNOWN_BASELINE_IDS = /* @__PURE__ */ new Set([
+  "KT-MOD-0001",
+  // tech-stack
+  "KT-MOD-0002",
+  // module-structure
+  "KT-MOD-0003",
+  // readme-first-paragraph
+  "KT-PRO-0001",
+  // build-config
+  "KT-PRO-0002",
+  // ci-config (allocated after build-config in the deterministic order)
+  "KT-GLD-0001"
+  // code-style
+]);
+var KNOWN_BASELINE_SLUGS = /* @__PURE__ */ new Set([
+  "tech-stack",
+  "module-structure",
+  "build-config",
+  "code-style",
+  "ci-config",
+  "readme-first-paragraph",
+  "project-brief"
+]);
+var ID_PREFIXED_FILENAME_PATTERN = /^KT-[A-Z]+-\d+--.+\.md$/u;
 async function runInitScan(targetInput, options = {}) {
   const startTs = Date.now();
   const target = normalizeTarget(targetInput);
@@ -32,20 +56,20 @@ async function runInitScan(targetInput, options = {}) {
   if (!existsSync(forensicPath)) {
     throw new Error(t("cli.scan.error.missing-forensic", { path: forensicPath }));
   }
+  await migrateLegacyBaselineFilenames(target);
   const forensic = await readForensic(forensicPath);
   const nowIso = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const tags = deriveTagsFromForensic(forensic);
   const fabricConfig = readFabricConfig(target);
   const fabricLanguage = fabricConfig.fabric_language ?? "match-existing";
   const resolvedLanguage = resolveFabricLanguage(fabricLanguage, target);
   const candidates = [
-    buildTechStackEntry(forensic, nowIso, tags, resolvedLanguage),
-    buildModuleStructureEntry(forensic, nowIso, tags, resolvedLanguage),
-    buildBuildConfigEntry(forensic, nowIso, tags, resolvedLanguage),
-    buildCodeStyleEntry(forensic, nowIso, tags, resolvedLanguage),
-    buildCIConfigEntry(forensic, nowIso, tags),
-    buildReadmeFirstParaEntry(target, forensic, nowIso, tags, resolvedLanguage),
-    buildProjectBriefEntry(target, forensic, nowIso, tags)
+    buildTechStackEntry(forensic, nowIso, resolvedLanguage),
+    buildModuleStructureEntry(forensic, nowIso, resolvedLanguage),
+    buildBuildConfigEntry(forensic, nowIso, resolvedLanguage),
+    buildCodeStyleEntry(forensic, nowIso, resolvedLanguage),
+    buildCIConfigEntry(forensic, nowIso),
+    buildReadmeFirstParaEntry(target, forensic, nowIso, resolvedLanguage),
+    buildProjectBriefEntry(target, forensic, nowIso)
   ];
   const entries = candidates.filter((e) => e !== null);
   const sidecarPath = join(target, KNOWLEDGE_DIR, SCAN_STATE_FILE);
@@ -55,11 +79,12 @@ async function runInitScan(targetInput, options = {}) {
   const skipped = [];
   const placedEntries = [];
   for (const entry of entries) {
-    const targetPath = join(target, KNOWLEDGE_DIR, entry.target_subdir, `${entry.slug}.md`);
-    const existingId = findExistingIdForFile(sidecar, targetPath, target);
+    const subdirAbs = join(target, KNOWLEDGE_DIR, entry.target_subdir);
+    const existingId = findExistingIdBySlug(sidecar, subdirAbs, entry.slug);
     const id = existingId ?? await allocator.allocate(entry.layer, entry.type);
     const built = { ...entry, id };
     placedEntries.push(built);
+    const targetPath = join(subdirAbs, `${id}--${entry.slug}.md`);
     const fullContent = renderMarkdown(built);
     const bodyHash = sha256(stripFrontmatter(fullContent));
     const sidecarKey = id;
@@ -303,7 +328,7 @@ function detectExistingLanguage(target) {
   const ratio = cjkCount / denominator;
   return ratio > ZH_CN_RATIO_THRESHOLD ? "zh-CN-hybrid" : "en";
 }
-function buildTechStackEntry(forensic, nowIso, tags, language = "en") {
+function buildTechStackEntry(forensic, nowIso, language = "en") {
   const framework = forensic.framework;
   const byExt = forensic.topology.by_ext ?? {};
   const topExtensions = Object.entries(byExt).sort(([, a], [, b]) => b - a).slice(0, 5).map(([ext, count]) => `${ext} (${count})`);
@@ -330,12 +355,12 @@ function buildTechStackEntry(forensic, nowIso, tags, language = "en") {
     body,
     target_subdir: "models",
     slug: "tech-stack",
-    tags,
+    tags: [],
     relevance_scope: "narrow",
     relevance_paths: relevancePaths
   };
 }
-function buildModuleStructureEntry(forensic, nowIso, tags, language = "en") {
+function buildModuleStructureEntry(forensic, nowIso, language = "en") {
   const keyDirs = forensic.topology.key_dirs ?? [];
   const entryPoints = forensic.entry_points ?? [];
   const totalFiles = forensic.topology.total_files ?? 0;
@@ -361,12 +386,12 @@ function buildModuleStructureEntry(forensic, nowIso, tags, language = "en") {
     body,
     target_subdir: "models",
     slug: "module-structure",
-    tags,
+    tags: [],
     relevance_scope: "narrow",
     relevance_paths: relevancePaths
   };
 }
-function buildBuildConfigEntry(forensic, nowIso, tags, language = "en") {
+function buildBuildConfigEntry(forensic, nowIso, language = "en") {
   const configFiles = (forensic.candidate_files ?? []).filter((entry) => entry.family === "config").map((entry) => entry.path);
   const framework = forensic.framework.kind;
   const configBlock = configFiles.length > 0 ? configFiles.map((file) => `- ${file}`).join("\n") : "- (no config files detected)";
@@ -389,12 +414,12 @@ function buildBuildConfigEntry(forensic, nowIso, tags, language = "en") {
     body,
     target_subdir: "processes",
     slug: "build-config",
-    tags,
+    tags: [],
     relevance_scope: "narrow",
     relevance_paths: relevancePaths
   };
 }
-function buildCodeStyleEntry(forensic, nowIso, tags, language = "en") {
+function buildCodeStyleEntry(forensic, nowIso, language = "en") {
   const dominantPatterns = (forensic.assertions ?? []).filter((a) => a.type === "pattern" || a.type === "domain").slice(0, 4).map((a) => `- ${a.statement}`);
   const proposedRules = (forensic.assertions ?? []).map((a) => a.proposed_rule).filter((rule) => typeof rule === "string" && rule.length > 0).slice(0, 4);
   const patternsBlock = dominantPatterns.length > 0 ? dominantPatterns.join("\n") : "- (no dominant patterns detected)";
@@ -424,12 +449,12 @@ function buildCodeStyleEntry(forensic, nowIso, tags, language = "en") {
     body,
     target_subdir: "guidelines",
     slug: "code-style",
-    tags,
+    tags: [],
     relevance_scope: "narrow",
     relevance_paths: relevancePaths
   };
 }
-function buildCIConfigEntry(forensic, nowIso, tags) {
+function buildCIConfigEntry(forensic, nowIso) {
   const ciFiles = (forensic.candidate_files ?? []).map((entry) => entry.path).filter((path) => isCIConfigPath(path));
   const ciExtensions = forensic.topology.by_ext ?? {};
   const hasCISignal = ciFiles.length > 0 || Object.keys(ciExtensions).some((ext) => ext === ".yml" || ext === ".yaml") && (forensic.assertions ?? []).some((a) => /ci|workflow|pipeline/i.test(a.statement));
@@ -466,12 +491,12 @@ function buildCIConfigEntry(forensic, nowIso, tags) {
     body,
     target_subdir: "processes",
     slug: "ci-config",
-    tags,
+    tags: [],
     relevance_scope: "narrow",
     relevance_paths: relevancePaths
   };
 }
-function buildReadmeFirstParaEntry(target, forensic, nowIso, tags, language = "en") {
+function buildReadmeFirstParaEntry(target, forensic, nowIso, language = "en") {
   if (forensic.readme.quality === "missing") {
     return null;
   }
@@ -501,7 +526,7 @@ function buildReadmeFirstParaEntry(target, forensic, nowIso, tags, language = "e
     body,
     target_subdir: "models",
     slug: "readme-first-paragraph",
-    tags,
+    tags: [],
     // v2.0-rc.7 T2: broad by design — single repo-root file, the Phase 1.5
     // PreToolUse blacklist already covers README. Anchoring this entry to
     // README.md would surface it on every README edit, which is noise.
@@ -509,7 +534,7 @@ function buildReadmeFirstParaEntry(target, forensic, nowIso, tags, language = "e
     relevance_paths: []
   };
 }
-function buildProjectBriefEntry(target, forensic, nowIso, tags) {
+function buildProjectBriefEntry(target, forensic, nowIso) {
   if (forensic.readme.quality === "missing") {
     return null;
   }
@@ -541,7 +566,7 @@ function buildProjectBriefEntry(target, forensic, nowIso, tags) {
     body,
     target_subdir: "models",
     slug: "project-brief",
-    tags,
+    tags: [],
     // v2.0-rc.7 T2: broad — project brief is a cross-cutting description
     // with no path anchor. Narrowing it to README.md would duplicate the
     // readme-first-paragraph surface; keeping it broad lets the
@@ -603,47 +628,6 @@ function quoteIfNeeded(value) {
 function stripFrontmatter(content) {
   return content.replace(/^---[\s\S]*?\r?\n---\s*\r?\n?/u, "");
 }
-function deriveTagsFromForensic(forensic) {
-  const MAX_TAGS = 5;
-  const seen = /* @__PURE__ */ new Set();
-  const tags = [];
-  function add(raw) {
-    const normalized = raw.toLowerCase().trim().replace(/\s+/gu, "-");
-    if (normalized.length > 0 && !seen.has(normalized)) {
-      seen.add(normalized);
-      tags.push(normalized);
-    }
-  }
-  if (forensic.framework.kind) {
-    add(forensic.framework.kind);
-  }
-  const SKIP_EXTS = /* @__PURE__ */ new Set([".json", ".md", ".lock", ".yaml", ".yml", ".txt", ".env"]);
-  const EXT_MAP = {
-    ".ts": "typescript",
-    ".tsx": "typescript",
-    ".js": "javascript",
-    ".jsx": "javascript",
-    ".mjs": "javascript",
-    ".cjs": "javascript",
-    ".py": "python",
-    ".go": "go",
-    ".rs": "rust",
-    ".java": "java",
-    ".cs": "csharp",
-    ".rb": "ruby",
-    ".php": "php",
-    ".swift": "swift",
-    ".kt": "kotlin"
-  };
-  const byExt = forensic.topology.by_ext ?? {};
-  const sorted = Object.entries(byExt).filter(([ext]) => !SKIP_EXTS.has(ext)).sort(([, a], [, b]) => b - a);
-  for (const [ext] of sorted) {
-    if (tags.length >= MAX_TAGS) break;
-    const mapped = EXT_MAP[ext] ?? ext.replace(/^\./u, "");
-    add(mapped);
-  }
-  return tags.slice(0, MAX_TAGS);
-}
 async function readForensic(forensicPath) {
   const raw = await readFile(forensicPath, "utf8");
   return JSON.parse(raw);
@@ -669,29 +653,143 @@ async function readScanState(sidecarPath) {
     return {};
   }
 }
-function findExistingIdForFile(sidecar, targetPath, target) {
-  if (!existsSync(targetPath)) {
+async function migrateLegacyBaselineFilenames(target) {
+  const knowledgeRoot = join(target, KNOWLEDGE_DIR);
+  if (!existsSync(knowledgeRoot)) {
+    return { migrated: [] };
+  }
+  const migrated = [];
+  const subdirs = ["models", "guidelines", "processes"];
+  for (const sub of subdirs) {
+    const subdirPath = join(knowledgeRoot, sub);
+    if (!existsSync(subdirPath)) continue;
+    let entries;
+    try {
+      entries = readdirSync(subdirPath);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (!name.endsWith(".md")) continue;
+      if (ID_PREFIXED_FILENAME_PATTERN.test(name)) {
+        const idMatch = /^(KT-[A-Z]+-\d+)--(.+)\.md$/u.exec(name);
+        if (idMatch === null) continue;
+        const [, fileId, fileSlug] = idMatch;
+        if (!KNOWN_BASELINE_IDS.has(fileId)) continue;
+        if (!KNOWN_BASELINE_SLUGS.has(fileSlug)) continue;
+        const onDiskPath = join(subdirPath, name);
+        let onDiskRaw;
+        try {
+          onDiskRaw = readFileSync(onDiskPath, "utf8");
+        } catch {
+          continue;
+        }
+        const scrubbed = stripStaleTagsLine(onDiskRaw);
+        if (scrubbed !== onDiskRaw) {
+          await atomicWriteText(onDiskPath, scrubbed);
+        }
+        continue;
+      }
+      const bareSlug = name.slice(0, -".md".length);
+      if (!KNOWN_BASELINE_SLUGS.has(bareSlug)) continue;
+      const oldPath = join(subdirPath, name);
+      let raw;
+      try {
+        raw = readFileSync(oldPath, "utf8");
+      } catch {
+        continue;
+      }
+      const id = extractFrontmatterId(raw);
+      if (id === null || !KNOWN_BASELINE_IDS.has(id)) continue;
+      const newName = `${id}--${bareSlug}.md`;
+      const newPath = join(subdirPath, newName);
+      const cleanedRaw = stripStaleTagsLine(raw);
+      if (existsSync(newPath)) {
+        try {
+          await unlink(oldPath);
+        } catch {
+        }
+        continue;
+      }
+      await atomicWriteText(newPath, cleanedRaw);
+      try {
+        await unlink(oldPath);
+      } catch {
+      }
+      migrated.push({ from: oldPath, to: newPath, id });
+    }
+  }
+  return { migrated };
+}
+function stripStaleTagsLine(raw) {
+  const fmMatch = /^(---\r?\n)([\s\S]*?)(\r?\n---\s*(?:\r?\n|$))/u.exec(raw);
+  if (fmMatch === null) return raw;
+  const head = fmMatch[1];
+  const body = fmMatch[2];
+  const tail = fmMatch[3];
+  const rest = raw.slice(fmMatch[0].length);
+  const flowPattern = /^tags:[ \t]*\[[^\n]*\][ \t]*$/mu;
+  if (flowPattern.test(body)) {
+    const replaced = body.replace(flowPattern, "tags: []");
+    return `${head}${replaced}${tail}${rest}`;
+  }
+  const blockPattern = /^tags:[ \t]*\r?\n(?:[ \t]+-[ \t]+.+\r?\n?)+/mu;
+  if (blockPattern.test(body)) {
+    const replaced = body.replace(blockPattern, "tags: []\n");
+    return `${head}${replaced.replace(/\n{2,}$/u, "\n")}${tail}${rest}`;
+  }
+  const barePattern = /^tags:[ \t]*$/mu;
+  if (barePattern.test(body)) {
+    const replaced = body.replace(barePattern, "tags: []");
+    return `${head}${replaced}${tail}${rest}`;
+  }
+  return raw;
+}
+function extractFrontmatterId(raw) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/u.exec(raw);
+  if (match === null) return null;
+  const idLine = /^id:\s*(.+)$/mu.exec(match[1]);
+  if (idLine === null) return null;
+  return idLine[1].replace(/^["'](.*)["']$/u, "$1").trim();
+}
+function findExistingIdBySlug(sidecar, subdirAbs, slug) {
+  if (!existsSync(subdirAbs)) {
     return null;
   }
+  let entries;
   try {
-    const raw = readFileSync(targetPath, "utf8");
-    const match = /^---\r?\n([\s\S]*?)\r?\n---/u.exec(raw);
-    if (match === null) {
-      return null;
-    }
-    const idLine = /^id:\s*(.+)$/mu.exec(match[1]);
-    if (idLine === null) {
+    entries = readdirSync(subdirAbs);
+  } catch {
+    return null;
+  }
+  const escapedSlug = slug.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const pattern = new RegExp(`^(KT-[A-Z]+-\\d+)--${escapedSlug}\\.md$`, "u");
+  const matches = [];
+  for (const name of entries) {
+    const m = pattern.exec(name);
+    if (m === null) continue;
+    matches.push({ id: m[1], file: name });
+  }
+  if (matches.length !== 1) {
+    return null;
+  }
+  const filenameId = matches[0].id;
+  try {
+    const raw = readFileSync(join(subdirAbs, matches[0].file), "utf8");
+    const frontmatterId = extractFrontmatterId(raw);
+    if (frontmatterId !== filenameId) {
       return null;
     }
-    const candidate = idLine[1].replace(/^["'](.*)["']$/u, "$1").trim();
-    if (/^K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d{4,}$/.test(candidate) && sidecar[candidate] !== void 0) {
-      return candidate;
-    }
-    return null;
   } catch {
-    void target;
     return null;
   }
+  if (!/^K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d{4,}$/u.test(filenameId)) {
+    return null;
+  }
+  if (sidecar[filenameId] === void 0) {
+    return null;
+  }
+  return filenameId;
 }
 function isCIConfigPath(path) {
   return path.startsWith(".github/workflows/") || path.startsWith(".gitlab-ci") || path === "azure-pipelines.yml" || path === ".circleci/config.yml" || path === "Jenkinsfile" || path === ".travis.yml";
@@ -759,7 +857,7 @@ async function registerKnowledgeNodesInMeta(target, entries) {
   }
   const nodes = typeof meta.nodes === "object" && meta.nodes !== null ? meta.nodes : {};
   for (const entry of entries) {
-    const contentRef = `${KNOWLEDGE_DIR}/${entry.target_subdir}/${entry.slug}.md`;
+    const contentRef = `${KNOWLEDGE_DIR}/${entry.target_subdir}/${entry.id}--${entry.slug}.md`;
     const absPath = join(target, contentRef);
     let hash = "";
     try {

package/dist/{chunk-OBQU6NHO.js → chunk-ZSESMG6L.js}

@@ -16,13 +16,10 @@ function readFabricConfig(workspaceRoot = process.cwd()) {
 }
 function resolveDevMode(cliTarget, workspaceRoot = process.cwd()) {
   const envTarget = normalizeTarget(process.env.EXTERNAL_FIXTURE_PATH, workspaceRoot);
-  const fabricConfig = readFabricConfig(workspaceRoot);
-  const configTarget = normalizeTarget(fabricConfig.externalFixturePath, workspaceRoot);
   const directTarget = normalizeTarget(cliTarget, workspaceRoot);
   const chain = [
     formatResolutionStep("cliTarget", directTarget),
     formatResolutionStep("EXTERNAL_FIXTURE_PATH", envTarget),
-    formatResolutionStep("fabric.config.json.externalFixturePath", configTarget),
     formatResolutionStep("process.cwd()", workspaceRoot)
   ];
   if (directTarget !== void 0) {
@@ -31,9 +28,6 @@ function resolveDevMode(cliTarget, workspaceRoot = process.cwd()) {
   if (envTarget !== void 0) {
     return { target: envTarget, source: "env", chain };
   }
-  if (configTarget !== void 0) {
-    return { target: configTarget, source: "config", chain };
-  }
   return { target: workspaceRoot, source: "cwd", chain };
 }
 function createDebugLogger(debug) {