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

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-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) {

package/dist/{config-7YD365I3.js → config-AYP5F72E.js}

@@ -3,8 +3,8 @@ import {
   configCmd,
   config_default,
   installMcpClients
-} from "./chunk-AIB54QRT.js";
-import "./chunk-SKSYUHKK.js";
+} from "./chunk-KZ2YITOS.js";
+import "./chunk-MF3OTILQ.js";
 import "./chunk-6ICJICVU.js";
 export {
   configCmd,

package/dist/{doctor-6XHLQJXB.js → doctor-L6TIXXIX.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runInitScan
-} from "./chunk-AXIFEVAS.js";
+} from "./chunk-FNO7CQDG.js";
 import {
   hasActionHint,
   paint,
@@ -13,7 +13,7 @@ import {
 } from "./chunk-6ICJICVU.js";
 import {
   resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-ZSESMG6L.js";
 
 // src/commands/doctor.ts
 import { confirm, isCancel } from "@clack/prompts";
@@ -22,6 +22,7 @@ import {
   appendEventLedgerEvent,
   checkLockOrThrow,
   runDoctorApplyLint as runDoctorFixKnowledge,
+  runDoctorCiteCoverage,
   runDoctorFix,
   runDoctorReport
 } from "@fenglimg/fabric-server";
@@ -75,6 +76,25 @@ var doctorCommand = defineCommand({
       type: "boolean",
       description: t("cli.doctor.args.yes.description"),
       default: false
+    },
+    // rc.20 TASK-05: cite policy adherence report (read-only). Skips standard
+    // inspections entirely — different output surface. Mutually exclusive
+    // with --fix / --fix-knowledge (enforced in run()).
+    "cite-coverage": {
+      type: "boolean",
+      description: t("cli.doctor.args.cite-coverage.description"),
+      default: false
+    },
+    since: {
+      type: "string",
+      description: t("cli.doctor.args.since.description"),
+      default: "7d"
+    },
+    client: {
+      type: "string",
+      description: t("cli.doctor.args.client.description"),
+      default: "all",
+      valueHint: "cc|codex|cursor|all"
     }
   },
   async run({ args }) {
@@ -92,6 +112,34 @@ var doctorCommand = defineCommand({
     const fixKnowledge = args["fix-knowledge"] === true;
     const fix = args.fix === true;
     const rescan = args.rescan === true;
+    const citeCoverage = args["cite-coverage"] === true;
+    if (citeCoverage) {
+      if (fix || fixKnowledge) {
+        writeStderr(t("cli.doctor.errors.cite-coverage-mutex"));
+        process.exitCode = 1;
+        return;
+      }
+      let sinceMs;
+      try {
+        sinceMs = parseSinceDuration(args.since ?? "7d");
+      } catch {
+        writeStderr(t("cli.doctor.errors.invalid-since", { input: args.since ?? "7d" }));
+        process.exitCode = 1;
+        return;
+      }
+      const clientFilter = args.client ?? "all";
+      if (!isValidClientFilter(clientFilter)) {
+        writeStderr(t("cli.doctor.errors.invalid-client", { input: clientFilter }));
+        process.exitCode = 1;
+        return;
+      }
+      const report2 = await runDoctorCiteCoverage(resolution.target, {
+        since: sinceMs,
+        client: clientFilter
+      });
+      renderCiteCoverageReport(report2, args.json === true);
+      return;
+    }
     if (fixKnowledge && fix) {
       writeStderr(t("cli.doctor.errors.fix-knowledge-fix-mutually-exclusive"));
       process.exitCode = 1;
@@ -293,7 +341,85 @@ async function resolveFixKnowledgeConsent(options) {
   }
   return "proceed";
 }
+var CITE_COVERAGE_CLIENT_FILTERS = /* @__PURE__ */ new Set([
+  "cc",
+  "codex",
+  "cursor",
+  "all"
+]);
+function isValidClientFilter(input) {
+  return CITE_COVERAGE_CLIENT_FILTERS.has(input);
+}
+function renderCiteCoverageReport(report, jsonMode) {
+  if (jsonMode) {
+    writeStdout(JSON.stringify(report, null, 2));
+    return;
+  }
+  if (report.status === "skipped") {
+    writeStdout(t("doctor.cite.status.skipped"));
+    return;
+  }
+  const lines = [];
+  lines.push(t("doctor.section.cite-coverage"));
+  lines.push(
+    t("doctor.cite.header", {
+      since: new Date(report.since_ts).toISOString(),
+      marker: new Date(report.marker_ts).toISOString()
+    })
+  );
+  if (report.marker_emitted_now) {
+    lines.push(t("doctor.cite.warning.justActivated"));
+  }
+  lines.push("");
+  lines.push(`  ${t("doctor.cite.metric.editsTouched")}: ${report.metrics.edits_touched}`);
+  lines.push(`  ${t("doctor.cite.metric.qualifyingCites")}: ${report.metrics.qualifying_cites}`);
+  lines.push(`  ${t("doctor.cite.metric.recalledUnverified")}: ${report.metrics.recalled_unverified}`);
+  lines.push(`  ${t("doctor.cite.metric.expectedButMissed")}: ${report.metrics.expected_but_missed}`);
+  lines.push(`  ${t("doctor.cite.metric.totalTurns")}: ${report.metrics.total_turns}`);
+  if (report.per_client !== void 0 && Object.keys(report.per_client).length > 1) {
+    lines.push("");
+    lines.push(`### ${t("doctor.cite.section.perClient")}`);
+    for (const [client, metrics] of Object.entries(report.per_client)) {
+      const summary = Object.entries(metrics).map(([k, v]) => `${k}=${v}`).join(" / ");
+      lines.push(`  ${client}: ${summary}`);
+    }
+  }
+  if (report.dismissed_reason_histogram !== void 0 && Object.keys(report.dismissed_reason_histogram).length > 0) {
+    lines.push("");
+    lines.push(`### ${t("doctor.cite.section.dismissedReasons")}`);
+    for (const [reason, count] of Object.entries(report.dismissed_reason_histogram)) {
+      const label = t(`doctor.cite.dismissed.${reason}`);
+      lines.push(`  ${label}: ${count}`);
+    }
+  }
+  writeStdout(lines.join("\n"));
+}
+function parseSinceDuration(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`invalid --since value: ${input}`);
+  }
+  const durationMatch = /^(\d+)([dhm])$/.exec(trimmed);
+  if (durationMatch !== null) {
+    const value = Number.parseInt(durationMatch[1], 10);
+    const unit = durationMatch[2];
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`invalid --since value: ${input}`);
+    }
+    const unitMs = unit === "d" ? 864e5 : unit === "h" ? 36e5 : 6e4;
+    return Date.now() - value * unitMs;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const value = Number.parseInt(trimmed, 10);
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`invalid --since value: ${input}`);
+    }
+    return value;
+  }
+  throw new Error(`invalid --since value: ${input}`);
+}
 export {
   doctor_default as default,
-  doctorCommand
+  doctorCommand,
+  parseSinceDuration
 };

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/index.ts
 import { realpathSync } from "fs";
@@ -8,20 +11,20 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  install: () => import("./install-JLDCHAXV.js").then((module) => module.default),
-  doctor: () => import("./doctor-6XHLQJXB.js").then((module) => module.default),
-  serve: () => import("./serve-L3X5UHG2.js").then((module) => module.default),
-  uninstall: () => import("./uninstall-DD6FIFCI.js").then((module) => module.default),
-  config: () => import("./config-7YD365I3.js").then((module) => module.default),
-  "plan-context-hint": () => import("./plan-context-hint-73U4FGKO.js").then((module) => module.default)
+  install: () => import("./install-DNZXGFHJ.js").then((module) => module.default),
+  doctor: () => import("./doctor-L6TIXXIX.js").then((module) => module.default),
+  serve: () => import("./serve-6PPQX7AW.js").then((module) => module.default),
+  uninstall: () => import("./uninstall-L2HEEOU3.js").then((module) => module.default),
+  config: () => import("./config-AYP5F72E.js").then((module) => module.default),
+  "plan-context-hint": () => import("./plan-context-hint-CFDGXHCA.js").then((module) => module.default)
 };
 
 // src/index.ts
 var main = defineCommand({
   meta: {
     name: "fabric",
-    version: "2.0.0-rc.15",
-    description: 'Initialize and manage Fabric projects. Use "fabric install" for one-shot setup.'
+    version: "2.0.0-rc.21",
+    description: t("cli.main.description")
   },
   subCommands: allCommands
 });

package/dist/{install-JLDCHAXV.js → install-DNZXGFHJ.js}

@@ -1,27 +1,31 @@
 #!/usr/bin/env node
 import {
   installMcpClients
-} from "./chunk-AIB54QRT.js";
+} from "./chunk-KZ2YITOS.js";
 import {
   detectExistingLanguage,
   runInitScan
-} from "./chunk-AXIFEVAS.js";
+} from "./chunk-FNO7CQDG.js";
 import {
-  addFabricKnowledgeBaseSection,
   installArchiveHintHook,
   installFabricArchiveSkill,
   installFabricImportSkill,
   installFabricReviewSkill,
+  installHookLibs,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,
   mergeClaudeCodeHookConfig,
   mergeCodexHookConfig,
   mergeCursorHookConfig,
-  readFabricLanguagePreference
-} from "./chunk-UTF4YBDN.js";
+  readFabricLanguagePreference,
+  writeClaudeBootstrapThinShell,
+  writeCodexBootstrapManagedBlock,
+  writeCursorBootstrapManagedBlock,
+  writeFabricAgentsSnapshot
+} from "./chunk-4HC5ZK7H.js";
 import {
   detectClientSupports
-} from "./chunk-SKSYUHKK.js";
+} from "./chunk-MF3OTILQ.js";
 import {
   displayWidth,
   hasActionHint,
@@ -35,7 +39,7 @@ import {
 import {
   createDebugLogger,
   resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-ZSESMG6L.js";
 
 // src/commands/install.ts
 import { randomUUID } from "crypto";
@@ -45,7 +49,7 @@ import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync as r
 import { dirname, isAbsolute as isAbsolute3, join as join3, resolve as resolve3 } from "path";
 import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
 import { defaultAgentsMetaCounters } from "@fenglimg/fabric-shared";
-import { atomicWriteJson, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
 import { defineCommand } from "citty";
 import { checkLockOrThrow } from "@fenglimg/fabric-server";
 
@@ -62,11 +66,14 @@ async function installHooks(target, _options = {}) {
   results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
   results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
   results.push(...await runStep(() => installKnowledgeHintNarrowHook(normalizedTarget)));
+  results.push(...await runStep(() => installHookLibs(normalizedTarget)));
   results.push(await runSingleStep("claude-hook-config", () => mergeClaudeCodeHookConfig(normalizedTarget)));
   results.push(await runSingleStep("codex-hook-config", () => mergeCodexHookConfig(normalizedTarget)));
   results.push(await runSingleStep("cursor-hook-config", () => mergeCursorHookConfig(normalizedTarget)));
-  const fabricLanguage = readFabricLanguagePreference(normalizedTarget);
-  results.push(...await runStep(() => addFabricKnowledgeBaseSection(normalizedTarget, fabricLanguage)));
+  results.push(await runSingleStep("bootstrap-snapshot", () => writeFabricAgentsSnapshot(normalizedTarget)));
+  results.push(await runSingleStep("bootstrap-claude", () => writeClaudeBootstrapThinShell(normalizedTarget)));
+  results.push(await runSingleStep("bootstrap-codex", () => writeCodexBootstrapManagedBlock(normalizedTarget)));
+  results.push(await runSingleStep("bootstrap-cursor", () => writeCursorBootstrapManagedBlock(normalizedTarget)));
   results.push(...validateHookPaths(normalizedTarget));
   return summarizeResults(results);
 }
@@ -1292,7 +1299,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0-rc.15" : "unknown";
+  return true ? "2.0.0-rc.21" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1302,15 +1309,6 @@ function toPosixPath(path) {
 }
 
 // src/commands/install.ts
-var AGENTS_MD_DEFAULT_CONTENT = `# Project Knowledge
-
-This project uses [Fabric](https://github.com/fenglimg/fabric) for cross-client AI knowledge management.
-
-Knowledge entries live in \`.fabric/knowledge/\` (team) and \`~/.fabric/knowledge/\` (personal).
-Run \`fabric doctor\` to verify state.
-
-See \`.fabric/knowledge/\` for project decisions, pitfalls, guidelines, models, and processes.
-`;
 var LOCAL_FABRIC_SERVER_PATH = join3("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
 var FABRIC_SERVER_PACKAGE = "@fenglimg/fabric-server";
 var INIT_WIZARD_GROUP_CANCELLED = /* @__PURE__ */ Symbol("init-wizard-group-cancelled");
@@ -1626,9 +1624,6 @@ async function executeInitFabricPlan(plan) {
   }
   mkdirSync(plan.fabricDir, { recursive: true });
   writeDefaultFabricConfig(plan.fabricDir, plan.target);
-  if (plan.agentsMdAction === "created" && !existsSync3(plan.agentsMdPath)) {
-    await atomicWriteText(plan.agentsMdPath, AGENTS_MD_DEFAULT_CONTENT);
-  }
   mkdirSync(plan.knowledgeDir, { recursive: true });
   for (const sub of KNOWLEDGE_SUBDIRS) {
     const teamSubDir = join3(plan.knowledgeDir, sub);
@@ -1820,11 +1815,14 @@ async function executeInitStagePlan(plan, stageName) {
         installResults.push(...await runBestEffort("hook-script", () => installArchiveHintHook(plan.target)));
         installResults.push(...await runBestEffort("hook-broad-script", () => installKnowledgeHintBroadHook(plan.target)));
         installResults.push(...await runBestEffort("hook-narrow-script", () => installKnowledgeHintNarrowHook(plan.target)));
+        installResults.push(...await runBestEffort("hook-lib", () => installHookLibs(plan.target)));
         installResults.push(await runBestEffortSingle("claude-hook-config", () => mergeClaudeCodeHookConfig(plan.target)));
         installResults.push(await runBestEffortSingle("codex-hook-config", () => mergeCodexHookConfig(plan.target)));
         installResults.push(await runBestEffortSingle("cursor-hook-config", () => mergeCursorHookConfig(plan.target)));
-        const fabricLanguage = readFabricLanguagePreference(plan.target);
-        installResults.push(...await runBestEffort("section", () => addFabricKnowledgeBaseSection(plan.target, fabricLanguage)));
+        installResults.push(await runBestEffortSingle("bootstrap-snapshot", () => writeFabricAgentsSnapshot(plan.target)));
+        installResults.push(await runBestEffortSingle("bootstrap-claude", () => writeClaudeBootstrapThinShell(plan.target)));
+        installResults.push(await runBestEffortSingle("bootstrap-codex", () => writeCodexBootstrapManagedBlock(plan.target)));
+        installResults.push(await runBestEffortSingle("bootstrap-cursor", () => writeCursorBootstrapManagedBlock(plan.target)));
         const installedCount = installResults.filter((r) => r.status === "written").length;
         const skippedCount = installResults.filter((r) => r.status === "skipped").length;
         const errorCount = installResults.filter((r) => r.status === "error").length;

package/dist/{plan-context-hint-73U4FGKO.js → plan-context-hint-CFDGXHCA.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-ZSESMG6L.js";
 
 // src/commands/plan-context-hint.ts
 import { defineCommand } from "citty";
@@ -66,17 +66,17 @@ async function runPlanContextHint(opts) {
     // scope_glob matches the requested path.
     dedupeByStableId(result.entries.flatMap((entry) => entry.description_index))
   );
-  const narrow = narrowSource.map((item) => ({
+  const entries = narrowSource.map((item) => ({
     id: item.stable_id,
     type: item.type ?? item.description.knowledge_type ?? "",
     maturity: item.maturity ?? item.description.maturity ?? "",
     summary: item.description.summary
   }));
   return {
-    version: 1,
+    version: 2,
     revision_hash: result.revision_hash,
     target_paths: targetPaths,
-    narrow,
+    entries,
     broad_count: sharedIndex.length
   };
 }

package/dist/{serve-L3X5UHG2.js → serve-6PPQX7AW.js}

@@ -11,7 +11,7 @@ import {
 import {
   createDebugLogger,
   resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-ZSESMG6L.js";
 
 // src/commands/serve.ts
 import { defineCommand } from "citty";