@fenglimg/fabric-cli 2.2.0-rc.1 → 2.2.0-rc.4

package/templates/hooks/post-tooluse-mutation.cjs

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+/**
+ * lifecycle-refactor W2-T3 — PostToolUse mutation marker hook (previously
+ * dormant). Closes the mutation env opened by the PreToolUse narrow hint.
+ *
+ * PostToolUse fires AFTER an Edit/Write/MultiEdit tool call completes. This
+ * hook appends one `file_mutated` event per edited path to
+ * `.fabric/events.jsonl`, carrying the `tool_call_id` so doctor can pair the
+ * Pre (intent) and Post (mutation) halves of a single tool call — the per-call
+ * key also guards against parallel-fire races (two concurrent edits never
+ * collapse to one ledger key).
+ *
+ * Design (lifecycle-concept-final.md §1 FROZEN invariants + §5 row7):
+ *   - LOW compute: extract paths + tool_call_id, append; the hook never reads
+ *     or aggregates the ledger, never runs `git diff`. ALL mutation_pool /
+ *     attribution work is doctor-side (offline, §5 row7).
+ *   - hook = nudge/marker, never a gate (KT-DEC-0007): every error path ends
+ *     in a silent exit 0; we never throw upward.
+ *   - Front-stage O(1) per path: advisory-locked append, no traversal.
+ *   - Per-event session_id: threaded from the REAL payload when present
+ *     (omitted when the client omits it — the marker is still useful for the
+ *     tool_call_id pairing even without a session).
+ *   - Hooks never require() the server package — only co-located lib/*.cjs.
+ *
+ * Each emitted line matches `fileMutatedEventSchema`
+ * (packages/shared/src/schemas/event-ledger.ts):
+ *   { kind:"fabric-event", id, ts, schema_version:1, session_id?,
+ *     event_type:"file_mutated", path, tool_call_id, tool_name? }
+ *
+ * Stdout/stderr are intentionally empty — PostToolUse is observation-only and
+ * never blocks the host's tool pipeline.
+ */
+
+const { randomUUID } = require("node:crypto");
+const { existsSync } = require("node:fs");
+const { isAbsolute, join, relative } = require("node:path");
+
+// W1-01 (ISS-011) parity: route every shared-ledger append through the
+// advisory-lock primitive so concurrent PostToolUse fires (multi-window /
+// parallel edits) never interleave a partial line. Best-effort, drop-on-
+// contention — same primitive the narrow/broad hooks use.
+const { appendLockedLine } = require("./lib/injection-log.cjs");
+
+const FABRIC_DIR_REL = ".fabric";
+const EVENTS_LEDGER_FILE = "events.jsonl";
+
+// Tool names that trigger the mutation marker. PostToolUse fires on many tool
+// names across clients; we only react to the file-edit tools (matches the
+// PreToolUse narrow hint's EDIT_TOOL_NAMES so Pre/Post pair on the same set).
+const EDIT_TOOL_NAMES = new Set(["Edit", "Write", "MultiEdit"]);
+
+/**
+ * Read stdin (or a test-supplied raw string) as JSON. Returns null on any
+ * parse failure — the hook stays silent rather than crashing the tool pipeline.
+ */
+function readPayload(rawStdin) {
+  if (typeof rawStdin !== "string" || rawStdin.length === 0) return null;
+  try {
+    const parsed = JSON.parse(rawStdin);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the tool name. Mirrors the narrow hint's probe:
+ *   - Claude Code / Codex: { tool_name, ... }
+ *   - Cursor (legacy):      { tool, ... }
+ */
+function extractToolName(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  if (typeof payload.tool_name === "string") return payload.tool_name;
+  if (typeof payload.tool === "string") return payload.tool;
+  return null;
+}
+
+/**
+ * Extract the tool_input object, accepting both the `tool_input`
+ * (Claude/Codex) and `input` (Cursor) conventions.
+ */
+function extractToolInput(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  if (payload.tool_input && typeof payload.tool_input === "object") {
+    return payload.tool_input;
+  }
+  if (payload.input && typeof payload.input === "object") {
+    return payload.input;
+  }
+  return null;
+}
+
+/**
+ * Pull file paths out of a tool_input object. Same three shapes the narrow
+ * hint handles (single file_path / array file_paths / MultiEdit edits[]).
+ * Returns a deduped array of strings — empty when none recognizable.
+ */
+function extractPaths(toolInput) {
+  if (!toolInput || typeof toolInput !== "object") return [];
+  const collected = [];
+
+  if (typeof toolInput.file_path === "string" && toolInput.file_path.length > 0) {
+    collected.push(toolInput.file_path);
+  }
+  if (Array.isArray(toolInput.file_paths)) {
+    for (const p of toolInput.file_paths) {
+      if (typeof p === "string" && p.length > 0) collected.push(p);
+    }
+  }
+  if (Array.isArray(toolInput.edits)) {
+    for (const edit of toolInput.edits) {
+      if (
+        edit &&
+        typeof edit === "object" &&
+        typeof edit.file_path === "string" &&
+        edit.file_path.length > 0
+      ) {
+        collected.push(edit.file_path);
+      }
+    }
+  }
+
+  const seen = new Set();
+  const out = [];
+  for (const p of collected) {
+    if (seen.has(p)) continue;
+    seen.add(p);
+    out.push(p);
+  }
+  return out;
+}
+
+/**
+ * Extract the per-call id. Claude Code's PostToolUse payload carries the id of
+ * the originating tool_use block as `tool_use_id`; older drafts / other clients
+ * variously used `tool_call_id` / `call_id` / `id`. We probe in that order.
+ *
+ * Returns null when none is present — the caller then synthesizes a best-effort
+ * fallback key so the marker still lands (per W2-T3: "缺失则用 best-effort
+ * fallback key 但仍 append"). A fallback key cannot pair with the Pre half but
+ * still records the mutation, which is strictly better than dropping it.
+ */
+function extractToolCallId(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const candidates = ["tool_use_id", "tool_call_id", "call_id", "id"];
+  for (const key of candidates) {
+    const v = payload[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return null;
+}
+
+/**
+ * Normalize a path to a project-relative, forward-slash form. Drops paths that
+ * escape the project tree (mirrors appendEditIntentToLedger in the narrow
+ * hook). Returns null for out-of-tree / empty.
+ */
+function normalizePath(projectRoot, p) {
+  if (typeof p !== "string" || p.length === 0) return null;
+  let rel;
+  if (isAbsolute(p)) {
+    rel = relative(projectRoot, p);
+    if (rel.startsWith("..")) return null;
+  } else {
+    if (p.startsWith("..")) return null;
+    rel = p;
+  }
+  const slashed = rel.split(/[\\/]/).join("/");
+  return slashed.length > 0 ? slashed : null;
+}
+
+/**
+ * Append one `file_mutated` marker per edited path to `.fabric/events.jsonl`.
+ * Best-effort:
+ *   - Skips silently when `.fabric/` does not exist (project not init'd).
+ *   - Skips silently when there are no in-tree paths.
+ *   - ANY error (append, JSON throw) is swallowed — never blocks the pipeline.
+ *
+ * One JSON line per path (PIPE_BUF-atomic). The per-path lines share a single
+ * tool_call_id so doctor can group them as one tool call.
+ */
+function appendFileMutated(projectRoot, now, paths, toolCallId, toolName, sessionId) {
+  try {
+    const fabricDir = join(projectRoot, FABRIC_DIR_REL);
+    if (!existsSync(fabricDir)) return;
+    const pathList = Array.isArray(paths)
+      ? paths.map((p) => normalizePath(projectRoot, p)).filter((p) => p !== null)
+      : [];
+    if (pathList.length === 0) return;
+    const tsMs = now instanceof Date ? now.getTime() : Number(now);
+    // Best-effort fallback key when the client omits the tool-call id: the
+    // mutation is still recorded (can't pair with the Pre half, but the path
+    // signal is preserved). Per-fire UUID keeps parallel fires distinct.
+    const callId =
+      typeof toolCallId === "string" && toolCallId.length > 0
+        ? toolCallId
+        : `fallback:${randomUUID()}`;
+    const validSessionId =
+      typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+    const validToolName =
+      typeof toolName === "string" && toolName.length > 0 ? toolName : null;
+    const lines =
+      pathList
+        .map((p) =>
+          JSON.stringify({
+            kind: "fabric-event",
+            id: `event:${randomUUID()}`,
+            ts: tsMs,
+            schema_version: 1,
+            ...(validSessionId ? { session_id: validSessionId } : {}),
+            event_type: "file_mutated",
+            path: p,
+            tool_call_id: callId,
+            ...(validToolName ? { tool_name: validToolName } : {}),
+          }),
+        )
+        .join("\n") + "\n";
+    appendLockedLine(join(fabricDir, EVENTS_LEDGER_FILE), lines);
+  } catch {
+    // Silent — marker failure must never block the tool pipeline.
+  }
+}
+
+// -----------------------------------------------------------------------------
+// Main — invoked as a CLI (require.main === module) and in-process by tests.
+// Wraps the entire flow in try/catch: ANY error → silent exit 0.
+// -----------------------------------------------------------------------------
+
+function main(env) {
+  try {
+    const cwd = (env && env.cwd) || process.cwd();
+    const now = (env && env.now) || new Date();
+    const payload =
+      env && env.payload !== undefined ? env.payload : readPayload(env && env.stdin);
+    if (payload === null || payload === undefined) return;
+
+    const toolName = extractToolName(payload);
+    if (!toolName || !EDIT_TOOL_NAMES.has(toolName)) return;
+
+    const toolInput = extractToolInput(payload);
+    const paths = extractPaths(toolInput);
+    if (paths.length === 0) return;
+
+    const toolCallId = extractToolCallId(payload);
+    const sessionId =
+      payload && typeof payload === "object" && typeof payload.session_id === "string"
+        ? payload.session_id
+        : null;
+
+    appendFileMutated(cwd, now, paths, toolCallId, toolName, sessionId);
+  } catch {
+    // Silent — never block the tool pipeline on hook failure.
+  }
+}
+
+module.exports = {
+  main,
+  readPayload,
+  extractToolName,
+  extractToolInput,
+  extractPaths,
+  extractToolCallId,
+  normalizePath,
+  appendFileMutated,
+  CONSTANTS: {
+    FABRIC_DIR_REL,
+    EVENTS_LEDGER_FILE,
+    EDIT_TOOL_NAMES,
+  },
+};
+
+if (require.main === module) {
+  // Read stdin synchronously (small hook payloads, no concurrency concerns).
+  let stdinRaw = "";
+  try {
+    stdinRaw = require("node:fs").readFileSync(0, "utf8");
+  } catch {
+    // No stdin — proceed with empty payload (E*: no append without paths).
+  }
+  main({ cwd: process.cwd(), now: new Date(), stdin: stdinRaw });
+  process.exit(0);
+}

package/templates/hooks/session-end-marker.cjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * lifecycle-refactor W2-T2 — SessionEnd marker hook (previously dormant).
+ *
+ * SessionEnd fires once when a client session boots down. This hook is a
+ * PURE MARKER: it appends a single `session_ended` event (session_id + ts,
+ * via the shared envelope) to `.fabric/events.jsonl` and does NOTHING else.
+ *
+ * Design (lifecycle-concept-final.md §1 FROZEN invariants + §5 row2):
+ *   - ZERO compute: the hook never reads/aggregates the ledger. ALL
+ *     surfaced→cited→edited funnel reconciliation is doctor-side (offline).
+ *   - hook = nudge/marker, never a gate (KT-DEC-0007): every error path ends
+ *     in a silent exit 0; we never throw upward.
+ *   - Front-stage O(1): one advisory-locked append, no traversal.
+ *   - Per-event session_id: when the client omits session_id we DEGRADE by
+ *     skipping the append entirely (a marker with no session is useless for
+ *     the per-session funnel doctor reconstructs).
+ *   - Hooks never require() the server package — only the co-located lib/*.cjs.
+ *
+ * The emitted line matches `sessionEndedEventSchema`
+ * (packages/shared/src/schemas/event-ledger.ts):
+ *   { kind:"fabric-event", id, ts, schema_version:1, session_id?, event_type:"session_ended" }
+ *
+ * Stdout/stderr are intentionally empty — SessionEnd is observation-only.
+ */
+
+const { randomUUID } = require("node:crypto");
+const { existsSync } = require("node:fs");
+const { join } = require("node:path");
+
+// W1-01 (ISS-011) parity: route the shared-ledger append through the
+// advisory-lock primitive so concurrent SessionEnd fires (multi-window) never
+// interleave a partial line. Drop-on-contention, best-effort — same primitive
+// the narrow/broad hooks use.
+const { appendLockedLine } = require("./lib/injection-log.cjs");
+
+const FABRIC_DIR_REL = ".fabric";
+const EVENTS_LEDGER_FILE = "events.jsonl";
+
+/**
+ * Read stdin (or a test-supplied raw string) as JSON. Returns null on any
+ * parse failure — the hook stays silent rather than crashing session teardown.
+ */
+function readPayload(rawStdin) {
+  if (typeof rawStdin !== "string" || rawStdin.length === 0) return null;
+  try {
+    const parsed = JSON.parse(rawStdin);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the REAL payload session_id (never a synthetic fallback). The
+ * funnel reconciliation in doctor keys on the client's own session id, so a
+ * fabricated id would silently corrupt the per-session join. Returns null when
+ * absent — the caller then skips the append (degraded, per §1).
+ */
+function extractSessionId(payload) {
+  if (
+    payload &&
+    typeof payload === "object" &&
+    typeof payload.session_id === "string" &&
+    payload.session_id.length > 0
+  ) {
+    return payload.session_id;
+  }
+  return null;
+}
+
+/**
+ * Append one `session_ended` marker to `.fabric/events.jsonl`. Best-effort:
+ *   - Skips silently when `.fabric/` does not exist (project not init'd).
+ *   - Skips silently when sessionId is null (degraded — no session to mark).
+ *   - ANY error (append, JSON throw) is swallowed — never blocks teardown.
+ */
+function appendSessionEnded(projectRoot, now, sessionId) {
+  try {
+    if (typeof sessionId !== "string" || sessionId.length === 0) return;
+    const fabricDir = join(projectRoot, FABRIC_DIR_REL);
+    if (!existsSync(fabricDir)) return;
+    const tsMs = now instanceof Date ? now.getTime() : Number(now);
+    const event = {
+      kind: "fabric-event",
+      id: `event:${randomUUID()}`,
+      ts: tsMs,
+      schema_version: 1,
+      session_id: sessionId,
+      event_type: "session_ended",
+    };
+    appendLockedLine(join(fabricDir, EVENTS_LEDGER_FILE), JSON.stringify(event) + "\n");
+  } catch {
+    // Silent — marker failure must never block session teardown.
+  }
+}
+
+// -----------------------------------------------------------------------------
+// Main — invoked as a CLI (require.main === module) and in-process by tests.
+// Wraps the entire flow in try/catch: ANY error → silent exit 0.
+// -----------------------------------------------------------------------------
+
+function main(env) {
+  try {
+    const cwd = (env && env.cwd) || process.cwd();
+    const now = (env && env.now) || new Date();
+    const payload =
+      env && env.payload !== undefined ? env.payload : readPayload(env && env.stdin);
+    const sessionId = extractSessionId(payload);
+    appendSessionEnded(cwd, now, sessionId);
+  } catch {
+    // Silent — never block session teardown on hook failure.
+  }
+}
+
+module.exports = {
+  main,
+  readPayload,
+  extractSessionId,
+  appendSessionEnded,
+  CONSTANTS: {
+    FABRIC_DIR_REL,
+    EVENTS_LEDGER_FILE,
+  },
+};
+
+if (require.main === module) {
+  // Read stdin synchronously (small hook payloads, no concurrency concerns).
+  let stdinRaw = "";
+  try {
+    stdinRaw = require("node:fs").readFileSync(0, "utf8");
+  } catch {
+    // No stdin — proceed with empty payload (degrades to a no-op append).
+  }
+  main({ cwd: process.cwd(), now: new Date(), stdin: stdinRaw });
+  process.exit(0);
+}

package/templates/skills/fabric-archive/SKILL.md

@@ -113,6 +113,12 @@ Assign `relevance_scope` ∈ {narrow, broad} + derive `relevance_paths` BEFORE b
 
 `Read ref/phase-3-5-scope.md` for the 6-step relevance_paths derivation pseudocode (COLLECT → DEDUPE → BLACKLIST → PUBLIC-PREFIX GENERALIZE → SCOPE GATE → ATTACH READ-ONLY EVIDENCE), worked example (5 sample paths → glob + literal output), and narrow↔broad inline-edit re-derivation rules.
 
+### Phase 3.6 — Related-edge Extraction (§7 graph generation)
+
+For each candidate, identify the **`related`** graph edges to other KB entries — the store-qualified `stable_id`s this entry semantically links to (the decision it supersedes, the pitfall it explains, the model it instantiates). You discovered these ids during the session via `fab_recall` / plan-context, so cite the ones you actually saw, NEVER invent stable_ids. Because `fab_extract_knowledge` has no dedicated `related` input, record the candidate edges as one line inside `session_context` (e.g. `related: team:KT-DEC-0007, team:KT-PIT-0011`) so they survive to approve-time frontmatter authoring (`fabric-review` writes the canonical `related: [...]` frontmatter).
+
+**§4 privacy iron law — KT→KP is FORBIDDEN.** A **team** (`KT-*`) entry's `related` MUST NOT point at a **personal** (`KP-*`) id: that would write a personal-knowledge topology pointer into the project's shared physical ledger (`./.fabric/agents.meta.json`). Allowed: `KT→KT`, `KP→KP`, `KP→KT`. Forbidden: `KT→KP` only. When unsure whether a target is personal, OMIT the edge. (The meta-builder also strips any KT→KP edge that slips through, but do not rely on that — author clean edges.)
+
 ### Phase 4 — Persist via MCP
 
 For each user-confirmed candidate, call `fab_extract_knowledge` ONCE (NEVER batch). Required: `source_sessions[]`, `recent_paths[]` (cap 20), `user_messages_summary`, `type` (plural form: decisions/pitfalls/guidelines/models/processes), `slug`, `layer`, `relevance_scope`, `relevance_paths[]`, `proposed_reason` (enum), `session_context` (3-5 line narrative). Four OPTIONAL rc.23 triage fields (`intent_clues`, `tech_stack`, `impact`, `must_read_if`) — populate when clean, **omit rather than guess**.
@@ -155,7 +161,7 @@ MANDATORY closing step on EVERY invocation (Phase 4 success path + every early-e
 - v2.0.0-rc.37 NEW-7 widened Phase 3.5: `edit_paths` ∪ `user_mentioned_paths` drives `relevance_paths`; `read_paths` flows separately to `evidence_paths` (structured frontmatter, not body markdown). NEVER lift body regex / symbol extraction into `relevance_paths` — those remain reserved for v2.1+.
 - NEVER batch multiple candidates into a single fab_extract_knowledge call; one call per candidate.
 - NEVER paraphrase the verbatim layer heuristic block above — the Chinese text is contract-locked.
-- MUST preserve protected tokens exactly: `stable_id`, `knowledge_proposed`, `knowledge_archive_aborted`, `knowledge_scope_degraded`, `.fabric/knowledge/pending/`, `fab_extract_knowledge`, `relevance_paths`, `relevance_scope`, `narrow`, `broad`, `edit_paths`, `source_sessions`, `proposed_reason`, `session_context`, `intent_clues`, `tech_stack`, `impact`, `must_read_if`, `pending_path`, `layer`, `team`, `personal`, `MUST`, `NEVER`, `强 team`, `强 personal`, `默认 team`.
+- MUST preserve protected tokens exactly: `stable_id`, `knowledge_proposed`, `knowledge_archive_aborted`, `knowledge_scope_degraded`, `.fabric/knowledge/pending/`, `fab_extract_knowledge`, `relevance_paths`, `relevance_scope`, `narrow`, `broad`, `edit_paths`, `source_sessions`, `proposed_reason`, `session_context`, `intent_clues`, `tech_stack`, `impact`, `must_read_if`, `pending_path`, `layer`, `team`, `personal`, `MUST`, `NEVER`, `强 team`, `强 personal`, `默认 team`, `related`, `KT→KP`.
 
 ## Worked Examples / E5 Cron / Dry-run (ref-only)
 

package/dist/chunk-4R2CYEA4.js

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadProjectConfig,
-  saveProjectConfig
-} from "./chunk-LFIKMVY7.js";
-import {
-  loadGlobalConfig,
-  resolveGlobalRoot,
-  saveGlobalConfig
-} from "./chunk-RYAFBNES.js";
-
-// src/store/store-ops.ts
-import { randomUUID } from "crypto";
-import { existsSync } from "fs";
-import { join } from "path";
-import {
-  addMountedStore,
-  bindRequiredStore,
-  detachMountedStore,
-  explainStore,
-  initStore,
-  storeRelativePath
-} from "@fenglimg/fabric-shared";
-var NO_GLOBAL_CONFIG = "no global Fabric config found \u2014 run `fabric install --global <url>` first";
-function requireConfig(globalRoot) {
-  const config = loadGlobalConfig(globalRoot);
-  if (config === null) {
-    throw new Error(NO_GLOBAL_CONFIG);
-  }
-  return config;
-}
-function storeList(globalRoot = resolveGlobalRoot()) {
-  return requireConfig(globalRoot).stores;
-}
-function storeAdd(store, globalRoot = resolveGlobalRoot()) {
-  const next = addMountedStore(requireConfig(globalRoot), store);
-  saveGlobalConfig(next, globalRoot);
-  return next;
-}
-function storeCreate(alias, now, options = {}) {
-  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
-  const config = requireConfig(globalRoot);
-  const uuid = options.uuid ?? randomUUID();
-  const storeDir = join(globalRoot, storeRelativePath(uuid));
-  initStore(
-    storeDir,
-    { store_uuid: uuid, created_at: now, canonical_alias: alias },
-    { git: options.git }
-  );
-  const mounted = options.remote === void 0 ? { store_uuid: uuid, alias } : { store_uuid: uuid, alias, remote: options.remote };
-  const next = addMountedStore(config, mounted);
-  saveGlobalConfig(next, globalRoot);
-  return { config: next, store_uuid: uuid, storeDir };
-}
-function assertStoreMountable(uuid, globalRoot = resolveGlobalRoot()) {
-  const storeDir = join(globalRoot, storeRelativePath(uuid));
-  if (!existsSync(join(storeDir, "store.json"))) {
-    throw new Error(
-      `cannot mount store ${uuid}: no store tree at ${storeDir} \u2014 clone it first (\`fabric install --global --url <remote>\`) or create it locally, then re-run \`fabric store add\`. Refusing to register a phantom store.`
-    );
-  }
-}
-function storeRemove(alias, globalRoot = resolveGlobalRoot()) {
-  const result = detachMountedStore(requireConfig(globalRoot), alias);
-  saveGlobalConfig(result.config, globalRoot);
-  return result;
-}
-function storeExplain(alias, globalRoot = resolveGlobalRoot()) {
-  return explainStore(requireConfig(globalRoot), alias);
-}
-var NO_PROJECT_CONFIG = "no project Fabric config \u2014 run `fabric install` in this repo first";
-function requireProjectConfig(projectRoot) {
-  const config = loadProjectConfig(projectRoot);
-  if (config === null) {
-    throw new Error(NO_PROJECT_CONFIG);
-  }
-  return config;
-}
-function storeBind(projectRoot, entry) {
-  const config = requireProjectConfig(projectRoot);
-  const next = {
-    ...config,
-    required_stores: bindRequiredStore(config.required_stores ?? [], entry)
-  };
-  saveProjectConfig(next, projectRoot);
-  return next;
-}
-function storeSwitchWrite(projectRoot, alias) {
-  const config = requireProjectConfig(projectRoot);
-  const next = { ...config, active_write_store: alias };
-  saveProjectConfig(next, projectRoot);
-  return next;
-}
-function missingRequiredStores(projectRoot, globalRoot = resolveGlobalRoot()) {
-  const project = loadProjectConfig(projectRoot);
-  if (project === null || project.required_stores === void 0) {
-    return [];
-  }
-  const global = loadGlobalConfig(globalRoot);
-  const mounted = new Set(
-    (global?.stores ?? []).flatMap((s) => [s.alias, s.store_uuid])
-  );
-  return project.required_stores.filter((r) => !mounted.has(r.id));
-}
-
-export {
-  storeList,
-  storeAdd,
-  storeCreate,
-  assertStoreMountable,
-  storeRemove,
-  storeExplain,
-  storeBind,
-  storeSwitchWrite,
-  missingRequiredStores
-};

package/dist/chunk-L4Q55UC4.js

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadProjectConfig
-} from "./chunk-LFIKMVY7.js";
-import {
-  loadGlobalConfig,
-  resolveGlobalRoot
-} from "./chunk-RYAFBNES.js";
-
-// src/store/scope-explain.ts
-import {
-  createStoreResolver
-} from "@fenglimg/fabric-shared";
-function buildResolveInput(projectRoot, globalRoot = resolveGlobalRoot()) {
-  const global = loadGlobalConfig(globalRoot);
-  if (global === null) {
-    return null;
-  }
-  const project = loadProjectConfig(projectRoot);
-  return {
-    uid: global.uid,
-    mountedStores: global.stores.map((s) => ({
-      store_uuid: s.store_uuid,
-      alias: s.alias,
-      ...s.remote === void 0 ? {} : { remote: s.remote },
-      writable: s.writable ?? true,
-      personal: s.personal ?? false
-    })),
-    requiredStores: (project?.required_stores ?? []).map((r) => ({
-      id: r.id,
-      ...r.suggested_remote === void 0 ? {} : { suggested_remote: r.suggested_remote }
-    })),
-    ...project?.active_write_store === void 0 ? {} : { activeWriteAlias: project.active_write_store }
-  };
-}
-function scopeExplain(projectRoot, scope, globalRoot = resolveGlobalRoot()) {
-  const input = buildResolveInput(projectRoot, globalRoot);
-  if (input === null) {
-    return null;
-  }
-  const resolver = createStoreResolver();
-  return {
-    scope,
-    readSet: resolver.resolveReadSet(input),
-    writeTarget: resolver.resolveWriteTarget(input, scope).target
-  };
-}
-
-export {
-  buildResolveInput,
-  scopeExplain
-};

package/dist/chunk-LFIKMVY7.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-
-// src/store/project-config-io.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { fabricConfigSchema } from "@fenglimg/fabric-shared";
-function projectConfigPath(projectRoot) {
-  return join(projectRoot, ".fabric", "fabric-config.json");
-}
-function loadProjectConfig(projectRoot) {
-  const path = projectConfigPath(projectRoot);
-  if (!existsSync(path)) {
-    return null;
-  }
-  return fabricConfigSchema.parse(JSON.parse(readFileSync(path, "utf8")));
-}
-function saveProjectConfig(config, projectRoot) {
-  const validated = fabricConfigSchema.parse(config);
-  mkdirSync(join(projectRoot, ".fabric"), { recursive: true });
-  writeFileSync(projectConfigPath(projectRoot), `${JSON.stringify(validated, null, 2)}
-`, "utf8");
-}
-
-export {
-  loadProjectConfig,
-  saveProjectConfig
-};

package/dist/chunk-RYAFBNES.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-
-// src/store/global-config-io.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { globalConfigSchema } from "@fenglimg/fabric-shared";
-function resolveGlobalRoot() {
-  return join(process.env.FABRIC_HOME ?? homedir(), ".fabric");
-}
-function globalConfigPath(globalRoot = resolveGlobalRoot()) {
-  return join(globalRoot, "fabric-global.json");
-}
-function loadGlobalConfig(globalRoot = resolveGlobalRoot()) {
-  const path = globalConfigPath(globalRoot);
-  if (!existsSync(path)) {
-    return null;
-  }
-  return globalConfigSchema.parse(JSON.parse(readFileSync(path, "utf8")));
-}
-function saveGlobalConfig(config, globalRoot = resolveGlobalRoot()) {
-  const validated = globalConfigSchema.parse(config);
-  mkdirSync(globalRoot, { recursive: true });
-  writeFileSync(globalConfigPath(globalRoot), `${JSON.stringify(validated, null, 2)}
-`, "utf8");
-}
-
-export {
-  resolveGlobalRoot,
-  globalConfigPath,
-  loadGlobalConfig,
-  saveGlobalConfig
-};