@fenglimg/fabric-cli 2.0.0-rc.13 → 2.0.0-rc.21

package/dist/{chunk-X7QPY5KH.js → chunk-4HC5ZK7H.js}

@@ -1,251 +1,63 @@
 #!/usr/bin/env node
+import {
+  deepMerge
+} from "./chunk-MF3OTILQ.js";
 
-// src/install/skills-and-hooks.ts
-import { chmodSync, existsSync as existsSync2, readFileSync } from "fs";
-import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, join as join2, parse, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-import { atomicWriteJson as atomicWriteJson2, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-
-// src/config/json.ts
-import { existsSync } from "fs";
-import { mkdir, readFile } from "fs/promises";
-import { dirname, join, resolve } from "path";
-import { homedir } from "os";
-import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
-
-// src/config/writer.ts
-function createServerEntry(serverPath) {
-  return {
-    command: process.execPath,
-    args: [serverPath]
-  };
-}
-
-// src/config/json.ts
-function deepMerge(target, source, options = {}) {
-  return deepMergeAtPath(target, source, "", options);
+// src/install/write-bootstrap-snapshot.ts
+import { existsSync, readFileSync } from "fs";
+import { mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+import { BOOTSTRAP_CANONICAL } from "@fenglimg/fabric-shared/templates/bootstrap-canonical";
+var FABRIC_AGENTS_RELPATH = join(".fabric", "AGENTS.md");
+var PROJECT_RULES_RELPATH = join(".fabric", "project-rules.md");
+function fabricAgentsSnapshotPath(targetRoot) {
+  return join(targetRoot, FABRIC_AGENTS_RELPATH);
 }
-function deepMergeAtPath(target, source, path, options) {
-  if (options.arrayAppendPaths && options.arrayAppendPaths.includes(path) && Array.isArray(target) && Array.isArray(source)) {
-    return appendArrayWithDedupe(target, source);
-  }
-  if (target === null || typeof target !== "object" || Array.isArray(target) || source === null || typeof source !== "object" || Array.isArray(source)) {
-    return source;
-  }
-  const out = { ...target };
-  for (const key of Object.keys(source)) {
-    const childPath = path === "" ? key : `${path}.${key}`;
-    out[key] = deepMergeAtPath(
-      target[key],
-      source[key],
-      childPath,
-      options
-    );
-  }
-  return out;
+function projectRulesPath(targetRoot) {
+  return join(targetRoot, PROJECT_RULES_RELPATH);
 }
-function appendArrayWithDedupe(target, source) {
-  const out = [...target];
-  for (const candidate of source) {
-    if (out.some((existing) => isSameHookEntry(existing, candidate))) {
-      continue;
-    }
-    out.push(candidate);
-  }
-  return out;
-}
-function isSameHookEntry(a, b) {
-  const cmdA = extractHookCommand(a);
-  const cmdB = extractHookCommand(b);
-  if (cmdA !== null && cmdB !== null) {
-    return cmdA === cmdB;
-  }
-  return deepEqual(a, b);
+function readProjectRulesIfPresent(targetRoot) {
+  const path = projectRulesPath(targetRoot);
+  if (!existsSync(path)) return null;
+  return readFileSync(path, "utf8");
 }
-function extractHookCommand(item) {
-  if (item === null || typeof item !== "object") {
-    return null;
-  }
-  const obj = item;
-  if (typeof obj.command === "string") {
-    return obj.command;
-  }
-  if (Array.isArray(obj.hooks)) {
-    for (const inner of obj.hooks) {
-      if (inner !== null && typeof inner === "object") {
-        const innerObj = inner;
-        if (typeof innerObj.command === "string") {
-          return innerObj.command;
-        }
+async function writeFabricAgentsSnapshot(targetRoot) {
+  const step = "bootstrap-snapshot";
+  const target = fabricAgentsSnapshotPath(targetRoot);
+  if (existsSync(target)) {
+    try {
+      const existing = readFileSync(target, "utf8");
+      if (existing === BOOTSTRAP_CANONICAL) {
+        return { step, path: target, status: "skipped", message: "up-to-date" };
       }
+    } catch {
     }
   }
-  return null;
-}
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
-    return false;
-  }
-  if (Array.isArray(a) !== Array.isArray(b)) {
-    return false;
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    return a.every((value, index) => deepEqual(value, b[index]));
-  }
-  const aObj = a;
-  const bObj = b;
-  const aKeys = Object.keys(aObj);
-  const bKeys = Object.keys(bObj);
-  if (aKeys.length !== bKeys.length) {
-    return false;
-  }
-  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
-}
-function expandHome(filePath) {
-  if (filePath === "~") {
-    return homedir();
-  }
-  if (filePath.startsWith("~/")) {
-    return join(homedir(), filePath.slice(2));
-  }
-  return filePath;
-}
-function normalizeConfigPath(filePath) {
-  return resolve(expandHome(filePath));
-}
-async function readJsonConfig(configPath) {
-  try {
-    const raw = await readFile(configPath, "utf8");
-    if (raw.trim().length === 0) {
-      return {};
-    }
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error(`Expected JSON object in ${configPath}`);
-    }
-    return parsed;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return {};
-    }
-    throw error;
-  }
-}
-async function writeJsonClientConfig(configPath, serverEntry) {
-  const existing = await readJsonConfig(configPath);
-  const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
-  await mkdir(dirname(configPath), { recursive: true });
-  await atomicWriteJson(configPath, merged, { indent: 2 });
-}
-async function removeJsonClientConfigEntry(configPath, serverName) {
-  if (!existsSync(configPath)) {
-    return { status: "skipped", path: configPath, message: "no-config-file" };
-  }
-  let existing;
-  try {
-    existing = await readJsonConfig(configPath);
-  } catch (error) {
-    return {
-      status: "error",
-      path: configPath,
-      message: error instanceof Error ? error.message : String(error)
-    };
-  }
-  const mcpServers = existing.mcpServers;
-  if (mcpServers === void 0 || mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
-    return { status: "skipped", path: configPath, message: "no-mcp-servers-object" };
-  }
-  const servers = mcpServers;
-  if (!Object.prototype.hasOwnProperty.call(servers, serverName)) {
-    return { status: "skipped", path: configPath, message: "not-present" };
-  }
-  const nextServers = { ...servers };
-  delete nextServers[serverName];
-  const next = { ...existing, mcpServers: nextServers };
-  try {
-    await mkdir(dirname(configPath), { recursive: true });
-    await atomicWriteJson(configPath, next, { indent: 2 });
-    return { status: "removed", path: configPath };
-  } catch (error) {
-    return {
-      status: "error",
-      path: configPath,
-      message: error instanceof Error ? error.message : String(error)
-    };
-  }
+  await mkdir(dirname(target), { recursive: true });
+  await atomicWriteText(target, BOOTSTRAP_CANONICAL);
+  return { step, path: target, status: "written" };
 }
-var JsonClientConfigWriter = class {
-  configuredPath;
-  constructor(configuredPath) {
-    this.configuredPath = configuredPath;
-  }
-  async detect(workspaceRoot, overridePath) {
-    const explicitPath = overridePath ?? this.configuredPath;
-    if (explicitPath !== void 0) {
-      return normalizeConfigPath(explicitPath);
-    }
-    const configPath = this.defaultPath(workspaceRoot);
-    return configPath === null ? null : normalizeConfigPath(configPath);
-  }
-  async write(serverPath, workspaceRoot, overridePath) {
-    const configPath = await this.detect(workspaceRoot, overridePath);
-    if (configPath === null) {
-      return;
-    }
-    await writeJsonClientConfig(configPath, createServerEntry(serverPath));
-  }
-  async remove(serverName, workspaceRoot, overridePath) {
-    const configPath = await this.detect(workspaceRoot, overridePath);
-    if (configPath === null) {
-      return { status: "skipped", message: "no-config-path" };
-    }
-    return removeJsonClientConfigEntry(configPath, serverName);
-  }
-};
-var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
-  clientKind = "ClaudeCodeCLI";
-  scope;
-  constructor(configuredPath, scope = "project") {
-    super(configuredPath);
-    this.scope = scope;
-  }
-  // Writes to project-level .mcp.json (per Claude Code MCP spec) by default,
-  // or ~/.claude.json for user scope.
-  // Detection still checks ~/.claude to confirm Claude Code is installed.
-  defaultPath(workspaceRoot) {
-    const globalClaudeDir = join(homedir(), ".claude");
-    const projectClaudeDir = join(workspaceRoot, ".claude");
-    if (!existsSync(globalClaudeDir) && !existsSync(projectClaudeDir)) {
-      return null;
-    }
-    return this.scope === "user" ? join(homedir(), ".claude.json") : join(workspaceRoot, ".mcp.json");
-  }
-};
-var CursorWriter = class extends JsonClientConfigWriter {
-  clientKind = "Cursor";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const cursorDir = join(workspaceRoot, ".cursor");
-    return existsSync(cursorDir) ? join(cursorDir, "mcp.json") : null;
-  }
-};
 
 // src/install/skills-and-hooks.ts
+import { chmodSync, existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { mkdir as mkdir2, readFile, rm } from "fs/promises";
+import { dirname as dirname2, join as join2, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { atomicWriteJson, atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
+import {
+  BOOTSTRAP_MARKER_BEGIN,
+  BOOTSTRAP_MARKER_END,
+  BOOTSTRAP_REGEX,
+  LEGACY_KB_REGEX
+} from "@fenglimg/fabric-shared/templates/bootstrap-canonical";
 var SKILL_TEMPLATE_REL = "skills/fabric-archive/SKILL.md";
 var SKILL_REVIEW_TEMPLATE_REL = "skills/fabric-review/SKILL.md";
 var SKILL_IMPORT_TEMPLATE_REL = "skills/fabric-import/SKILL.md";
 var HOOK_SCRIPT_TEMPLATE_REL = "hooks/fabric-hint.cjs";
 var HOOK_BROAD_SCRIPT_TEMPLATE_REL = "hooks/knowledge-hint-broad.cjs";
 var HOOK_NARROW_SCRIPT_TEMPLATE_REL = "hooks/knowledge-hint-narrow.cjs";
+var HOOK_LIB_TEMPLATE_DIR_REL = "hooks/lib";
 var CLAUDE_HOOK_CONFIG_TEMPLATE_REL = "hooks/configs/claude-code.json";
 var CODEX_HOOK_CONFIG_TEMPLATE_REL = "hooks/configs/codex-hooks.json";
 var CURSOR_HOOK_CONFIG_TEMPLATE_REL = "hooks/configs/cursor-hooks.json";
@@ -280,6 +92,11 @@ var HOOK_SCRIPT_DESTINATIONS = {
     ".cursor/hooks/knowledge-hint-narrow.cjs"
   ]
 };
+var HOOK_LIB_DESTINATIONS = [
+  ".claude/hooks/lib",
+  ".codex/hooks/lib",
+  ".cursor/hooks/lib"
+];
 var HOOK_CONFIG_TARGETS = {
   claudeCode: ".claude/settings.json",
   codex: ".codex/hooks.json",
@@ -288,7 +105,7 @@ var HOOK_CONFIG_TARGETS = {
 var HOOK_CONFIG_ARRAY_PATHS = {
   claudeCode: ["hooks.Stop", "hooks.SessionStart", "hooks.PreToolUse"],
   codex: ["events.Stop", "events.SessionStart", "events.PreToolUse"],
-  cursor: ["events.Stop", "events.SessionStart", "events.PreToolUse"]
+  cursor: ["hooks.stop", "hooks.sessionStart", "hooks.preToolUse"]
 };
 var FABRIC_HOOK_COMMAND_PATHS = {
   claudeCode: {
@@ -307,17 +124,13 @@ var FABRIC_HOOK_COMMAND_PATHS = {
     knowledgeHintNarrow: ".cursor/hooks/knowledge-hint-narrow.cjs"
   }
 };
-var SECTION_TARGETS = ["CLAUDE.md", "AGENTS.md", join2(".cursor", "rules")];
-var FABRIC_SECTION_BEGIN_MARKER = "<!-- fabric:knowledge-base:begin -->";
-var FABRIC_SECTION_END_MARKER = "<!-- fabric:knowledge-base:end -->";
-var FABRIC_SECTION_REGEX = /(?:\r?\n){0,2}<!-- fabric:knowledge-base:begin -->[\s\S]*?<!-- fabric:knowledge-base:end -->/;
 function readFabricLanguagePreference(projectRoot) {
   const configPath = join2(projectRoot, ".fabric", "fabric-config.json");
   if (!existsSync2(configPath)) {
     return "match-existing";
   }
   try {
-    const raw = readFileSync(configPath, "utf8");
+    const raw = readFileSync2(configPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       return "match-existing";
@@ -328,20 +141,6 @@ function readFabricLanguagePreference(projectRoot) {
     return "match-existing";
   }
 }
-function buildFabricKnowledgeBaseSection(fabricLanguage) {
-  return `${FABRIC_SECTION_BEGIN_MARKER}
-
-## Fabric Knowledge Base
-
-This project uses Fabric for persistent project knowledge under \`.fabric/knowledge/\`.
-
-- **Discovery**: SessionStart lists available entries (broad menu); editing files may surface narrow hints
-- **Usage**: call \`fab_get_knowledge_sections\` to fetch full content of any entry by id
-- **Write flows**: see fabric-archive (record), fabric-review (validate), fabric-import (backfill) Skills
-- **Language**: rendered per \`fabric_language\` in \`.fabric/fabric-config.json\` (current: \`${fabricLanguage}\`)
-
-${FABRIC_SECTION_END_MARKER}`;
-}
 async function installFabricArchiveSkill(projectRoot, _options = {}) {
   const source = await readTemplate(SKILL_TEMPLATE_REL);
   const targets = SKILL_DESTINATIONS.fabricArchive.map((rel) => join2(projectRoot, rel));
@@ -417,6 +216,53 @@ async function installKnowledgeHintNarrowHook(projectRoot, _options = {}) {
   }
   return results;
 }
+async function installHookLibs(projectRoot, _options = {}) {
+  const libTemplateDir = findTemplatePath(HOOK_LIB_TEMPLATE_DIR_REL);
+  let libFiles;
+  try {
+    libFiles = readdirSync(libTemplateDir).filter((name) => name.endsWith(".cjs"));
+  } catch (error) {
+    return [
+      {
+        step: "hook-lib",
+        path: libTemplateDir,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    ];
+  }
+  if (libFiles.length === 0) {
+    return [
+      {
+        step: "hook-lib",
+        path: libTemplateDir,
+        status: "skipped",
+        message: "no-libs-to-ship"
+      }
+    ];
+  }
+  const results = [];
+  for (const libFile of libFiles) {
+    const sourcePath = join2(libTemplateDir, libFile);
+    let source;
+    try {
+      source = readFileSync2(sourcePath, "utf8");
+    } catch (error) {
+      results.push({
+        step: "hook-lib",
+        path: sourcePath,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    for (const destDirRel of HOOK_LIB_DESTINATIONS) {
+      const target = join2(projectRoot, destDirRel, libFile);
+      results.push(await copyTextIdempotent("hook-lib", source, target));
+    }
+  }
+  return results;
+}
 async function mergeClaudeCodeHookConfig(projectRoot, _options = {}) {
   const fragment = await readJsonTemplate(CLAUDE_HOOK_CONFIG_TEMPLATE_REL);
   const targetPath = join2(projectRoot, HOOK_CONFIG_TARGETS.claudeCode);
@@ -447,65 +293,216 @@ async function mergeCursorHookConfig(projectRoot, _options = {}) {
     [...HOOK_CONFIG_ARRAY_PATHS.cursor]
   );
 }
-async function addFabricKnowledgeBaseSection(projectRoot, fabricLanguage, _options = {}) {
-  const sectionBody = buildFabricKnowledgeBaseSection(fabricLanguage);
-  const results = [];
-  for (const rel of SECTION_TARGETS) {
-    const target = join2(projectRoot, rel);
-    if (!existsSync2(target)) {
-      results.push({ step: "section", path: target, status: "skipped", message: "absent" });
-      continue;
+function buildManagedBlockBody(targetRoot) {
+  const snapshotPath = fabricAgentsSnapshotPath(targetRoot);
+  const snapshot = readFileSync2(snapshotPath, "utf8");
+  const projectRules = readProjectRulesIfPresent(targetRoot);
+  if (projectRules === null) {
+    return snapshot;
+  }
+  return `${snapshot}
+---
+${projectRules}`;
+}
+function wrapInBootstrapMarkers(body) {
+  return `${BOOTSTRAP_MARKER_BEGIN}
+${body}
+${BOOTSTRAP_MARKER_END}`;
+}
+function stripLegacyKnowledgeBaseSection(existing) {
+  const match = existing.match(LEGACY_KB_REGEX);
+  if (match === null) return existing;
+  const before = existing.slice(0, match.index ?? 0);
+  const after = existing.slice((match.index ?? 0) + match[0].length);
+  return `${before}${after.replace(/^\r?\n/, "")}`;
+}
+var CLAUDE_BOOTSTRAP_HEADER = "# Project Knowledge";
+var CLAUDE_AGENTS_IMPORT_LINE = "@.fabric/AGENTS.md";
+var CLAUDE_PROJECT_RULES_IMPORT_LINE = "@.fabric/project-rules.md";
+async function writeClaudeBootstrapThinShell(targetRoot, _options = {}) {
+  const step = "bootstrap-claude";
+  const target = join2(targetRoot, "CLAUDE.md");
+  const projectRulesPresent = existsSync2(projectRulesPath(targetRoot));
+  let existing = "";
+  let preExisted = false;
+  if (existsSync2(target)) {
+    preExisted = true;
+    try {
+      existing = await readFile(target, "utf8");
+    } catch (error) {
+      return {
+        step,
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
     }
-    let existing;
+  }
+  let next = stripLegacyKnowledgeBaseSection(existing);
+  if (!projectRulesPresent) {
+    next = removeImportLine(next, CLAUDE_PROJECT_RULES_IMPORT_LINE);
+  }
+  if (!preExisted && next.length === 0) {
+    next = `${CLAUDE_BOOTSTRAP_HEADER}
+`;
+  }
+  next = ensureImportLine(next, CLAUDE_AGENTS_IMPORT_LINE);
+  if (projectRulesPresent) {
+    next = ensureImportLine(next, CLAUDE_PROJECT_RULES_IMPORT_LINE);
+  }
+  if (next === existing) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  try {
+    await mkdir2(dirname2(target), { recursive: true });
+    await atomicWriteText2(target, next);
+    return { step, path: target, status: "written" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function ensureImportLine(content, line) {
+  if (hasExactLine(content, line)) return content;
+  if (content.length === 0) return `${line}
+`;
+  const endsWithBlank = content.endsWith("\n\n");
+  const endsWithNewline = content.endsWith("\n");
+  if (endsWithBlank) {
+    return `${content}${line}
+`;
+  }
+  if (endsWithNewline) {
+    return `${content}
+${line}
+`;
+  }
+  return `${content}
+
+${line}
+`;
+}
+function removeImportLine(content, line) {
+  const lines = content.split(/\r?\n/);
+  const filtered = lines.filter((l) => l.replace(/\s+$/, "") !== line);
+  return filtered.join("\n");
+}
+function hasExactLine(content, line) {
+  const lines = content.split(/\r?\n/);
+  return lines.some((l) => l.replace(/\s+$/, "") === line);
+}
+async function writeCodexBootstrapManagedBlock(targetRoot, _options = {}) {
+  const step = "bootstrap-codex";
+  const target = join2(targetRoot, "AGENTS.md");
+  let existing = "";
+  if (existsSync2(target)) {
     try {
-      existing = await readFile2(target, "utf8");
+      existing = await readFile(target, "utf8");
     } catch (error) {
-      results.push({
-        step: "section",
+      return {
+        step,
         path: target,
         status: "error",
         message: error instanceof Error ? error.message : String(error)
-      });
-      continue;
+      };
     }
-    let next;
-    const match = existing.match(FABRIC_SECTION_REGEX);
-    if (match !== null) {
-      const before = existing.slice(0, match.index ?? 0);
-      const after = existing.slice((match.index ?? 0) + match[0].length);
-      const stripped = `${before}${after.replace(/^\r?\n/, "")}`;
-      const trailingNewline = stripped.length === 0 || stripped.endsWith("\n") ? "" : "\n";
-      next = `${stripped}${trailingNewline}
-${sectionBody}
+  }
+  const body = buildManagedBlockBody(targetRoot);
+  const managedBlock = wrapInBootstrapMarkers(body);
+  const stripped = stripLegacyKnowledgeBaseSection(existing);
+  let next;
+  const match = stripped.match(BOOTSTRAP_REGEX);
+  if (match !== null) {
+    const before = stripped.slice(0, match.index ?? 0);
+    const after = stripped.slice((match.index ?? 0) + match[0].length);
+    const cleaned = `${before}${after.replace(/^\r?\n/, "")}`;
+    const trailingNewline = cleaned.length === 0 || cleaned.endsWith("\n") ? "" : "\n";
+    next = `${cleaned}${trailingNewline}${cleaned.length === 0 ? "" : "\n"}${managedBlock}
+`;
+  } else {
+    if (stripped.length === 0) {
+      next = `${managedBlock}
 `;
     } else {
-      const trailingNewline = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
-      next = `${existing}${trailingNewline}
-${sectionBody}
+      const trailingNewline = stripped.endsWith("\n") ? "" : "\n";
+      next = `${stripped}${trailingNewline}
+${managedBlock}
 `;
     }
-    if (next === existing) {
-      results.push({ step: "section", path: target, status: "skipped", message: "up-to-date" });
-      continue;
+  }
+  if (next === existing) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  try {
+    await mkdir2(dirname2(target), { recursive: true });
+    await atomicWriteText2(target, next);
+    return { step, path: target, status: "written" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var CURSOR_RULE_FRONT_MATTER = "---\nalwaysApply: true\ndescription: Fabric Protocol bootstrap rules\n---\n\n";
+var CURSOR_LEGACY_FLAT_FILE_REL = join2(".cursor", "rules");
+var CURSOR_BOOTSTRAP_MDC_REL = join2(".cursor", "rules", "fabric-bootstrap.mdc");
+async function writeCursorBootstrapManagedBlock(targetRoot, _options = {}) {
+  const step = "bootstrap-cursor";
+  const target = join2(targetRoot, CURSOR_BOOTSTRAP_MDC_REL);
+  const legacyFlatFile = join2(targetRoot, CURSOR_LEGACY_FLAT_FILE_REL);
+  try {
+    if (existsSync2(legacyFlatFile)) {
+      const stat = statSync(legacyFlatFile);
+      if (stat.isFile()) {
+        await rm(legacyFlatFile, { force: true });
+      }
     }
+  } catch {
+  }
+  const body = buildManagedBlockBody(targetRoot);
+  const managedBlock = wrapInBootstrapMarkers(body);
+  const expected = `${CURSOR_RULE_FRONT_MATTER}${managedBlock}
+`;
+  let existing = "";
+  if (existsSync2(target)) {
     try {
-      await atomicWriteText(target, next);
-      results.push({ step: "section", path: target, status: "written" });
+      existing = await readFile(target, "utf8");
     } catch (error) {
-      results.push({
-        step: "section",
+      return {
+        step,
         path: target,
         status: "error",
         message: error instanceof Error ? error.message : String(error)
-      });
+      };
     }
   }
-  return results;
+  if (existing === expected) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  try {
+    await mkdir2(dirname2(target), { recursive: true });
+    await atomicWriteText2(target, expected);
+    return { step, path: target, status: "written" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
 }
 async function copyTextIdempotent(step, source, target) {
   if (existsSync2(target)) {
     try {
-      const existing = readFileSync(target, "utf8");
+      const existing = readFileSync2(target, "utf8");
       if (existing === source) {
         return { step, path: target, status: "skipped", message: "up-to-date" };
       }
@@ -513,7 +510,7 @@ async function copyTextIdempotent(step, source, target) {
     }
   }
   await mkdir2(dirname2(target), { recursive: true });
-  await atomicWriteText(target, source);
+  await atomicWriteText2(target, source);
   return { step, path: target, status: "written" };
 }
 async function mergeJsonIdempotent(step, target, fragment, arrayAppendPaths) {
@@ -523,12 +520,12 @@ async function mergeJsonIdempotent(step, target, fragment, arrayAppendPaths) {
     return { step, path: target, status: "skipped", message: "up-to-date" };
   }
   await mkdir2(dirname2(target), { recursive: true });
-  await atomicWriteJson2(target, merged, { indent: 2 });
+  await atomicWriteJson(target, merged, { indent: 2 });
   return { step, path: target, status: "written" };
 }
 async function readJsonObjectOrEmpty(path) {
   try {
-    const raw = await readFile2(path, "utf8");
+    const raw = await readFile(path, "utf8");
     if (raw.trim().length === 0) {
       return {};
     }
@@ -549,7 +546,7 @@ function jsonEqual(a, b) {
 }
 async function readTemplate(relativePath) {
   const path = findTemplatePath(relativePath);
-  return readFile2(path, "utf8");
+  return readFile(path, "utf8");
 }
 async function readJsonTemplate(relativePath) {
   const raw = await readTemplate(relativePath);
@@ -561,7 +558,7 @@ async function readJsonTemplate(relativePath) {
 }
 function findTemplatePath(relativePath) {
   const startDir = dirname2(fileURLToPath(import.meta.url));
-  let current = resolve2(startDir);
+  let current = resolve(startDir);
   while (true) {
     const candidate = join2(current, "templates", relativePath);
     if (existsSync2(candidate)) {
@@ -576,19 +573,14 @@ function findTemplatePath(relativePath) {
 }
 
 export {
-  createServerEntry,
-  normalizeConfigPath,
-  writeJsonClientConfig,
-  removeJsonClientConfigEntry,
-  ClaudeCodeCLIWriter,
-  CursorWriter,
+  fabricAgentsSnapshotPath,
+  writeFabricAgentsSnapshot,
   SKILL_DESTINATIONS,
   HOOK_SCRIPT_DESTINATIONS,
+  HOOK_LIB_DESTINATIONS,
   HOOK_CONFIG_TARGETS,
   HOOK_CONFIG_ARRAY_PATHS,
   FABRIC_HOOK_COMMAND_PATHS,
-  SECTION_TARGETS,
-  FABRIC_SECTION_REGEX,
   readFabricLanguagePreference,
   installFabricArchiveSkill,
   installFabricReviewSkill,
@@ -596,8 +588,11 @@ export {
   installArchiveHintHook,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,
+  installHookLibs,
   mergeClaudeCodeHookConfig,
   mergeCodexHookConfig,
   mergeCursorHookConfig,
-  addFabricKnowledgeBaseSection
+  writeClaudeBootstrapThinShell,
+  writeCodexBootstrapManagedBlock,
+  writeCursorBootstrapManagedBlock
 };