@fenglimg/fabric-cli 2.0.0-rc.36 → 2.0.0-rc.37

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wangzhichao (fenglimg)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/{chunk-XVS4F3P6.js → chunk-D25XJ4BC.js}

@@ -96,11 +96,19 @@ var HOOK_SCRIPT_DESTINATIONS = {
     ".codex/hooks/knowledge-hint-narrow.cjs",
     ".cursor/hooks/knowledge-hint-narrow.cjs"
   ],
-  // v2.0.0-rc.34 TASK-06: Claude Code only — UserPromptSubmit cite-policy
-  // long-session evict sidecar. Codex / Cursor don't have an equivalent
-  // event registration; cite-coverage telemetry there relies on the existing
-  // Stop / SessionStart hooks (knowledge-hint-broad rc.33 W2 channel).
-  citePolicyEvict: [".claude/hooks/cite-policy-evict.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",
@@ -314,6 +322,41 @@ async function installSkillRefFiles(projectRoot, skillSlug) {
   }
   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));
@@ -822,6 +865,7 @@ export {
   installFabricReviewSkill,
   installFabricImportSkill,
   cleanupDeprecatedSkills,
+  installSharedSkillLib,
   installArchiveHintHook,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,

package/dist/{chunk-G2CIOLD4.js → chunk-WWNXR34K.js}

@@ -41,24 +41,9 @@ function padEnd(value, width, char = " ") {
   return result;
 }
 
-// src/lib/error-render.ts
-function hasActionHint(err) {
-  if (err === null || typeof err !== "object") return false;
-  const candidate = err;
-  return typeof candidate.message === "string" && candidate.message.length > 0 && typeof candidate.actionHint === "string" && candidate.actionHint.length > 0;
-}
-function renderFabricError(err, stream = process.stderr) {
-  stream.write(`${err.message}
-`);
-  stream.write(`  -> ${err.actionHint}
-`);
-}
-
 export {
   paint,
   symbol,
   displayWidth,
-  padEnd,
-  hasActionHint,
-  renderFabricError
+  padEnd
 };

package/dist/{doctor-2FCRAWDZ.js → doctor-764NFF3X.js}

@@ -1,29 +1,27 @@
 #!/usr/bin/env node
 import {
-  hasActionHint,
   paint,
-  renderFabricError,
   symbol
-} from "./chunk-G2CIOLD4.js";
+} from "./chunk-WWNXR34K.js";
+import {
+  resolveDevMode
+} from "./chunk-COI5VDFU.js";
 import {
   getDoctorTranslator,
   t
 } from "./chunk-PWLW3B57.js";
-import {
-  resolveDevMode
-} from "./chunk-COI5VDFU.js";
 
 // src/commands/doctor.ts
 import { confirm, isCancel } from "@clack/prompts";
 import { defineCommand } from "citty";
 import {
   appendEventLedgerEvent,
-  checkLockOrThrow,
   enrichDescriptions,
   runDoctorApplyLint as runDoctorFixKnowledge,
   runDoctorArchiveHistory,
   runDoctorCiteCoverage,
   runDoctorFix,
+  runDoctorHistoryAll,
   runDoctorReport
 } from "@fenglimg/fabric-server";
 var FIX_KNOWLEDGE_CODE_LABELS = {
@@ -135,21 +133,22 @@ var doctorCommand = defineCommand({
       type: "boolean",
       description: t("cli.doctor.args.archive-history.description"),
       default: false
+    },
+    // rc.37 NEW-33: unified history view across archive / fix / all surfaces.
+    // Mode = `archive | fix | all` (the `archive` mode delegates to the
+    // existing runDoctorArchiveHistory; `fix` aggregates doctor_run events;
+    // `all` rolls up both into a per-day count table). Read-only; mutex
+    // with the mutation arms.
+    history: {
+      type: "string",
+      description: t("cli.doctor.args.history.description"),
+      valueHint: "archive|fix|all"
     }
   },
   async run({ args }) {
     const workspaceRoot = process.cwd();
     const resolution = resolveDevMode(args.target, workspaceRoot);
     const dt = getDoctorTranslator(resolution.target);
-    try {
-      checkLockOrThrow(resolution.target);
-    } catch (err) {
-      if (hasActionHint(err)) {
-        renderFabricError(err);
-        process.exit(1);
-      }
-      throw err;
-    }
     const fixKnowledge = args["fix-knowledge"] === true;
     const fix = args.fix === true;
     const citeCoverage = args["cite-coverage"] === true;
@@ -164,6 +163,44 @@ var doctorCommand = defineCommand({
         return;
       }
     }
+    const historyMode = args.history;
+    if (typeof historyMode === "string" && historyMode.length > 0) {
+      if (fix || fixKnowledge || citeCoverage || enrichDesc || archiveHistory) {
+        writeStderr(dt("cli.doctor.errors.history-mutex"));
+        process.exitCode = 1;
+        return;
+      }
+      if (historyMode !== "archive" && historyMode !== "fix" && historyMode !== "all") {
+        writeStderr(dt("cli.doctor.errors.invalid-history-mode", { input: historyMode }));
+        process.exitCode = 1;
+        return;
+      }
+      const sinceInput = args.since ?? "7d";
+      let sinceMs;
+      try {
+        sinceMs = parseSinceDuration(sinceInput);
+      } catch {
+        writeStderr(dt("cli.doctor.errors.invalid-since", { input: sinceInput }));
+        process.exitCode = 1;
+        return;
+      }
+      if (historyMode === "archive") {
+        const report3 = await runDoctorArchiveHistory(resolution.target, { since: sinceMs });
+        if (args.json === true) {
+          writeStdout(JSON.stringify(report3, null, 2));
+        } else {
+          renderArchiveHistoryReport(report3, sinceInput, dt);
+        }
+        return;
+      }
+      const report2 = await runDoctorHistoryAll(resolution.target, { since: sinceMs });
+      if (args.json === true) {
+        writeStdout(JSON.stringify(report2, null, 2));
+      } else {
+        renderHistoryAllReport(report2, sinceInput, historyMode, dt);
+      }
+      return;
+    }
     if (archiveHistory) {
       if (fix || fixKnowledge || citeCoverage || enrichDesc) {
         writeStderr(dt("cli.doctor.errors.archive-history-mutex"));
@@ -319,6 +356,7 @@ var doctorCommand = defineCommand({
 var doctor_default = doctorCommand;
 function renderHumanReport(report, dt, verbose) {
   writeStdout(`${renderStatus(report.status)} ${paint.ai("fabric doctor")} ${paint.human(report.summary.target)}`);
+  renderTldrHeader(report);
   for (const check of report.checks) {
     writeStdout(`${renderStatus(check.status)} ${check.name}: ${check.message}`);
   }
@@ -372,6 +410,31 @@ function writeIssueSection(title, issues, options) {
     }
   }
 }
+function renderTldrHeader(report) {
+  const ranked = [];
+  for (const issue of report.fixable_errors) {
+    ranked.push({ severity: "fixable", code: issue.code, message: issue.message });
+  }
+  for (const issue of report.manual_errors) {
+    ranked.push({ severity: "manual", code: issue.code, message: issue.message });
+  }
+  for (const issue of report.warnings) {
+    ranked.push({ severity: "warn", code: issue.code, message: issue.message });
+  }
+  if (ranked.length === 0) {
+    writeStdout(`${symbol.ok} TL;DR: all 48 checks green \u2014 nothing to fix.`);
+    return;
+  }
+  const top3 = ranked.slice(0, 3);
+  writeStdout(
+    `TL;DR (top ${top3.length} of ${ranked.length}, severity order: fixable\u2192manual\u2192warn):`
+  );
+  for (const item of top3) {
+    const marker = item.severity === "fixable" ? symbol.error : item.severity === "manual" ? symbol.error : symbol.warn;
+    const truncated = item.message.length > 140 ? `${item.message.slice(0, 137)}...` : item.message;
+    writeStdout(`  ${marker} ${item.code}: ${truncated}`);
+  }
+}
 function renderStatus(status) {
   if (status === "ok") {
     return symbol.ok;
@@ -692,6 +755,39 @@ function renderArchiveHistoryReport(report, sinceLabel, dt) {
   }
   writeStdout(lines.join("\n"));
 }
+function renderHistoryAllReport(report, sinceLabel, mode, dt) {
+  if (report.rows.length === 0) {
+    writeStdout(dt("doctor.history.empty", { sinceLabel, mode }));
+    return;
+  }
+  const lines = [];
+  lines.push(
+    dt("doctor.history.header", {
+      sinceLabel,
+      mode,
+      days: String(report.rows.length)
+    })
+  );
+  lines.push("");
+  if (mode === "fix") {
+    lines.push("| date       | lint | fix | issues | mutations |");
+    lines.push("| ---------- | ---- | --- | ------ | --------- |");
+    for (const row of report.rows) {
+      lines.push(
+        `| ${row.date} | ${row.doctor_runs_lint} | ${row.doctor_runs_fix} | ${row.doctor_total_issues} | ${row.doctor_total_mutations} |`
+      );
+    }
+  } else {
+    lines.push("| date       | lint | fix | issues | mutations | archive | proposed |");
+    lines.push("| ---------- | ---- | --- | ------ | --------- | ------- | -------- |");
+    for (const row of report.rows) {
+      lines.push(
+        `| ${row.date} | ${row.doctor_runs_lint} | ${row.doctor_runs_fix} | ${row.doctor_total_issues} | ${row.doctor_total_mutations} | ${row.archive_attempts} | ${row.archive_proposed} |`
+      );
+    }
+  }
+  writeStdout(lines.join("\n"));
+}
 function formatTimestampForTable(iso) {
   const d = new Date(iso);
   if (Number.isNaN(d.getTime())) return iso;

package/dist/index.js

@@ -11,22 +11,23 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  install: () => import("./install-XSUIX6AD.js").then((module) => module.default),
-  doctor: () => import("./doctor-2FCRAWDZ.js").then((module) => module.default),
-  serve: () => import("./serve-43JTEM3U.js").then((module) => module.default),
-  uninstall: () => import("./uninstall-BIJ5GLEU.js").then((module) => module.default),
+  install: () => import("./install-U7MGIJ2L.js").then((module) => module.default),
+  doctor: () => import("./doctor-764NFF3X.js").then((module) => module.default),
+  uninstall: () => import("./uninstall-MH7ZIB6M.js").then((module) => module.default),
   config: () => import("./config-XJIPZNUP.js").then((module) => module.default),
   "plan-context-hint": () => import("./plan-context-hint-UQLRKGBZ.js").then((module) => module.default),
   // v2.0.0-rc.23 TASK-014 (F8c): S5 onboard-slot coverage. Used by the
   // fabric-archive Skill's first-run phase to detect unclaimed slots.
-  "onboard-coverage": () => import("./onboard-coverage-MFCAEBDO.js").then((module) => module.default)
+  "onboard-coverage": () => import("./onboard-coverage-MFCAEBDO.js").then((module) => module.default),
+  // v2.0.0-rc.37 NEW-34: text dashboard over .fabric/metrics.jsonl.
+  metrics: () => import("./metrics-ACEQFPDU.js").then((module) => module.default)
 };
 
 // src/index.ts
 var main = defineCommand({
   meta: {
     name: "fabric",
-    version: "2.0.0-rc.36",
+    version: "2.0.0-rc.37",
     description: t("cli.main.description")
   },
   subCommands: allCommands

package/dist/{install-XSUIX6AD.js → install-U7MGIJ2L.js}

@@ -12,6 +12,7 @@ import {
   installHookLibs,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,
+  installSharedSkillLib,
   mergeClaudeCodeHookConfig,
   mergeCodexHookConfig,
   mergeCursorHookConfig,
@@ -20,24 +21,22 @@ import {
   writeCodexBootstrapManagedBlock,
   writeCursorBootstrapManagedBlock,
   writeFabricAgentsSnapshot
-} from "./chunk-XVS4F3P6.js";
+} from "./chunk-D25XJ4BC.js";
 import {
   detectClientSupports
 } from "./chunk-MF3OTILQ.js";
 import {
   displayWidth,
-  hasActionHint,
   padEnd,
-  paint,
-  renderFabricError
-} from "./chunk-G2CIOLD4.js";
-import {
-  t
-} from "./chunk-PWLW3B57.js";
+  paint
+} from "./chunk-WWNXR34K.js";
 import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-COI5VDFU.js";
+import {
+  t
+} from "./chunk-PWLW3B57.js";
 
 // src/commands/install.ts
 import { randomUUID } from "crypto";
@@ -49,7 +48,6 @@ import { cancel, confirm, group, intro, isCancel, log, note, outro, select } fro
 import { defaultAgentsMetaCounters } from "@fenglimg/fabric-shared";
 import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
 import { defineCommand } from "citty";
-import { checkLockOrThrow } from "@fenglimg/fabric-server";
 
 // src/install/hooks-orchestrator.ts
 import { existsSync, statSync } from "fs";
@@ -61,6 +59,7 @@ async function installHooks(target, _options = {}) {
   results.push(...await runStep(() => installFabricArchiveSkill(normalizedTarget)));
   results.push(...await runStep(() => installFabricReviewSkill(normalizedTarget)));
   results.push(...await runStep(() => installFabricImportSkill(normalizedTarget)));
+  results.push(...await runStep(() => installSharedSkillLib(normalizedTarget)));
   results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
   results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
   results.push(...await runStep(() => installKnowledgeHintNarrowHook(normalizedTarget)));
@@ -1351,7 +1350,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0-rc.36" : "unknown";
+  return true ? "2.0.0-rc.37" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1393,6 +1392,11 @@ var installCommand = defineCommand({
       type: "boolean",
       description: t("cli.install.args.force-skills-only.description"),
       default: false
+    },
+    "force-hooks-only": {
+      type: "boolean",
+      description: t("cli.install.args.force-hooks-only.description"),
+      default: false
     }
   },
   async run({ args }) {
@@ -1443,6 +1447,35 @@ ${hint}
     process.exitCode = 1;
   }
 }
+async function runHooksOnlyRefresh(targetInput) {
+  const target = normalizeTarget3(targetInput);
+  const metaPath = join4(target, ".fabric", "agents.meta.json");
+  if (!existsSync4(metaPath)) {
+    const message = t("cli.install.force-hooks-only.uninitialised.message");
+    const hint = t("cli.install.force-hooks-only.uninitialised.hint");
+    process.stderr.write(`${message}
+${hint}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(formatInitStageHeader(t("cli.install.force-hooks-only.banner")));
+  const result = await installHooks(target);
+  console.log(
+    t("cli.install.force-hooks-only.summary", {
+      written: String(result.installed.length),
+      skipped: String(result.skipped.length),
+      errors: String(result.errors.length)
+    })
+  );
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      process.stderr.write(`  ${err}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
 async function runInitCommand(args) {
   const logger = createDebugLogger(args.debug);
   const resolution = resolveDevMode(args.target, process.cwd());
@@ -1450,19 +1483,11 @@ async function runInitCommand(args) {
     await runSkillsOnlyRefresh(resolution.target);
     return;
   }
-  const intent = resolveInitCliIntent(args, resolution.target);
-  const fabricInitialized = existsSync4(join4(intent.target, ".fabric", "events.jsonl"));
-  if (fabricInitialized) {
-    try {
-      checkLockOrThrow(intent.target);
-    } catch (err) {
-      if (hasActionHint(err)) {
-        renderFabricError(err);
-        process.exit(1);
-      }
-      throw err;
-    }
+  if (args["force-hooks-only"] === true) {
+    await runHooksOnlyRefresh(resolution.target);
+    return;
   }
+  const intent = resolveInitCliIntent(args, resolution.target);
   logger(`init target source: ${resolution.source}`);
   for (const step of resolution.chain) {
     logger(step);
@@ -2335,6 +2360,8 @@ function printInitCapabilitySummary(supports, stageResults, options) {
   for (const row of rows) {
     console.log(formatCapabilityTableRow(row, widths));
   }
+  console.log("");
+  console.log(t("cli.install.restart-banner"));
 }
 function toCapabilityRow(support, stageResults, options) {
   const stage = (name) => stageResults.find((entry) => entry.name === name)?.disposition ?? null;
@@ -2455,6 +2482,7 @@ export {
   initFabric,
   installCommand,
   resolveInitExecutionPlanWithWizard,
+  runHooksOnlyRefresh,
   runInitCommand,
   runSkillsOnlyRefresh,
   shouldUseInitWizard

package/dist/metrics-ACEQFPDU.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+// src/commands/metrics.ts
+import { resolve } from "path";
+import { defineCommand } from "citty";
+import { readMetrics } from "@fenglimg/fabric-server";
+function parseSinceArg(raw) {
+  if (raw === void 0 || raw.length === 0) return 0;
+  const match = /^(\d+)([smhd]?)$/u.exec(raw);
+  if (match === null) {
+    throw new Error(`--since: invalid duration "${raw}" (expected e.g. 24h, 7d, 30m)`);
+  }
+  const n = Number.parseInt(match[1], 10);
+  const unit = match[2] ?? "s";
+  const multipliers = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+  return n * (multipliers[unit] ?? 1e3);
+}
+function aggregate(rows, sinceMs, now) {
+  const cutoff = sinceMs > 0 ? now.getTime() - sinceMs : 0;
+  const filtered = rows.filter((r) => {
+    if (cutoff === 0) return true;
+    const ts = Date.parse(r.timestamp);
+    return Number.isFinite(ts) && ts >= cutoff;
+  });
+  const totals = {};
+  const perEntryConsumed = {};
+  for (const row of filtered) {
+    for (const [name, count] of Object.entries(row.counters)) {
+      if (name.startsWith("knowledge_consumed:")) {
+        const id = name.slice("knowledge_consumed:".length);
+        perEntryConsumed[id] = (perEntryConsumed[id] ?? 0) + count;
+        totals["knowledge_consumed"] = (totals["knowledge_consumed"] ?? 0) + count;
+        continue;
+      }
+      totals[name] = (totals[name] ?? 0) + count;
+    }
+  }
+  return {
+    windowDescription: sinceMs > 0 ? formatDuration(sinceMs) : "all-time",
+    rowCount: filtered.length,
+    totals,
+    perEntryConsumed,
+    rangeStart: filtered[0]?.timestamp ?? null,
+    rangeEnd: filtered[filtered.length - 1]?.timestamp ?? null
+  };
+}
+function formatDuration(ms) {
+  if (ms >= 864e5) return `${Math.round(ms / 864e5)}d`;
+  if (ms >= 36e5) return `${Math.round(ms / 36e5)}h`;
+  if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+function renderText(agg) {
+  const lines = [];
+  lines.push(`Fabric metrics \u2014 window: ${agg.windowDescription}`);
+  if (agg.rangeStart && agg.rangeEnd) {
+    lines.push(`  rows: ${agg.rowCount} (${agg.rangeStart} \u2192 ${agg.rangeEnd})`);
+  } else {
+    lines.push(`  rows: ${agg.rowCount}`);
+  }
+  lines.push("");
+  if (Object.keys(agg.totals).length === 0) {
+    lines.push("  (no counter activity in window \u2014 server may be idle or just started)");
+    return lines.join("\n");
+  }
+  lines.push("  counter                              total");
+  lines.push("  ------------------------------------ ----------");
+  const sorted = Object.entries(agg.totals).sort((a, b) => b[1] - a[1]);
+  for (const [name, count] of sorted) {
+    lines.push(`  ${name.padEnd(36)} ${String(count).padStart(10)}`);
+  }
+  const perEntrySorted = Object.entries(agg.perEntryConsumed).sort((a, b) => b[1] - a[1]).slice(0, 10);
+  if (perEntrySorted.length > 0) {
+    lines.push("");
+    lines.push("  Top per-entry consumed (knowledge_consumed:<id>)");
+    lines.push("  ------------------------------------ ----------");
+    for (const [id, count] of perEntrySorted) {
+      lines.push(`  ${id.padEnd(36)} ${String(count).padStart(10)}`);
+    }
+  }
+  return lines.join("\n");
+}
+var metricsCommand = defineCommand({
+  meta: {
+    name: "metrics",
+    description: "Print a text dashboard of Fabric counter activity from .fabric/metrics.jsonl",
+    hidden: true
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON instead of the text table.",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Project root (defaults to the current working directory)."
+    },
+    since: {
+      type: "string",
+      description: "Limit to rows within a recent window. Examples: 24h, 7d, 30m, 90s. Omit for all-time."
+    }
+  },
+  async run({ args }) {
+    const projectRoot = resolve(args.target ?? process.cwd());
+    const sinceMs = parseSinceArg(args.since);
+    const rows = await readMetrics(projectRoot);
+    const aggregated = aggregate(rows, sinceMs, /* @__PURE__ */ new Date());
+    if (args.json === true) {
+      process.stdout.write(`${JSON.stringify(aggregated)}
+`);
+    } else {
+      process.stdout.write(`${renderText(aggregated)}
+`);
+    }
+  }
+});
+var metrics_default = metricsCommand;
+export {
+  metrics_default as default,
+  metricsCommand
+};

package/dist/{uninstall-BIJ5GLEU.js → uninstall-MH7ZIB6M.js}

@@ -7,23 +7,21 @@ import {
   HOOK_SCRIPT_DESTINATIONS,
   SKILL_DESTINATIONS,
   fabricAgentsSnapshotPath
-} from "./chunk-XVS4F3P6.js";
+} from "./chunk-D25XJ4BC.js";
 import {
   detectClientSupports,
   resolveClients
 } from "./chunk-MF3OTILQ.js";
 import {
-  hasActionHint,
-  paint,
-  renderFabricError
-} from "./chunk-G2CIOLD4.js";
-import {
-  t
-} from "./chunk-PWLW3B57.js";
+  paint
+} from "./chunk-WWNXR34K.js";
 import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-COI5VDFU.js";
+import {
+  t
+} from "./chunk-PWLW3B57.js";
 
 // src/commands/uninstall.ts
 import { existsSync as existsSync2, statSync } from "fs";
@@ -32,7 +30,6 @@ import { homedir } from "os";
 import { isAbsolute, join as join2, relative, resolve, sep } from "path";
 import { cancel, confirm, group, intro, isCancel, log, note, outro } from "@clack/prompts";
 import { defineCommand } from "citty";
-import { checkLockOrThrow } from "@fenglimg/fabric-server";
 
 // src/install/uninstall-skills-and-hooks.ts
 import { existsSync } from "fs";
@@ -570,15 +567,6 @@ async function runUninstallCommand(args) {
   for (const step of resolution.chain) {
     logger(step);
   }
-  try {
-    checkLockOrThrow(intent.target);
-  } catch (err) {
-    if (hasActionHint(err)) {
-      renderFabricError(err);
-      process.exit(1);
-    }
-    throw err;
-  }
   const supports = detectClientSupports(intent.target);
   const basePlan = await buildUninstallExecutionPlan(intent.target, {
     ...intent.options