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

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

@@ -1,11 +1,7 @@
 #!/usr/bin/env node
 import {
   installMcpClients
-} from "./chunk-KZ2YITOS.js";
-import {
-  detectExistingLanguage,
-  runInitScan
-} from "./chunk-FNO7CQDG.js";
+} from "./chunk-STLR2GHP.js";
 import {
   installArchiveHintHook,
   installFabricArchiveSkill,
@@ -22,7 +18,7 @@ import {
   writeCodexBootstrapManagedBlock,
   writeCursorBootstrapManagedBlock,
   writeFabricAgentsSnapshot
-} from "./chunk-4HC5ZK7H.js";
+} from "./chunk-AXKII55Y.js";
 import {
   detectClientSupports
 } from "./chunk-MF3OTILQ.js";
@@ -39,14 +35,14 @@ import {
 import {
   createDebugLogger,
   resolveDevMode
-} from "./chunk-ZSESMG6L.js";
+} from "./chunk-COI5VDFU.js";
 
 // src/commands/install.ts
 import { randomUUID } from "crypto";
 import { homedir } from "os";
 import * as childProcess from "child_process";
-import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync, statSync as statSync3, writeFileSync } from "fs";
-import { dirname, isAbsolute as isAbsolute3, join as join3, resolve as resolve3 } from "path";
+import { appendFileSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, rmSync, statSync as statSync4, writeFileSync } from "fs";
+import { dirname, isAbsolute as isAbsolute3, join as join4, 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 } from "@fenglimg/fabric-shared/node/atomic-write";
@@ -184,11 +180,64 @@ function assertExistingDirectory(target) {
   }
 }
 
+// src/lib/detect-language.ts
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
+function detectExistingLanguage(target) {
+  const ZH_CN_RATIO_THRESHOLD = 0.3;
+  const samples = [];
+  const readmePath = join2(target, "README.md");
+  if (existsSync2(readmePath)) {
+    try {
+      samples.push(readFileSync(readmePath, "utf8"));
+    } catch {
+    }
+  }
+  const docsDir = join2(target, "docs");
+  if (existsSync2(docsDir)) {
+    try {
+      const stat = statSync2(docsDir);
+      if (stat.isDirectory()) {
+        for (const entry of readdirSync(docsDir, { withFileTypes: true })) {
+          if (!entry.isFile()) continue;
+          if (!/\.(md|mdx|txt)$/iu.test(entry.name)) continue;
+          try {
+            samples.push(readFileSync(join2(docsDir, entry.name), "utf8"));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (samples.length === 0) {
+    return "en";
+  }
+  let cjkCount = 0;
+  let asciiLetterCount = 0;
+  for (const sample of samples) {
+    for (const ch of sample) {
+      const code = ch.codePointAt(0) ?? 0;
+      if (code >= 19968 && code <= 40959) {
+        cjkCount += 1;
+      } else if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+        asciiLetterCount += 1;
+      }
+    }
+  }
+  const denominator = cjkCount + asciiLetterCount;
+  if (denominator === 0) {
+    return "en";
+  }
+  const ratio = cjkCount / denominator;
+  return ratio > ZH_CN_RATIO_THRESHOLD ? "zh-CN-hybrid" : "en";
+}
+
 // src/scanner/forensic.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync2, readdirSync, readFileSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
 import { createRequire } from "module";
-import { basename, extname, isAbsolute as isAbsolute2, join as join2, posix, relative, resolve as resolve2, sep } from "path";
+import { basename, extname, isAbsolute as isAbsolute2, join as join3, posix, relative, resolve as resolve2, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
@@ -331,8 +380,8 @@ function buildTopology(root) {
     if (current === void 0) {
       continue;
     }
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join2(current, entry.name);
+    for (const entry of readdirSync2(current, { withFileTypes: true })) {
+      const absolutePath = join3(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -352,7 +401,7 @@ function buildTopology(root) {
       if (!entry.isFile()) {
         continue;
       }
-      const stats = statSync2(absolutePath);
+      const stats = statSync3(absolutePath);
       const extension = extname(entry.name) || "[none]";
       byExt[extension] = (byExt[extension] ?? 0) + 1;
       totalFiles += 1;
@@ -371,7 +420,7 @@ function buildTopology(root) {
   };
 }
 function assertExistingDirectory2(target) {
-  if (!existsSync2(target) || !statSync2(target).isDirectory()) {
+  if (!existsSync3(target) || !statSync3(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
@@ -420,7 +469,7 @@ function getEntryPointReason(relativePath) {
 async function buildCodeSamples(target, entryPoints, frameworkKind, topology, packageDependencies) {
   const samples = [];
   for (const entryPoint of entryPoints.slice(0, SAMPLE_LIMIT)) {
-    const absolutePath = join2(target, ...entryPoint.path.split("/"));
+    const absolutePath = join3(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
     const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
       frameworkKind,
@@ -440,7 +489,7 @@ async function buildCodeSamples(target, entryPoints, frameworkKind, topology, pa
 }
 function readFirstLines(path, lineLimit) {
   try {
-    const lines = readFileSync(path, "utf8").split(/\r?\n/);
+    const lines = readFileSync2(path, "utf8").split(/\r?\n/);
     if (lines.at(-1) === "") {
       lines.pop();
     }
@@ -457,12 +506,12 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join2(target, "package.json");
-  if (!existsSync2(packageJsonPath)) {
+  const packageJsonPath = join3(target, "package.json");
+  if (!existsSync3(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
   try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
     return new Map([
       ...Object.entries(packageJson.dependencies ?? {}),
       ...Object.entries(packageJson.devDependencies ?? {}),
@@ -798,16 +847,16 @@ function scoreFrameworkConfidence(input) {
   return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
 }
 function readReadmeInfo(target) {
-  const readmePath = join2(target, "README.md");
-  const hasContributing = existsSync2(join2(target, "CONTRIBUTING.md"));
-  if (!existsSync2(readmePath)) {
+  const readmePath = join3(target, "README.md");
+  const hasContributing = existsSync3(join3(target, "CONTRIBUTING.md"));
+  if (!existsSync3(readmePath)) {
     return {
       quality: "missing",
       line_count: 0,
       has_contributing: hasContributing
     };
   }
-  const readme = readFileSync(readmePath, "utf8");
+  const readme = readFileSync2(readmePath, "utf8");
   const wordCount = readme.trim().split(/\s+/).filter(Boolean).length;
   return {
     quality: wordCount >= 200 ? "ok" : "stub",
@@ -1285,10 +1334,10 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 function readProjectName(target) {
-  const packageJsonPath = join2(target, "package.json");
-  if (existsSync2(packageJsonPath)) {
+  const packageJsonPath = join3(target, "package.json");
+  if (existsSync3(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
         return packageJson.name;
       }
@@ -1299,7 +1348,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0-rc.21" : "unknown";
+  return true ? "2.0.0-rc.23" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1309,7 +1358,7 @@ function toPosixPath(path) {
 }
 
 // src/commands/install.ts
-var LOCAL_FABRIC_SERVER_PATH = join3("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+var LOCAL_FABRIC_SERVER_PATH = join4("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");
 var installCommand = defineCommand({
@@ -1347,7 +1396,7 @@ async function runInitCommand(args) {
   const logger = createDebugLogger(args.debug);
   const resolution = resolveDevMode(args.target, process.cwd());
   const intent = resolveInitCliIntent(args, resolution.target);
-  const fabricInitialized = existsSync3(join3(intent.target, ".fabric", "events.jsonl"));
+  const fabricInitialized = existsSync4(join4(intent.target, ".fabric", "events.jsonl"));
   if (fabricInitialized) {
     try {
       checkLockOrThrow(intent.target);
@@ -1384,8 +1433,8 @@ async function runInitCommand(args) {
   return result;
 }
 function writeDefaultFabricConfig(fabricDir, targetRoot) {
-  const target = join3(fabricDir, "fabric-config.json");
-  if (existsSync3(target)) return;
+  const target = join4(fabricDir, "fabric-config.json");
+  if (existsSync4(target)) return;
   const detectedLanguage = detectExistingLanguage(targetRoot);
   const FABRIC_CONFIG_DEFAULTS = {
     // Scan/import language policy. Fixated at init time by probing
@@ -1524,7 +1573,7 @@ async function executeInitExecutionPlan(plan) {
       finalSupports: plan.supports
     };
   }
-  if (existsSync3(plan.scaffold.fabricDir) && !statSync3(plan.scaffold.fabricDir).isDirectory()) {
+  if (existsSync4(plan.scaffold.fabricDir) && !statSync4(plan.scaffold.fabricDir).isDirectory()) {
     throw new Error(
       t("cli.install.diff.drift-abort", { path: plan.scaffold.fabricDir })
     );
@@ -1577,16 +1626,16 @@ function resolvePersonalFabricRoot() {
 }
 async function buildInitFabricPlan(target, options) {
   assertExistingDirectory3(target);
-  const fabricDir = join3(target, ".fabric");
-  const agentsMdPath = join3(target, "AGENTS.md");
-  const agentsMdAction = existsSync3(agentsMdPath) ? "preserved" : "created";
-  const knowledgeDir = join3(fabricDir, "knowledge");
-  const personalKnowledgeDir = join3(resolvePersonalFabricRoot(), ".fabric", "knowledge");
-  const forensicPath = join3(fabricDir, "forensic.json");
-  const eventsPath = join3(fabricDir, "events.jsonl");
-  const metaPath = join3(fabricDir, "agents.meta.json");
+  const fabricDir = join4(target, ".fabric");
+  const agentsMdPath = join4(target, "AGENTS.md");
+  const agentsMdAction = existsSync4(agentsMdPath) ? "preserved" : "created";
+  const knowledgeDir = join4(fabricDir, "knowledge");
+  const personalKnowledgeDir = join4(resolvePersonalFabricRoot(), ".fabric", "knowledge");
+  const forensicPath = join4(fabricDir, "forensic.json");
+  const eventsPath = join4(fabricDir, "events.jsonl");
+  const metaPath = join4(fabricDir, "agents.meta.json");
   const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
-  const knowledgeDirAction = existsSync3(knowledgeDir) ? "overwritten" : "created";
+  const knowledgeDirAction = existsSync4(knowledgeDir) ? "overwritten" : "created";
   const metaClassification = classifyFreshPath(metaPath, "structural");
   const eventsClassification = classifyFreshPath(eventsPath, "presence");
   const forensicClassification = classifyFreshPath(forensicPath, "always-rewrite");
@@ -1626,17 +1675,17 @@ async function executeInitFabricPlan(plan) {
   writeDefaultFabricConfig(plan.fabricDir, plan.target);
   mkdirSync(plan.knowledgeDir, { recursive: true });
   for (const sub of KNOWLEDGE_SUBDIRS) {
-    const teamSubDir = join3(plan.knowledgeDir, sub);
+    const teamSubDir = join4(plan.knowledgeDir, sub);
     mkdirSync(teamSubDir, { recursive: true });
-    const teamGitkeep = join3(teamSubDir, ".gitkeep");
-    if (!existsSync3(teamGitkeep)) {
+    const teamGitkeep = join4(teamSubDir, ".gitkeep");
+    if (!existsSync4(teamGitkeep)) {
       writeFileSync(teamGitkeep, "", "utf8");
     }
   }
   try {
     mkdirSync(plan.personalKnowledgeDir, { recursive: true });
     for (const sub of KNOWLEDGE_SUBDIRS) {
-      mkdirSync(join3(plan.personalKnowledgeDir, sub), { recursive: true });
+      mkdirSync(join4(plan.personalKnowledgeDir, sub), { recursive: true });
     }
   } catch {
   }
@@ -1651,17 +1700,7 @@ async function executeInitFabricPlan(plan) {
   }
   preparePlannedPath(plan.forensicPath, plan.forensicAction);
   await atomicWriteJson(plan.forensicPath, plan.forensicReport);
-  const wasCanonicalReRun = plan.metaState === "present-canonical" && plan.eventsState === "present-canonical";
-  if (!wasCanonicalReRun) {
-    try {
-      await runInitScan(plan.target, { source: "init" });
-    } catch (error) {
-      writeStderr(
-        `[warn] init-scan failed: ${error instanceof Error ? error.message : String(error)} \u2014 re-run \`fab scan\` to populate baseline knowledge entries.`
-      );
-    }
-  }
-  if (existsSync3(plan.eventsPath)) {
+  if (existsSync4(plan.eventsPath)) {
     const applied = [];
     const canonical = [];
     const drifted = [];
@@ -1870,21 +1909,21 @@ async function executeInitStagePlan(plan, stageName) {
   }
 }
 function shouldReplaceWritableDirectory(path, _options) {
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return false;
   }
-  if (statSync3(path).isDirectory()) {
+  if (statSync4(path).isDirectory()) {
     return false;
   }
   return false;
 }
 function classifyFreshPath(path, strategy) {
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return { path, state: "missing" };
   }
   let stat;
   try {
-    stat = statSync3(path);
+    stat = statSync4(path);
   } catch (error) {
     return {
       path,
@@ -1899,7 +1938,7 @@ function classifyFreshPath(path, strategy) {
     return { path, state: "present-canonical" };
   }
   try {
-    const raw = readFileSync2(path, "utf8");
+    const raw = readFileSync3(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       return { path, state: "user-modified", reason: "not a JSON object" };
@@ -1928,7 +1967,7 @@ function formatDiffFileState(state) {
 }
 function preparePlannedPath(path, action) {
   mkdirSync(dirname(path), { recursive: true });
-  if (action === "overwritten" && existsSync3(path)) {
+  if (action === "overwritten" && existsSync4(path)) {
     rmSync(path, { recursive: true, force: true });
   }
 }
@@ -2082,19 +2121,19 @@ function normalizeTarget3(targetInput) {
   return isAbsolute3(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
 }
 function assertExistingDirectory3(target) {
-  if (!existsSync3(target) || !statSync3(target).isDirectory()) {
+  if (!existsSync4(target) || !statSync4(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
 function detectPackageManager(cwd) {
   const workspaceRoot = resolve3(cwd);
-  if (existsSync3(join3(workspaceRoot, "pnpm-lock.yaml"))) {
+  if (existsSync4(join4(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync3(join3(workspaceRoot, "yarn.lock"))) {
+  if (existsSync4(join4(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync3(join3(workspaceRoot, "package-lock.json"))) {
+  if (existsSync4(join4(workspaceRoot, "package-lock.json"))) {
     return "npm";
   }
   return "npm";

package/dist/onboard-coverage-JJ5NGU7I.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+// src/commands/onboard-coverage.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { defineCommand } from "citty";
+import {
+  ONBOARD_SLOT_NAMES,
+  ONBOARD_SLOT_TOTAL
+} from "@fenglimg/fabric-shared";
+var KNOWLEDGE_TYPE_DIRS = [
+  "decisions",
+  "pitfalls",
+  "guidelines",
+  "models",
+  "processes"
+];
+var FABRIC_CONFIG_PATH = [".fabric", "fabric-config.json"];
+function emptyFilled() {
+  const filled = {};
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    filled[slot] = [];
+  }
+  return filled;
+}
+function readOnboardSlotFrontmatter(filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const match = /^---\n([\s\S]*?)\n---/u.exec(content);
+  if (match === null) return void 0;
+  const block = match[1];
+  if (block === void 0) return void 0;
+  for (const rawLine of block.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    const key = line.slice(0, sep).trim();
+    if (key !== "onboard_slot") continue;
+    let value = line.slice(sep + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+      value = value.slice(1, -1);
+    }
+    return value;
+  }
+  return void 0;
+}
+function readStableIdFrontmatter(filePath, fallbackName) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return fallbackName.replace(/\.md$/u, "");
+  }
+  const match = /^---\n([\s\S]*?)\n---/u.exec(content);
+  if (match === null) return fallbackName.replace(/\.md$/u, "");
+  const block = match[1];
+  if (block === void 0) return fallbackName.replace(/\.md$/u, "");
+  for (const rawLine of block.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    if (line.slice(0, sep).trim() !== "id") continue;
+    return line.slice(sep + 1).trim();
+  }
+  return fallbackName.replace(/\.md$/u, "");
+}
+function readOptedOutSlots(projectRoot) {
+  const path = join(projectRoot, ...FABRIC_CONFIG_PATH);
+  if (!existsSync(path)) return [];
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    process.stderr.write(
+      `onboard-coverage: ignoring malformed fabric-config.json (${err instanceof Error ? err.message : String(err)})
+`
+    );
+    return [];
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return [];
+  }
+  const slots = parsed.onboard_slots_opted_out;
+  if (!Array.isArray(slots)) return [];
+  return slots.filter((v) => typeof v === "string");
+}
+function runOnboardCoverage(projectRoot) {
+  const filled = emptyFilled();
+  const knowledgeRoot = join(projectRoot, ".fabric", "knowledge");
+  if (existsSync(knowledgeRoot)) {
+    for (const typeDir of KNOWLEDGE_TYPE_DIRS) {
+      const dir = join(knowledgeRoot, typeDir);
+      if (!existsSync(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (!entry.name.endsWith(".md")) continue;
+        const filePath = join(dir, entry.name);
+        const slot = readOnboardSlotFrontmatter(filePath);
+        if (slot === void 0) continue;
+        if (!ONBOARD_SLOT_NAMES.includes(slot)) continue;
+        const stableId = readStableIdFrontmatter(filePath, entry.name);
+        filled[slot].push(stableId);
+      }
+    }
+  }
+  const optedOut = readOptedOutSlots(projectRoot);
+  const missing = ONBOARD_SLOT_NAMES.filter((slot) => {
+    if (filled[slot].length > 0) return false;
+    if (optedOut.includes(slot)) return false;
+    return true;
+  });
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    filled[slot].sort();
+  }
+  return {
+    filled,
+    missing,
+    opted_out: optedOut,
+    total: ONBOARD_SLOT_TOTAL
+  };
+}
+function renderHumanReadable(report) {
+  const filledCount = ONBOARD_SLOT_NAMES.filter(
+    (slot) => report.filled[slot].length > 0
+  ).length;
+  const optedOutCount = report.opted_out.length;
+  const missingCount = report.missing.length;
+  const lines = [];
+  lines.push(
+    `Onboard coverage: ${filledCount}/${report.total} filled, ${optedOutCount} opted-out, ${missingCount} missing`
+  );
+  lines.push("");
+  lines.push("  slot                       status      entries");
+  lines.push("  -------------------------- ----------- -------------------------");
+  for (const slot of ONBOARD_SLOT_NAMES) {
+    const entries = report.filled[slot];
+    let status;
+    let detail;
+    if (entries.length > 0) {
+      status = "filled";
+      detail = entries.join(", ");
+    } else if (report.opted_out.includes(slot)) {
+      status = "opted-out";
+      detail = "(user-dismissed; run `fab config onboard-reset` to re-open)";
+    } else {
+      status = "missing";
+      detail = "(run /fabric-archive to onboard)";
+    }
+    lines.push(`  ${slot.padEnd(26)} ${status.padEnd(11)} ${detail}`);
+  }
+  return lines.join("\n");
+}
+var onboardCoverageCommand = defineCommand({
+  meta: {
+    name: "onboard-coverage",
+    description: "Report S5 onboard-slot coverage for the workspace. Used by the fabric-archive Skill's first-run phase to detect unclaimed project-tone slots.",
+    // Mirrors `plan-context-hint`: hidden from `fab --help` so the top-level
+    // banner stays focused on install/doctor/serve/config. The command stays
+    // callable directly from Skills via `fab onboard-coverage --json`.
+    hidden: true
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON to stdout instead of the human table.",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Override the project root (defaults to cwd)."
+    }
+  },
+  async run({ args }) {
+    try {
+      const projectRoot = resolve(args.target ?? process.cwd());
+      const report = runOnboardCoverage(projectRoot);
+      if (args.json === true) {
+        process.stdout.write(`${JSON.stringify(report)}
+`);
+      } else {
+        process.stdout.write(`${renderHumanReadable(report)}
+`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`onboard-coverage failed: ${message}
+`);
+      process.exitCode = 1;
+    }
+  }
+});
+var onboard_coverage_default = onboardCoverageCommand;
+export {
+  onboard_coverage_default as default,
+  onboardCoverageCommand,
+  runOnboardCoverage
+};

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   resolveDevMode
-} from "./chunk-ZSESMG6L.js";
+} from "./chunk-COI5VDFU.js";
 
 // src/commands/plan-context-hint.ts
 import { defineCommand } from "citty";
@@ -72,13 +72,20 @@ async function runPlanContextHint(opts) {
     maturity: item.maturity ?? item.description.maturity ?? "",
     summary: item.description.summary
   }));
-  return {
+  const output = {
     version: 2,
     revision_hash: result.revision_hash,
     target_paths: targetPaths,
     entries,
     broad_count: sharedIndex.length
   };
+  if (result.auto_healed === true) {
+    output.auto_healed = true;
+    if (typeof result.previous_revision_hash === "string") {
+      output.previous_revision_hash = result.previous_revision_hash;
+    }
+  }
+  return output;
 }
 function parsePathsArg(raw) {
   if (raw === void 0 || raw.length === 0) {

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

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

package/dist/{uninstall-L2HEEOU3.js → uninstall-MQM6NUFM.js}

@@ -7,7 +7,7 @@ import {
   HOOK_SCRIPT_DESTINATIONS,
   SKILL_DESTINATIONS,
   fabricAgentsSnapshotPath
-} from "./chunk-4HC5ZK7H.js";
+} from "./chunk-AXKII55Y.js";
 import {
   detectClientSupports,
   resolveClients
@@ -23,7 +23,7 @@ import {
 import {
   createDebugLogger,
   resolveDevMode
-} from "./chunk-ZSESMG6L.js";
+} from "./chunk-COI5VDFU.js";
 
 // src/commands/uninstall.ts
 import { existsSync as existsSync2, statSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fenglimg/fabric-cli",
-  "version": "2.0.0-rc.21",
+  "version": "2.0.0-rc.23",
   "type": "module",
   "bin": {
     "fab": "dist/index.js",
@@ -20,8 +20,8 @@
     "tree-sitter-javascript": "^0.25.0",
     "tree-sitter-typescript": "^0.23.2",
     "web-tree-sitter": "^0.26.8",
-    "@fenglimg/fabric-server": "2.0.0-rc.21",
-    "@fenglimg/fabric-shared": "2.0.0-rc.21"
+    "@fenglimg/fabric-server": "2.0.0-rc.23",
+    "@fenglimg/fabric-shared": "2.0.0-rc.23"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",