@fenglimg/fabric-cli 2.0.0 → 2.0.1

package/dist/chunk-D25XJ4BC.js

@@ -0,0 +1,880 @@
+#!/usr/bin/env node
+import {
+  deepMerge
+} from "./chunk-MF3OTILQ.js";
+
+// 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 projectRulesPath(targetRoot) {
+  return join(targetRoot, PROJECT_RULES_RELPATH);
+}
+function readProjectRulesIfPresent(targetRoot) {
+  const path = projectRulesPath(targetRoot);
+  if (!existsSync(path)) return null;
+  return readFileSync(path, "utf8");
+}
+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 {
+    }
+  }
+  await mkdir(dirname(target), { recursive: true });
+  await atomicWriteText(target, BOOTSTRAP_CANONICAL);
+  return { step, path: target, status: "written" };
+}
+
+// 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_CITE_EVICT_SCRIPT_TEMPLATE_REL = "hooks/cite-policy-evict.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";
+var SKILL_DESTINATIONS = {
+  fabricArchive: [
+    ".claude/skills/fabric-archive/SKILL.md",
+    ".codex/skills/fabric-archive/SKILL.md"
+  ],
+  fabricReview: [
+    ".claude/skills/fabric-review/SKILL.md",
+    ".codex/skills/fabric-review/SKILL.md"
+  ],
+  fabricImport: [
+    ".claude/skills/fabric-import/SKILL.md",
+    ".codex/skills/fabric-import/SKILL.md"
+  ]
+};
+var DEPRECATED_SKILL_DIRS = [
+  ".claude/skills/fabric-init",
+  ".codex/skills/fabric-init"
+];
+var HOOK_SCRIPT_DESTINATIONS = {
+  fabricHint: [
+    ".claude/hooks/fabric-hint.cjs",
+    ".codex/hooks/fabric-hint.cjs",
+    ".cursor/hooks/fabric-hint.cjs"
+  ],
+  knowledgeHintBroad: [
+    ".claude/hooks/knowledge-hint-broad.cjs",
+    ".codex/hooks/knowledge-hint-broad.cjs",
+    ".cursor/hooks/knowledge-hint-broad.cjs"
+  ],
+  knowledgeHintNarrow: [
+    ".claude/hooks/knowledge-hint-narrow.cjs",
+    ".codex/hooks/knowledge-hint-narrow.cjs",
+    ".cursor/hooks/knowledge-hint-narrow.cjs"
+  ],
+  // v2.0.0-rc.34 TASK-06: Claude Code — UserPromptSubmit cite-policy long-
+  // session evict sidecar.
+  // v2.0.0-rc.37 NEW-21: extended to Codex / Cursor SessionStart slots.
+  // Those clients don't have an equivalent per-prompt event, so cite-policy-
+  // evict.cjs runs in "SessionStart mode" (one-shot stderr emit per session
+  // boot, no turn-counter). Cadence is lower than Claude Code's per-prompt
+  // window but strictly better than 0 (rc.32 baseline measured Codex/Cursor
+  // at 3.1% cite coverage when no cite-reminder surface existed).
+  citePolicyEvict: [
+    ".claude/hooks/cite-policy-evict.cjs",
+    ".codex/hooks/cite-policy-evict.cjs",
+    ".cursor/hooks/cite-policy-evict.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",
+  cursor: ".cursor/hooks.json"
+};
+var HOOK_CONFIG_ARRAY_PATHS = {
+  claudeCode: ["hooks.Stop", "hooks.SessionStart", "hooks.PreToolUse"],
+  codex: ["events.Stop", "events.SessionStart", "events.PreToolUse"],
+  cursor: ["hooks.stop", "hooks.sessionStart", "hooks.preToolUse"]
+};
+var FABRIC_HOOK_COMMAND_PATHS = {
+  claudeCode: {
+    fabricHint: "${CLAUDE_PROJECT_DIR}/.claude/hooks/fabric-hint.cjs",
+    knowledgeHintBroad: "${CLAUDE_PROJECT_DIR}/.claude/hooks/knowledge-hint-broad.cjs",
+    knowledgeHintNarrow: "${CLAUDE_PROJECT_DIR}/.claude/hooks/knowledge-hint-narrow.cjs"
+  },
+  codex: {
+    fabricHint: '"$(git rev-parse --show-toplevel)/.codex/hooks/fabric-hint.cjs"',
+    knowledgeHintBroad: '"$(git rev-parse --show-toplevel)/.codex/hooks/knowledge-hint-broad.cjs"',
+    knowledgeHintNarrow: '"$(git rev-parse --show-toplevel)/.codex/hooks/knowledge-hint-narrow.cjs"'
+  },
+  cursor: {
+    fabricHint: ".cursor/hooks/fabric-hint.cjs",
+    knowledgeHintBroad: ".cursor/hooks/knowledge-hint-broad.cjs",
+    knowledgeHintNarrow: ".cursor/hooks/knowledge-hint-narrow.cjs"
+  }
+};
+function readFabricLanguagePreference(projectRoot) {
+  const configPath = join2(projectRoot, ".fabric", "fabric-config.json");
+  if (!existsSync2(configPath)) {
+    return "match-existing";
+  }
+  try {
+    const raw = readFileSync2(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return "match-existing";
+    }
+    const value = parsed["fabric_language"];
+    return typeof value === "string" && value.length > 0 ? value : "match-existing";
+  } catch {
+    return "match-existing";
+  }
+}
+var SKILL_TOKEN_ERROR_TOKENS = 1e4;
+var STALE_INSTALL_RATIO = 1.5;
+function estimateSkillTokens(text) {
+  return Math.ceil(text.length / 3);
+}
+function validateSkillCanonicalSize(source, slug) {
+  const tokens = estimateSkillTokens(source);
+  if (tokens > SKILL_TOKEN_ERROR_TOKENS) {
+    throw new Error(
+      `Skill '${slug}' canonical SKILL.md estimates ${tokens} tok (>${SKILL_TOKEN_ERROR_TOKENS} ERROR threshold). Install aborted \u2014 this is a Fabric release bug, not a user-recoverable state. Re-split SKILL.md via progressive disclosure (see fabric-archive/phases/* as canonical example) and rebuild.`
+    );
+  }
+}
+function inspectStaleInstall(target, source) {
+  if (!existsSync2(target)) return null;
+  let existing;
+  try {
+    existing = readFileSync2(target, "utf8");
+  } catch {
+    return null;
+  }
+  const existingTok = estimateSkillTokens(existing);
+  const sourceTok = estimateSkillTokens(source);
+  if (existingTok > sourceTok * STALE_INSTALL_RATIO) {
+    return `stale-replaced (${existingTok} tok \u2192 ${sourceTok} tok canonical)`;
+  }
+  return null;
+}
+async function installFabricArchiveSkill(projectRoot, _options = {}) {
+  const source = await readTemplate(SKILL_TEMPLATE_REL);
+  validateSkillCanonicalSize(source, "fabric-archive");
+  const targets = SKILL_DESTINATIONS.fabricArchive.map((rel) => join2(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const staleMsg = inspectStaleInstall(target, source);
+    const result = await copyTextIdempotent("skill", source, target);
+    if (staleMsg && result.status === "written") {
+      result.message = result.message ? `${staleMsg}; ${result.message}` : staleMsg;
+    }
+    results.push(result);
+  }
+  results.push(...await installSkillRefFiles(projectRoot, "fabric-archive"));
+  return results;
+}
+async function installFabricReviewSkill(projectRoot, _options = {}) {
+  const source = await readTemplate(SKILL_REVIEW_TEMPLATE_REL);
+  validateSkillCanonicalSize(source, "fabric-review");
+  const targets = SKILL_DESTINATIONS.fabricReview.map((rel) => join2(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const staleMsg = inspectStaleInstall(target, source);
+    const result = await copyTextIdempotent("skill-review", source, target);
+    if (staleMsg && result.status === "written") {
+      result.message = result.message ? `${staleMsg}; ${result.message}` : staleMsg;
+    }
+    results.push(result);
+  }
+  results.push(...await installSkillRefFiles(projectRoot, "fabric-review"));
+  return results;
+}
+async function installFabricImportSkill(projectRoot, _options = {}) {
+  const source = await readTemplate(SKILL_IMPORT_TEMPLATE_REL);
+  validateSkillCanonicalSize(source, "fabric-import");
+  const targets = SKILL_DESTINATIONS.fabricImport.map((rel) => join2(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const staleMsg = inspectStaleInstall(target, source);
+    const result = await copyTextIdempotent("skill-import", source, target);
+    if (staleMsg && result.status === "written") {
+      result.message = result.message ? `${staleMsg}; ${result.message}` : staleMsg;
+    }
+    results.push(result);
+  }
+  results.push(...await installSkillRefFiles(projectRoot, "fabric-import"));
+  return results;
+}
+async function cleanupDeprecatedSkills(projectRoot) {
+  const results = [];
+  for (const rel of DEPRECATED_SKILL_DIRS) {
+    const target = join2(projectRoot, rel);
+    if (!existsSync2(target)) {
+      results.push({ step: "skill-deprecated-cleanup", path: target, status: "skipped", message: "absent" });
+      continue;
+    }
+    try {
+      await rm(target, { recursive: true, force: true });
+      results.push({
+        step: "skill-deprecated-cleanup",
+        path: target,
+        status: "written",
+        message: "removed-deprecated"
+      });
+    } catch (error) {
+      results.push({
+        step: "skill-deprecated-cleanup",
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+async function installSkillRefFiles(projectRoot, skillSlug) {
+  let refTemplateDir;
+  try {
+    refTemplateDir = findTemplatePath(`skills/${skillSlug}/ref`);
+  } catch {
+    return [
+      {
+        step: "skill-ref",
+        path: `skills/${skillSlug}/ref`,
+        status: "skipped",
+        message: `no-ref-dir: ${skillSlug}`
+      }
+    ];
+  }
+  let refFiles;
+  try {
+    refFiles = readdirSync(refTemplateDir).filter((name) => name.endsWith(".md"));
+  } catch {
+    return [
+      {
+        step: "skill-ref",
+        path: refTemplateDir,
+        status: "skipped",
+        message: `no-ref-files: ${skillSlug}`
+      }
+    ];
+  }
+  if (refFiles.length === 0) {
+    return [
+      {
+        step: "skill-ref",
+        path: refTemplateDir,
+        status: "skipped",
+        message: `no-ref-files: ${skillSlug}`
+      }
+    ];
+  }
+  const clientPrefixes = [".claude", ".codex"];
+  const results = [];
+  for (const refFile of refFiles) {
+    const sourcePath = join2(refTemplateDir, refFile);
+    let source;
+    try {
+      source = readFileSync2(sourcePath, "utf8");
+    } catch (error) {
+      results.push({
+        step: "skill-ref",
+        path: sourcePath,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    for (const prefix of clientPrefixes) {
+      const target = join2(projectRoot, prefix, "skills", skillSlug, "ref", refFile);
+      results.push(await copyTextIdempotent("skill-ref", source, target));
+    }
+  }
+  return results;
+}
+async function installSharedSkillLib(projectRoot, _options = {}) {
+  let libTemplateDir;
+  try {
+    libTemplateDir = findTemplatePath("skills/lib");
+  } catch {
+    return [{ step: "skill-lib", path: "skills/lib", status: "skipped", message: "no-lib-dir" }];
+  }
+  let libFiles;
+  try {
+    libFiles = readdirSync(libTemplateDir).filter((name) => name.endsWith(".md"));
+  } catch {
+    return [{ step: "skill-lib", path: libTemplateDir, status: "skipped", message: "no-lib-files" }];
+  }
+  const clientPrefixes = [".claude", ".codex"];
+  const results = [];
+  for (const libFile of libFiles) {
+    let source;
+    try {
+      source = readFileSync2(join2(libTemplateDir, libFile), "utf8");
+    } catch (error) {
+      results.push({
+        step: "skill-lib",
+        path: join2(libTemplateDir, libFile),
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    for (const prefix of clientPrefixes) {
+      const target = join2(projectRoot, prefix, "skills", "lib", libFile);
+      results.push(await copyTextIdempotent("skill-lib", source, target));
+    }
+  }
+  return results;
+}
+async function installArchiveHintHook(projectRoot, _options = {}) {
+  const source = await readTemplate(HOOK_SCRIPT_TEMPLATE_REL);
+  const targets = HOOK_SCRIPT_DESTINATIONS.fabricHint.map((rel) => join2(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const result = await copyTextIdempotent("hook-script", source, target);
+    if (result.status === "written" && process.platform !== "win32") {
+      try {
+        chmodSync(target, 493);
+      } catch {
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function installKnowledgeHintBroadHook(projectRoot, _options = {}) {
+  const source = await readTemplate(HOOK_BROAD_SCRIPT_TEMPLATE_REL);
+  const targets = HOOK_SCRIPT_DESTINATIONS.knowledgeHintBroad.map((rel) => join2(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const result = await copyTextIdempotent("hook-broad-script", source, target);
+    if (result.status === "written" && process.platform !== "win32") {
+      try {
+        chmodSync(target, 493);
+      } catch {
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function installKnowledgeHintNarrowHook(projectRoot, _options = {}) {
+  const source = await readTemplate(HOOK_NARROW_SCRIPT_TEMPLATE_REL);
+  const targets = HOOK_SCRIPT_DESTINATIONS.knowledgeHintNarrow.map((rel) => join2(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const result = await copyTextIdempotent("hook-narrow-script", source, target);
+    if (result.status === "written" && process.platform !== "win32") {
+      try {
+        chmodSync(target, 493);
+      } catch {
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function installCitePolicyEvictHook(projectRoot, _options = {}) {
+  const source = await readTemplate(HOOK_CITE_EVICT_SCRIPT_TEMPLATE_REL);
+  const targets = HOOK_SCRIPT_DESTINATIONS.citePolicyEvict.map((rel) => join2(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const result = await copyTextIdempotent("hook-cite-evict-script", source, target);
+    if (result.status === "written" && process.platform !== "win32") {
+      try {
+        chmodSync(target, 493);
+      } catch {
+      }
+    }
+    results.push(result);
+  }
+  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);
+  return mergeJsonIdempotent(
+    "claude-hook-config",
+    targetPath,
+    fragment,
+    [...HOOK_CONFIG_ARRAY_PATHS.claudeCode]
+  );
+}
+async function mergeCodexHookConfig(projectRoot, _options = {}) {
+  const fragment = await readJsonTemplate(CODEX_HOOK_CONFIG_TEMPLATE_REL);
+  const targetPath = join2(projectRoot, HOOK_CONFIG_TARGETS.codex);
+  return mergeJsonIdempotent(
+    "codex-hook-config",
+    targetPath,
+    fragment,
+    [...HOOK_CONFIG_ARRAY_PATHS.codex]
+  );
+}
+async function mergeCursorHookConfig(projectRoot, _options = {}) {
+  const fragment = await readJsonTemplate(CURSOR_HOOK_CONFIG_TEMPLATE_REL);
+  const targetPath = join2(projectRoot, HOOK_CONFIG_TARGETS.cursor);
+  return mergeJsonIdempotent(
+    "cursor-hook-config",
+    targetPath,
+    fragment,
+    [...HOOK_CONFIG_ARRAY_PATHS.cursor]
+  );
+}
+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 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 readFile(target, "utf8");
+    } catch (error) {
+      return {
+        step,
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  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 = stripped.endsWith("\n") ? "" : "\n";
+      next = `${stripped}${trailingNewline}
+${managedBlock}
+`;
+    }
+  }
+  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 {
+      existing = await readFile(target, "utf8");
+    } catch (error) {
+      return {
+        step,
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  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 = readFileSync2(target, "utf8");
+      if (existing === source) {
+        return { step, path: target, status: "skipped", message: "up-to-date" };
+      }
+    } catch {
+    }
+  }
+  await mkdir2(dirname2(target), { recursive: true });
+  await atomicWriteText2(target, source);
+  return { step, path: target, status: "written" };
+}
+var FABRIC_HOOK_SCRIPT_BASENAMES = /* @__PURE__ */ new Set([
+  "fabric-hint.cjs",
+  "knowledge-hint-broad.cjs",
+  "knowledge-hint-narrow.cjs",
+  // rc.5 TASK-010 rename — old hook scripts that pre-upgrade workspaces
+  // may still have registered. Sweeping them prevents the double-fire
+  // documented in audit §2.6.
+  "archive-hint.cjs"
+]);
+function commandBasename(command) {
+  const trimmed = command.trim().replace(/^"+|"+$/g, "");
+  const match = /([^/\\]+\.cjs)$/u.exec(trimmed);
+  return match === null ? null : match[1];
+}
+function stripStaleHookEntries(existing, arrayAppendPaths) {
+  const swept = JSON.parse(JSON.stringify(existing));
+  let removed = 0;
+  for (const dottedPath of arrayAppendPaths) {
+    const segments = dottedPath.split(".");
+    let cursor = swept;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const seg = segments[i];
+      if (cursor === null || typeof cursor !== "object" || Array.isArray(cursor)) {
+        cursor = void 0;
+        break;
+      }
+      cursor = cursor[seg];
+    }
+    if (cursor === null || cursor === void 0 || typeof cursor !== "object" || Array.isArray(cursor)) {
+      continue;
+    }
+    const finalSeg = segments[segments.length - 1];
+    const arr = cursor[finalSeg];
+    if (!Array.isArray(arr)) continue;
+    const filtered = [];
+    for (const item of arr) {
+      if (item === null || typeof item !== "object") {
+        filtered.push(item);
+        continue;
+      }
+      const entry = item;
+      const hooks = entry.hooks;
+      let isFabricOwned = false;
+      if (Array.isArray(hooks)) {
+        for (const h of hooks) {
+          if (h !== null && typeof h === "object") {
+            const cmd = h.command;
+            if (typeof cmd === "string") {
+              const base = commandBasename(cmd);
+              if (base !== null && FABRIC_HOOK_SCRIPT_BASENAMES.has(base)) {
+                isFabricOwned = true;
+                break;
+              }
+            }
+          }
+        }
+      }
+      if (!isFabricOwned && typeof entry.command === "string") {
+        const base = commandBasename(entry.command);
+        if (base !== null && FABRIC_HOOK_SCRIPT_BASENAMES.has(base)) {
+          isFabricOwned = true;
+        }
+      }
+      if (isFabricOwned) {
+        removed += 1;
+      } else {
+        filtered.push(item);
+      }
+    }
+    cursor[finalSeg] = filtered;
+  }
+  return { swept, removed };
+}
+async function mergeJsonIdempotent(step, target, fragment, arrayAppendPaths) {
+  const existing = await readJsonObjectOrEmpty(target);
+  const { swept } = stripStaleHookEntries(existing, arrayAppendPaths);
+  const merged = deepMerge(swept, fragment, { arrayAppendPaths });
+  if (jsonEqual(existing, merged)) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  await mkdir2(dirname2(target), { recursive: true });
+  await atomicWriteJson(target, merged, { indent: 2 });
+  return { step, path: target, status: "written" };
+}
+async function readJsonObjectOrEmpty(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    if (raw.trim().length === 0) {
+      return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+function jsonEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+async function readTemplate(relativePath) {
+  const path = findTemplatePath(relativePath);
+  return readFile(path, "utf8");
+}
+async function readJsonTemplate(relativePath) {
+  const raw = await readTemplate(relativePath);
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Template at ${relativePath} is not a JSON object`);
+  }
+  return parsed;
+}
+function findTemplatePath(relativePath) {
+  const startDir = dirname2(fileURLToPath(import.meta.url));
+  let current = resolve(startDir);
+  while (true) {
+    const candidate = join2(current, "templates", relativePath);
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+    const parent = dirname2(current);
+    if (parent === current || parse(current).root === current) {
+      throw new Error(`Template not found: templates/${relativePath} (searched up from ${startDir})`);
+    }
+    current = parent;
+  }
+}
+
+export {
+  fabricAgentsSnapshotPath,
+  writeFabricAgentsSnapshot,
+  SKILL_DESTINATIONS,
+  HOOK_SCRIPT_DESTINATIONS,
+  HOOK_LIB_DESTINATIONS,
+  HOOK_CONFIG_TARGETS,
+  HOOK_CONFIG_ARRAY_PATHS,
+  FABRIC_HOOK_COMMAND_PATHS,
+  readFabricLanguagePreference,
+  installFabricArchiveSkill,
+  installFabricReviewSkill,
+  installFabricImportSkill,
+  cleanupDeprecatedSkills,
+  installSharedSkillLib,
+  installArchiveHintHook,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  installCitePolicyEvictHook,
+  installHookLibs,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  mergeCursorHookConfig,
+  writeClaudeBootstrapThinShell,
+  writeCodexBootstrapManagedBlock,
+  writeCursorBootstrapManagedBlock
+};