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

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

@@ -0,0 +1,386 @@
+#!/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 a tool call completes. This hook serves two markers,
+ * both appended to `.fabric/events.jsonl` and both observation-only:
+ *   - Edit/Write/MultiEdit → one `file_mutated` event per edited path, carrying
+ *     the `tool_call_id` so doctor can pair the Pre (intent) and Post (mutation)
+ *     halves of a single call (the per-call key also guards parallel-fire races).
+ *   - Read → one `knowledge_body_read` event per Fabric knowledge file opened
+ *     (KT-DEC-0030). After retrieval collapsed to one lean tool (KT-DEC-0026),
+ *     fab_recall returns descriptions + paths only; the agent reads a body via a
+ *     NATIVE Read, and this marker is the observable trace doctor uses for the
+ *     planned → body_read → cite[applied] funnel.
+ *
+ * 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"]);
+
+// KT-DEC-0030: tool names that read a file body. After retrieval collapsed to
+// one lean tool (KT-DEC-0026), the agent consumes a knowledge body via a NATIVE
+// Read of the store file — so a Read landing on a `<store>/knowledge/<type>/
+// <ID>--*.md` path is the observable "body opened" signal. Only `Read` is in
+// scope (Edit/Write already covered by the mutation marker above).
+const READ_TOOL_NAMES = new Set(["Read"]);
+
+// Matches a Fabric knowledge file path and captures the stable_id from the
+// basename. The id grammar mirrors KT-DEC-0004 (`K[PT]-(DEC|MOD|GLD|PIT|PRO)-NNNN`).
+// The path MUST sit under a `/knowledge/<type>/` segment so arbitrary Reads that
+// merely happen to embed an id-shaped token never false-fire.
+const KNOWLEDGE_BODY_PATH_RE =
+  /[\\/]knowledge[\\/][^\\/]+[\\/](K[PT]-(?:DEC|MOD|GLD|PIT|PRO)-\d{3,})--[^\\/]*\.md$/;
+
+// Captures the store alias from a multistore path (`.../stores/<alias>/...`).
+// Absent for legacy dual-root layouts → store stays undefined (still a valid event).
+const STORE_ALIAS_RE = /[\\/]stores[\\/]([^\\/]+)[\\/]/;
+
+/**
+ * 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, ... }
+ */
+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 from the `tool_input`
+ * (Claude/Codex) convention.
+ */
+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.
+  }
+}
+
+/**
+ * KT-DEC-0030: parse a Read path into a knowledge-body-read descriptor. Returns
+ * `{ stable_id, store, path }` when the path is a Fabric knowledge file, else
+ * null. `store` is omitted when no `stores/<alias>/` segment is present (legacy
+ * dual-root layout). `path` is forward-slash-normalized but NOT made
+ * project-relative — knowledge bodies live under ~/.fabric, outside the project
+ * tree, so the home-anchored path is the meaningful identifier.
+ */
+function extractKnowledgeBodyRead(filePath) {
+  if (typeof filePath !== "string" || filePath.length === 0) return null;
+  const idMatch = KNOWLEDGE_BODY_PATH_RE.exec(filePath);
+  if (idMatch === null) return null;
+  const storeMatch = STORE_ALIAS_RE.exec(filePath);
+  const slashed = filePath.split(/[\\/]/).join("/");
+  return {
+    stable_id: idMatch[1],
+    store: storeMatch !== null ? storeMatch[1] : null,
+    path: slashed,
+  };
+}
+
+/**
+ * Append one `knowledge_body_read` marker per Fabric knowledge file read.
+ * Best-effort, identical guarantees to appendFileMutated (silent on any error,
+ * skips when `.fabric/` absent). Non-knowledge reads produce zero events — the
+ * common case (the agent reads source files far more than knowledge bodies),
+ * so the hook stays a near-noop on the hot Read path.
+ */
+function appendKnowledgeBodyRead(projectRoot, now, paths, toolCallId, toolName, sessionId) {
+  try {
+    const fabricDir = join(projectRoot, FABRIC_DIR_REL);
+    if (!existsSync(fabricDir)) return;
+    const reads = Array.isArray(paths)
+      ? paths.map((p) => extractKnowledgeBodyRead(p)).filter((r) => r !== null)
+      : [];
+    if (reads.length === 0) return;
+    const tsMs = now instanceof Date ? now.getTime() : Number(now);
+    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 =
+      reads
+        .map((r) =>
+          JSON.stringify({
+            kind: "fabric-event",
+            id: `event:${randomUUID()}`,
+            ts: tsMs,
+            schema_version: 1,
+            ...(validSessionId ? { session_id: validSessionId } : {}),
+            event_type: "knowledge_body_read",
+            stable_id: r.stable_id,
+            ...(r.store ? { store: r.store } : {}),
+            path: r.path,
+            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);
+    const isEdit = toolName && EDIT_TOOL_NAMES.has(toolName);
+    const isRead = toolName && READ_TOOL_NAMES.has(toolName);
+    if (!isEdit && !isRead) 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;
+
+    if (isEdit) {
+      appendFileMutated(cwd, now, paths, toolCallId, toolName, sessionId);
+    } else {
+      // KT-DEC-0030: observe native Reads of store knowledge bodies. Non-
+      // knowledge Reads filter out inside appendKnowledgeBodyRead (zero events).
+      appendKnowledgeBodyRead(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,
+  extractKnowledgeBodyRead,
+  appendKnowledgeBodyRead,
+  CONSTANTS: {
+    FABRIC_DIR_REL,
+    EVENTS_LEDGER_FILE,
+    EDIT_TOOL_NAMES,
+    READ_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/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: fabric
+description: Fabric 入口层路由 — 参考 maestro 的顺序协调方式，把用户意图分派到 fabric-archive/review/import/store/sync/audit/connect。Triggers fabric/知识库/归档/审批/store/同步/关联/审计.
+---
+
+# fabric — Fabric Skill Router
+
+这是 Fabric 相关 skills 的入口层。它只负责理解用户意图、选择正确的下游 skill、按顺序直接调用；不直接读写 `~/.fabric` store，不自行解析 store 树，也不替代底层 `fabric-*` skills 的安全门。
+
+## Routing Contract
+
+1. 先判断用户要做的是哪类 Fabric 工作。
+2. 只调用一个最合适的下游 skill；只有用户明确要求一组维护动作时，才按顺序调用多个。
+3. 每一步完成后读取结果，再决定是否继续下一步。不要并发委派，也不要用 CSV/wave worker。
+4. 如果目标涉及写入、审批、退役或关联，必须走对应下游 skill 的既有写路径；本入口 skill 不直接修改 `knowledge/`。
+5. Store 状态只通过 `fabric info`、`fabric store ...`、`fabric sync`、MCP 工具或下游 skill 获取。MUST NOT 直接遍历或执行 `~/.fabric/stores/` 内容；store 是 data-only。
+
+## Intent Map
+
+<!-- fabric:router-intent:begin -->
+<!-- 本块由 `fabric install` 从 7 个 leaf skill 的 description Triggers 子句生成。严禁手编;改 leaf description 后重跑 `fabric install`。 -->
+
+| 用户意图(leaf description Triggers) | 下游 skill |
+| --- | --- |
+| 以后/always/never/下次/记一下;wrong-turn-revert;decision-confirm;dismissal-reason;/fabric-archive | `fabric-archive` |
+| 审批/驳回/复审/重审/approve/reject/review pending | `fabric-review` |
+| 导入历史/bootstrap fabric/mine changelog/挖掘 commit | `fabric-import` |
+| 同步知识库/sync stores/fabric-sync/解决 store 冲突/rebase 冲突 | `fabric-sync` |
+| 创建 store/挂载 store/绑定知识库/store 列表/切换写库/set up knowledge store | `fabric-store` |
+| 审计知识库/清理陈旧知识/知识库体检/deprecate 条目/prune stale knowledge/知识库瘦身/淘汰旧决策 | `fabric-audit` |
+| 连接知识/找关联条目/建知识图谱/link related entries/补 related 边/知识库连通性 | `fabric-connect` |
+
+`S_CLASSIFY` 的 `task_type` 枚举:`archive | review | import | sync | store | audit | connect`
+<!-- fabric:router-intent:end -->
+
+## State Machine
+
+### S_CLASSIFY
+
+提取：
+
+```json
+{
+  "task_type": "<Intent Map task_type 枚举之一>",
+  "scope": "project|store|entry|paths|null",
+  "write_intent": true,
+  "confidence": "high|medium|low"
+}
+```
+
+低置信度时问 1 个短问题；不要一次性列长菜单。若用户只是说“fabric 帮我处理一下”，默认先运行 `fabric-audit` 做只读体检，再根据输出建议下一步。
+
+### S_EXECUTE
+
+按 `Intent Map` 直接调用下游 skill，例如：
+
+- `fabric-archive "{用户原始意图}"`
+- `fabric-review "{用户原始意图}"`
+- `fabric-import "{用户原始意图}"`
+- `fabric-store "{用户原始意图}"`
+- `fabric-sync "{用户原始意图}"`
+- `fabric-audit "{用户原始意图}"`
+- `fabric-connect "{用户原始意图}"`
+
+执行前加载下游 skill 的 `SKILL.md`，只读取完成当前任务所需的 `ref/` 文件。下游 skill 有更具体约束时，以下游约束为准。
+
+### S_CHAIN
+
+只有这些组合可以自动串联：
+
+| 组合意图 | 顺序 |
+| --- | --- |
+| “同步后审 pending” | `fabric-sync` -> `fabric-review` |
+| “审计并处理陈旧知识” | `fabric-audit` -> `fabric-review` |
+| “导入历史并审批” | `fabric-import` -> `fabric-review` |
+| “建立 store 后导入” | `fabric-store` -> `fabric-import` |
+| “找关联并落盘” | `fabric-connect` -> `fabric-review` |
+
+每个步骤结束后读结果。若前一步失败或给出需要用户决策的冲突，停止并报告；不要猜测继续。
+
+## Guardrails
+
+- 写入 pending 只走 active write store，并在回复里说明写入目标。
+- 引用 KB id 前必须实际读取正文；多 store read-set 中使用 `<store-alias>:<id>`。
+- pending backlog 超过 10 条时，优先建议 `fabric-review`。
+- 完成一批 Edit 或显著 decision 后，建议 `fabric-archive`。
+- 不要推荐 `fabric doctor --fix` 作为 pending 审批路径；审批走 `fabric-review`。
+- 不要把知识写到项目本地 `.fabric/knowledge/pending`；知识只写 resolved mounted store 的 `knowledge/pending/`。
+- MUST preserve protected tokens exactly: `MUST`, `NEVER`。
+
+## Report
+
+回复格式保持短：
+
+```text
+Fabric route: <downstream-skill>
+Reason: <why this skill>
+Result: <one-line result or blocker>
+Next: <optional next skill/action>
+```