@fenglimg/fabric-shared 2.0.0-rc.1 → 2.0.0

package/dist/{chunk-KHIM6MWS.js → chunk-U2SR2M4L.js}

@@ -52,11 +52,15 @@ var enMessages = {
   "doctor.section.fixable": "Fixable errors:",
   "doctor.section.manual": "Manual errors:",
   "doctor.section.warnings": "Warnings:",
+  "doctor.section.apply-lint-mutations": "Apply-lint mutations:",
   "cli.doctor.args.target.description": "Target project path. Defaults to CLI arg, EXTERNAL_FIXTURE_PATH, fabric.config.json, then cwd.",
-  "cli.doctor.args.fix.description": "Repair deterministic derived Fabric state, including meta, rule-test index, bootstrap, and events ledger.",
+  "cli.doctor.args.fix.description": "Repair deterministic derived Fabric state, including meta, knowledge-test index, bootstrap, and events ledger.",
   "cli.doctor.args.json.description": "Print the doctor report as JSON.",
   "cli.doctor.args.strict.description": "Treat warnings as failures.",
   "cli.doctor.args.force.description": "Run even if a serve process appears to hold the lock.",
+  "cli.doctor.args.apply-lint.description": "Apply lint mutations: demote orphaned canonical entries, archive stale drafts, and bump drifted index counters. Emits knowledge_demoted / knowledge_archived events. Default doctor invocation remains report-only.",
+  "cli.doctor.args.yes.description": "Skip the --apply-lint safety confirm. Required for non-tty invocations unless FABRIC_NONINTERACTIVE=1 is set in the environment.",
+  "cli.doctor.errors.apply-lint-fix-mutually-exclusive": "--apply-lint and --fix cannot be combined. --apply-lint mutates user knowledge state (demote/archive); --fix repairs derived state (meta/index). Run them separately.",
   "cli.hooks.description": "Manage Fabric Git hook templates.",
   "cli.hooks.install.description": "Install the Fabric Husky pre-commit hook template.",
   "cli.hooks.install.args.target.description": "Target project path, default is the current working directory.",
@@ -487,11 +491,15 @@ var zhCNMessages = {
   "doctor.section.fixable": "\u53EF\u4FEE\u590D\u9519\u8BEF\uFF1A",
   "doctor.section.manual": "\u9700\u624B\u52A8\u4FEE\u590D\uFF1A",
   "doctor.section.warnings": "\u8B66\u544A\uFF1A",
+  "doctor.section.apply-lint-mutations": "Apply-lint \u53D8\u66F4\uFF1A",
   "cli.doctor.args.target.description": "\u76EE\u6807\u9879\u76EE\u8DEF\u5F84\u3002\u9ED8\u8BA4\u4F9D\u6B21\u4F7F\u7528 CLI \u53C2\u6570\u3001EXTERNAL_FIXTURE_PATH\u3001fabric.config.json\u3001\u5F53\u524D\u76EE\u5F55\u3002",
-  "cli.doctor.args.fix.description": "\u4FEE\u590D\u786E\u5B9A\u6027\u6D3E\u751F\u7684 Fabric \u72B6\u6001\uFF0C\u5305\u62EC meta\u3001rule-test index\u3001bootstrap \u548C events ledger\u3002",
+  "cli.doctor.args.fix.description": "\u4FEE\u590D\u786E\u5B9A\u6027\u6D3E\u751F\u7684 Fabric \u72B6\u6001\uFF0C\u5305\u62EC meta\u3001knowledge-test \u7D22\u5F15\u3001bootstrap \u548C events ledger\u3002",
   "cli.doctor.args.json.description": "\u4EE5 JSON \u8F93\u51FA doctor \u62A5\u544A\u3002",
   "cli.doctor.args.strict.description": "\u5C06 warning \u4E5F\u89C6\u4E3A\u5931\u8D25\u3002",
   "cli.doctor.args.force.description": "\u5373\u4F7F serve \u8FDB\u7A0B\u6301\u6709\u9501\uFF0C\u4E5F\u5F3A\u5236\u8FD0\u884C\u3002",
+  "cli.doctor.args.apply-lint.description": "\u5E94\u7528 lint \u53D8\u66F4\uFF1A\u964D\u7EA7\u5B64\u7ACB\u7684\u89C4\u8303\u6761\u76EE\u3001\u5F52\u6863\u9648\u65E7 draft\u3001\u4FEE\u6B63\u6F02\u79FB\u7684\u7D22\u5F15\u8BA1\u6570\u5668\uFF1B\u5199\u5165 knowledge_demoted / knowledge_archived \u4E8B\u4EF6\u3002\u9ED8\u8BA4\u8FD0\u884C\u4ECD\u7136\u53EA\u8BFB\u3002",
+  "cli.doctor.args.yes.description": "\u8DF3\u8FC7 --apply-lint \u7684\u5B89\u5168\u786E\u8BA4\uFF1B\u975E tty \u8C03\u7528\u5FC5\u987B\u663E\u5F0F\u8BBE\u7F6E\u8BE5\u6807\u8BB0\uFF0C\u6216\u5728\u73AF\u5883\u53D8\u91CF\u4E2D\u8BBE\u7F6E FABRIC_NONINTERACTIVE=1\u3002",
+  "cli.doctor.errors.apply-lint-fix-mutually-exclusive": "--apply-lint \u4E0E --fix \u4E0D\u53EF\u540C\u65F6\u4F7F\u7528\u3002--apply-lint \u4FEE\u6539\u7528\u6237\u77E5\u8BC6\u72B6\u6001\uFF08\u964D\u7EA7/\u5F52\u6863\uFF09\uFF1B--fix \u4FEE\u590D\u6D3E\u751F\u72B6\u6001\uFF08meta/\u7D22\u5F15\uFF09\u3002\u8BF7\u5206\u522B\u8FD0\u884C\u3002",
   "cli.hooks.description": "\u7BA1\u7406 Fabric Git \u94A9\u5B50\u6A21\u677F\u3002",
   "cli.hooks.install.description": "\u5B89\u88C5 Fabric Husky pre-commit \u94A9\u5B50\u6A21\u677F\u3002",
   "cli.hooks.install.args.target.description": "\u76EE\u6807\u9879\u76EE\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u3002",
@@ -917,27 +925,24 @@ function detectNodeLocale() {
 
 // src/i18n/protected-tokens.ts
 var PROTECTED_TOKENS = [
+  // v2.0 MCP tool names
   "fab_plan_context",
-  "fab_get_rule_sections",
-  "fabric_rules",
-  "ledger_entry",
-  "ledger_entry_id",
-  "agent_meta",
+  "fab_get_knowledge_sections",
+  "fab_extract_knowledge",
+  "fab_review",
+  // Project convergence point + knowledge tree paths
   "AGENTS.md",
-  "FABRIC.md",
   ".fabric/agents/",
   ".fabric/agents/_cross/",
   ".fabric/agents.meta.json",
   ".fabric/human-lock.json",
-  ".fabric/init-context.json",
-  ".fabric/forensic.json",
-  ".fabric/.intent-ledger.jsonl",
   ".fabric/events.jsonl",
+  ".fabric/knowledge/",
+  // Event types templates reference verbatim
+  "knowledge_proposed",
+  // Human-lock marker
   "@HUMAN",
-  "shadow constraints",
-  "Shadow Mirroring",
-  "CORE RULES",
-  "DO NOT TRANSLATE",
+  // Hard-rule keywords AI clients rely on for compliance
   "MUST",
   "NEVER"
 ];

package/dist/chunk-VQDCDCJA.js

@@ -0,0 +1,555 @@
+// src/schemas/api-contracts.ts
+import { z } from "zod";
+var structuredWarningSchema = z.object({
+  code: z.string(),
+  file: z.string(),
+  line: z.number().optional(),
+  action_hint: z.string()
+});
+var _knowledgeTypeEnum = z.enum(["model", "decision", "guideline", "pitfall", "process"]);
+var _maturityEnum = z.enum(["draft", "verified", "proven"]);
+var _layerEnum = z.enum(["personal", "team"]);
+var _ruleDescriptionSchema = z.object({
+  summary: z.string(),
+  intent_clues: z.array(z.string()),
+  tech_stack: z.array(z.string()),
+  impact: z.array(z.string()),
+  must_read_if: z.string(),
+  entities: z.array(z.string()).optional(),
+  // v2.0: optional knowledge-entry fields. Absent for v1.x rules; present for
+  // entries that declare frontmatter `id/type/maturity/layer`.
+  id: z.string().optional(),
+  knowledge_type: _knowledgeTypeEnum.optional(),
+  maturity: _maturityEnum.optional(),
+  knowledge_layer: _layerEnum.optional(),
+  layer_reason: z.string().optional(),
+  created_at: z.string().optional()
+});
+var _descriptionIndexItemSchema = z.object({
+  stable_id: z.string(),
+  level: z.enum(["L0", "L1", "L2"]),
+  required: z.boolean(),
+  selectable: z.boolean(),
+  description: _ruleDescriptionSchema,
+  // v2.0: top-level knowledge surface for client-side filtering. Mirrors
+  // description.* — exposed here so MCP clients can filter without reaching
+  // into the nested payload.
+  type: _knowledgeTypeEnum.optional(),
+  maturity: _maturityEnum.optional(),
+  layer: _layerEnum.optional(),
+  layer_reason: z.string().optional(),
+  // v2/rc.2: tag list shipped via frontmatter (commit a85121a). Exposed at
+  // the API surface so MCP clients can filter without re-parsing the
+  // description payload. Absent on legacy entries; consumers should treat
+  // missing as [].
+  tags: z.array(z.string()).optional(),
+  // v2.0-rc.5 (C1): relevance scope/paths drive plan-context-hint narrowing.
+  // Exposed at the API surface so MCP clients (and the `fabric
+  // plan-context-hint` CLI from D1) can filter without re-parsing the
+  // description payload. Defaults applied at the parse layer
+  // (knowledge-meta-builder + agentsMetaNodeBaseSchema):
+  //   relevance_scope → 'broad'  (always-surface, safe default)
+  //   relevance_paths → []       (no path anchors)
+  // Consumers should treat missing fields as broad/[]. Optional on the wire
+  // so older servers without rc.5 schemas remain wire-compatible.
+  relevance_scope: z.enum(["narrow", "broad"]).optional(),
+  relevance_paths: z.array(z.string()).optional()
+});
+var _requirementProfileSchema = z.object({
+  target_path: z.string(),
+  path_segments: z.array(z.string()),
+  extension: z.string(),
+  known_tech: z.array(z.string()),
+  user_intent: z.string(),
+  detected_entities: z.array(z.string())
+});
+var planContextInputSchema = z.object({
+  paths: z.array(z.string()).min(1).describe("Candidate file paths to build neutral rule selection context for"),
+  intent: z.string().optional().describe("User-stated requirement or implementation intent; used only to build a neutral requirement profile"),
+  known_tech: z.array(z.string()).optional().describe("Known technologies involved in the requirement profile"),
+  detected_entities: z.record(z.array(z.string())).optional().describe("Optional path-keyed detected entities for the requirement profile"),
+  client_hash: z.string().optional().describe("Revision hash from a prior fab_plan_context response; enables stale detection"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records"),
+  // v2.0-rc.5 A3 (TASK-007): `include_deprecated` removed — it was a no-op
+  // placeholder (MaturitySchema has no `deprecated` value). When the maturity
+  // enum widens we re-introduce the flag as part of that protocol bump.
+  // v2/rc.2 (Q6): client-supplied layer scope. When omitted, the server
+  // falls back to fabric-config.default_layer_filter (TASK-002) so a single
+  // workspace policy controls the default. Explicit values override.
+  layer_filter: z.enum(["team", "personal", "both"]).optional().describe(
+    "Restrict description_index to the named layer. Default: fabric-config.default_layer_filter (TASK-002)."
+  ),
+  // v2.0-rc.5 C3 (TASK-012): explicit path context for `narrow` relevance
+  // filtering. When omitted, the server falls back to `paths` so existing
+  // callers see narrowing against the requested paths. When the resolved
+  // list is empty, the narrow filter fails open (every narrow entry passes).
+  target_paths: z.array(z.string()).optional().describe(
+    "Path context for narrow-scope relevance filtering. Defaults to `paths`; empty = no filter."
+  )
+});
+var planContextOutputSchema = z.object({
+  revision_hash: z.string(),
+  stale: z.boolean(),
+  selection_token: z.string(),
+  entries: z.array(
+    z.object({
+      path: z.string(),
+      requirement_profile: _requirementProfileSchema,
+      description_index: z.array(_descriptionIndexItemSchema)
+    })
+  ),
+  shared: z.object({
+    description_index: z.array(_descriptionIndexItemSchema),
+    preflight_diagnostics: z.array(
+      z.object({
+        code: z.literal("missing_description"),
+        severity: z.literal("warn"),
+        message: z.string(),
+        stable_ids: z.array(z.string()).optional(),
+        path: z.string().optional()
+      })
+    )
+  }),
+  warnings: z.array(structuredWarningSchema).optional()
+});
+var planContextAnnotations = {
+  readOnlyHint: true,
+  idempotentHint: true,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Plan rule context"
+};
+var planContextHintNarrowEntrySchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  maturity: z.string(),
+  summary: z.string()
+});
+var planContextHintOutputSchema = z.object({
+  version: z.literal(1),
+  revision_hash: z.string(),
+  target_paths: z.array(z.string()),
+  narrow: z.array(planContextHintNarrowEntrySchema),
+  broad_count: z.number().int().nonnegative()
+});
+var _knowledgeEntrySchema = z.object({ path: z.string(), content: z.string() });
+var _humanLockedSchema = z.object({ file: z.string(), excerpt: z.string() });
+var _descriptionStubSchema = z.object({ path: z.string(), description: z.string() });
+var getKnowledgeInputSchema = z.object({
+  path: z.string().describe("Target file path to query rules for"),
+  client_hash: z.string().optional().describe("Revision hash from prior fab_get_rules response; enables stale detection"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records")
+});
+var getKnowledgeOutputSchema = z.object({
+  revision_hash: z.string(),
+  stale: z.boolean(),
+  rules: z.object({
+    L0: z.string(),
+    L1: z.array(_knowledgeEntrySchema),
+    L2: z.array(_knowledgeEntrySchema),
+    human_locked_nearby: z.array(_humanLockedSchema),
+    description_stubs: z.array(_descriptionStubSchema).optional()
+  }),
+  warnings: z.array(structuredWarningSchema).optional()
+});
+var getKnowledgeAnnotations = {
+  readOnlyHint: true,
+  idempotentHint: true,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Get rule content"
+};
+var KNOWLEDGE_SECTION_NAMES_TUPLE = ["MISSION_STATEMENT", "MANDATORY_INJECTION", "BUSINESS_LOGIC_CHUNKS", "CONTEXT_INFO"];
+var knowledgeSectionsInputSchema = z.object({
+  selection_token: z.string().min(1).describe("Selection token returned by fab_plan_context"),
+  sections: z.array(z.enum(KNOWLEDGE_SECTION_NAMES_TUPLE)).min(1).describe("Structured rule sections to fetch"),
+  ai_selected_stable_ids: z.array(z.string()).describe("AI-selected L1 stable_ids chosen from fab_plan_context ai_selectable_stable_ids"),
+  ai_selection_reasons: z.record(z.string().min(1)).describe("Reason for each AI-selected L1 stable_id"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records"),
+  // v2.0 rc.5 TASK-014 (C5): optional client identity hash propagated into
+  // knowledge_consumed events. Falls back to empty string when unset — full
+  // client-identity propagation deferred to rc.6.
+  client_hash: z.string().optional().describe("Optional caller-provided client hash propagated into knowledge_consumed events")
+});
+var knowledgeSectionsOutputSchema = z.object({
+  revision_hash: z.string(),
+  precedence: z.tuple([z.literal("L2"), z.literal("L1"), z.literal("L0")]),
+  selected_stable_ids: z.array(z.string()),
+  rules: z.array(
+    z.object({
+      stable_id: z.string(),
+      level: z.enum(["L0", "L1", "L2"]),
+      path: z.string(),
+      sections: z.record(z.string())
+    })
+  ),
+  diagnostics: z.array(
+    z.discriminatedUnion("code", [
+      z.object({
+        code: z.literal("missing_section"),
+        severity: z.literal("warn"),
+        stable_id: z.string(),
+        section: z.enum(KNOWLEDGE_SECTION_NAMES_TUPLE),
+        message: z.string()
+      }),
+      // v2.0: warn-level diagnostic for un-migrated v1.x entries (no
+      // knowledge_type and no knowledge_layer). Does NOT block selection.
+      z.object({
+        code: z.literal("missing_knowledge_metadata"),
+        severity: z.literal("warn"),
+        stable_id: z.string(),
+        message: z.string()
+      })
+    ])
+  ),
+  // v2/rc.3 (Q6): present iff a layer-flip in fab_review/modify changed the
+  // canonical stable_id since the caller's selection_token was minted.
+  // Clients should retry against `redirect_to.stable_id`.
+  redirect_to: z.object({ stable_id: z.string() }).optional().describe(
+    "Post-layer-flip redirect. Populated when stable_id changed after token mint (rc.3 fab_review/modify)."
+  ),
+  warnings: z.array(structuredWarningSchema).optional()
+});
+var knowledgeSectionsAnnotations = {
+  readOnlyHint: true,
+  idempotentHint: true,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Filter rule sections"
+};
+var ProposedReasonSchema = z.enum([
+  "explicit-user-mark",
+  "diagnostic-then-fix",
+  "decision-confirmation",
+  "wrong-turn-revert",
+  "new-dependency-or-pattern",
+  "dismissal-with-reason"
+]);
+var PROPOSED_REASON_DESCRIPTIONS = {
+  "explicit-user-mark": "\u7528\u6237\u663E\u5F0F\u6807\u8BB0\u9700\u5F52\u6863\uFF08always / never / \u4E0B\u6B21\u6CE8\u610F \u7B49\u89C4\u8303\u6027\u8BED\u8A00\uFF09\u3002",
+  "diagnostic-then-fix": "\u8BCA\u65AD\u8FC7\u7A0B\u53D1\u73B0\u65B0\u6A21\u5F0F\u6216\u8E29\u5751\uFF0C\u4FEE\u590D\u540E\u503C\u5F97\u6C89\u6DC0\u3002",
+  "decision-confirmation": "\u22652 \u5019\u9009\u65B9\u6848\u7ECF\u6743\u8861\u540E\u786E\u8BA4\u9009\u578B\uFF0C\u9700\u4FDD\u7559 rationale\u3002",
+  "wrong-turn-revert": "\u5C1D\u8BD5\u67D0\u8DEF\u5F84\u540E\u56DE\u9000\uFF0C\u9519\u8BEF\u8DEF\u5F84\u672C\u8EAB\u662F\u503C\u5F97\u8BB0\u5F55\u7684 pitfall\u3002",
+  "new-dependency-or-pattern": "\u5F15\u5165\u65B0\u4F9D\u8D56 / \u65B0\u6A21\u5F0F / \u65B0\u547D\u540D\u7EA6\u5B9A\u3002",
+  "dismissal-with-reason": "\u7528\u6237\u660E\u786E\u62D2\u7EDD\u67D0\u65B9\u6848\u5E76\u7ED9\u51FA\u539F\u56E0\uFF0C\u539F\u56E0\u5373\u53EF\u5F52\u6863\u77E5\u8BC6\u3002"
+};
+var _sourceSessionsField = z.preprocess(
+  (value) => {
+    if (typeof value === "string") return [value];
+    return value;
+  },
+  z.array(z.string().min(1)).min(1)
+);
+var _FabExtractKnowledgeInputBaseSchema = z.object({
+  // v2.0.0-rc.7 T5: array form. Legacy single-string callers are accepted
+  // via the preprocess shim above. The optional pre-T5 alias `source_session`
+  // is kept as an accepted alternative below for in-flight integrations
+  // (Zod parses one or the other — see refinement).
+  source_sessions: _sourceSessionsField.optional().describe(
+    "Originating session ids; correlates with Event Ledger records. Array form (T5). Single string accepted via back-compat shim."
+  ),
+  // Pre-T5 alias. When set and source_sessions is missing, the handler maps
+  // it to [source_session]. Marked optional so new callers can drop it.
+  source_session: z.string().min(1).optional().describe(
+    "DEPRECATED \u2014 pre-T5 alias for source_sessions. Use source_sessions: string[]. Single string still accepted for back-compat."
+  ),
+  recent_paths: z.array(z.string()).describe("Workspace paths recently touched in the source session \u2014 used as scope hints"),
+  user_messages_summary: z.string().describe("Skill-side summary of the user's intent/messages, kept compact"),
+  type: z.enum(["decisions", "pitfalls", "guidelines", "models", "processes"]).describe("Knowledge type bucket (plural form, mirrors directory layout)"),
+  slug: z.string().describe("URL-safe short identifier proposed by the Skill; server may sanitize"),
+  // rc.5 B1: dual pending root. When 'personal', the server writes to
+  // ~/.fabric/knowledge/pending/<type>/; otherwise to .fabric/knowledge/pending/<type>/.
+  // Defaults to 'team' to preserve existing call sites (Skill bumps as needed).
+  layer: z.enum(["team", "personal"]).optional().describe(
+    "Storage layer for the pending entry. 'team' writes under the workspace; 'personal' writes under the user's home. Defaults to 'team'."
+  ),
+  // v2.0.0-rc.7 T6: proposed_reason — required enum that drives `## Why
+  // proposed` rendering. Skills (archive / import / review) infer the
+  // appropriate reason per their semantics (see each SKILL.md).
+  proposed_reason: ProposedReasonSchema.describe(
+    "Why this entry is being proposed. Drives `## Why proposed` rendering and enables future maturity-promotion scoring."
+  ),
+  // v2.0.0-rc.7 T6: session_context — required 3-5 line markdown blob that
+  // captures the session goal + key turning point. Future-self review reads
+  // this without conversation transcript access. Min length guards against
+  // empty placeholders; cap is soft (no max), Skill caps at ~600 chars.
+  session_context: z.string().min(20, { message: "session_context must be \u226520 chars (3-5 lines describing goal + turning point)" }).describe(
+    "3-5 line markdown blob \u2014 session goal + key turning point. Reviewed by future-self without transcript access."
+  )
+});
+var FabExtractKnowledgeInputSchema = _FabExtractKnowledgeInputBaseSchema.superRefine(
+  (value, ctx) => {
+    const hasArray = Array.isArray(value.source_sessions) && value.source_sessions.length > 0;
+    const hasString = typeof value.source_session === "string" && value.source_session.length > 0;
+    if (!hasArray && !hasString) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "either source_sessions (array, preferred) or source_session (legacy single string) must be provided",
+        path: ["source_sessions"]
+      });
+    }
+  }
+);
+var FabExtractKnowledgeInputShape = _FabExtractKnowledgeInputBaseSchema.shape;
+var FabExtractKnowledgeOutputSchema = z.object({
+  pending_path: z.string().describe("Workspace-relative path to the persisted pending entry"),
+  idempotency_key: z.string().describe("Stable key derived from inputs; identical inputs yield identical key")
+});
+var fabExtractKnowledgeAnnotations = {
+  readOnlyHint: false,
+  idempotentHint: true,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Extract pending knowledge entry"
+};
+var _fabReviewFiltersSchema = z.object({
+  type: z.enum(["decisions", "pitfalls", "guidelines", "models", "processes"]).optional(),
+  layer: z.enum(["team", "personal", "both"]).optional(),
+  maturity: z.enum(["draft", "verified", "proven"]).optional(),
+  tags: z.array(z.string()).optional(),
+  // rc.4 TASK-006 fix (c): ISO-8601 lower bound on entry created_at; entries
+  // strictly older than this threshold are excluded from list / search
+  // results. Additive optional field — existing callers unaffected.
+  created_after: z.string().datetime().optional()
+}).optional();
+var _fabReviewModifyChangesSchema = z.object({
+  title: z.string().optional(),
+  summary: z.string().optional(),
+  // Q7: writing `layer` here triggers a layer-flip; downstream callers may
+  // observe a redirect_to in fab_get_knowledge_sections if stable_id changes.
+  layer: z.enum(["team", "personal"]).optional(),
+  maturity: z.enum(["draft", "verified", "proven"]).optional(),
+  tags: z.array(z.string()).optional(),
+  // v2.0-rc.5 C3 (TASK-012): relevance scope/paths patches. Applied to
+  // pending AND canonical entries. When an explicit team→personal layer flip
+  // arrives on a narrow entry, the server auto-degrades to broad + [] and
+  // emits a `knowledge_scope_degraded` event regardless of what the caller
+  // sent in these fields (personal-implies-broad).
+  relevance_scope: z.enum(["narrow", "broad"]).optional(),
+  relevance_paths: z.array(z.string()).optional()
+});
+var FabReviewInputSchema = z.discriminatedUnion("action", [
+  z.object({
+    action: z.literal("list"),
+    filters: _fabReviewFiltersSchema
+  }),
+  z.object({
+    action: z.literal("approve"),
+    pending_paths: z.array(z.string()).min(1)
+  }),
+  z.object({
+    action: z.literal("reject"),
+    pending_paths: z.array(z.string()).min(1),
+    reason: z.string().min(1)
+  }),
+  z.object({
+    action: z.literal("modify"),
+    pending_path: z.string().min(1),
+    changes: _fabReviewModifyChangesSchema
+  }),
+  z.object({
+    action: z.literal("search"),
+    query: z.string().min(1),
+    filters: _fabReviewFiltersSchema
+  }),
+  z.object({
+    action: z.literal("defer"),
+    pending_paths: z.array(z.string()).min(1),
+    until: z.string().datetime().optional(),
+    reason: z.string().optional()
+  })
+]);
+var _fabReviewListItemSchema = z.object({
+  pending_path: z.string(),
+  type: z.enum(["decisions", "pitfalls", "guidelines", "models", "processes"]),
+  layer: z.enum(["team", "personal"]),
+  maturity: z.enum(["draft", "verified", "proven"]),
+  tags: z.array(z.string()).optional(),
+  title: z.string().optional(),
+  summary: z.string().optional(),
+  // rc.5 B1: dual pending root. 'team' = workspace .fabric/knowledge/pending,
+  // 'personal' = ~/.fabric/knowledge/pending. Distinct from `layer` (frontmatter):
+  // origin reflects where the pending file actually lives on disk; layer reflects
+  // the declared classification that will drive the approve destination.
+  origin: z.enum(["team", "personal"]).optional()
+});
+var FabReviewOutputSchema = z.discriminatedUnion("action", [
+  z.object({
+    action: z.literal("list"),
+    items: z.array(_fabReviewListItemSchema)
+  }),
+  z.object({
+    action: z.literal("approve"),
+    approved: z.array(z.object({ pending_path: z.string(), stable_id: z.string() }))
+  }),
+  z.object({
+    action: z.literal("reject"),
+    rejected: z.array(z.string())
+  }),
+  z.object({
+    action: z.literal("modify"),
+    pending_path: z.string(),
+    // When a layer-flip occurred, prior_stable_id and new_stable_id differ.
+    prior_stable_id: z.string().optional(),
+    new_stable_id: z.string().optional()
+  }),
+  z.object({
+    action: z.literal("search"),
+    items: z.array(_fabReviewListItemSchema)
+  }),
+  z.object({
+    action: z.literal("defer"),
+    deferred: z.array(z.string())
+  })
+]);
+var fabReviewAnnotations = {
+  readOnlyHint: false,
+  idempotentHint: false,
+  destructiveHint: false,
+  openWorldHint: false,
+  title: "Review pending knowledge entries"
+};
+var ledgerSourceSchema = z.enum(["ai", "human"]);
+var timestampFilterSchema = z.preprocess((value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    if (/^\d+$/.test(trimmed)) {
+      return Number.parseInt(trimmed, 10);
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isNaN(parsed) ? value : parsed;
+  }
+  return value;
+}, z.number().int().nonnegative());
+var ledgerQuerySchema = z.object({
+  source: ledgerSourceSchema.optional(),
+  since: timestampFilterSchema.optional()
+});
+var historyStateQuerySchema = z.object({
+  ledger_id: z.string().trim().min(1).optional(),
+  ts: timestampFilterSchema.optional()
+}).superRefine((value, ctx) => {
+  const provided = [value.ledger_id, value.ts].filter((entry) => entry !== void 0);
+  if (provided.length !== 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Provide exactly one of ledger_id or ts.",
+      path: ["ledger_id"]
+    });
+  }
+});
+var humanLockApproveRequestSchema = z.object({
+  file: z.string().min(1),
+  start_line: z.number().int().positive(),
+  end_line: z.number().int().positive(),
+  new_hash: z.string().min(1)
+});
+var humanLockFileParamsSchema = z.object({
+  file: z.string().min(1)
+});
+var annotateIntentRequestSchema = z.object({
+  ledger_entry_id: z.string().min(1),
+  annotation: z.string().trim().min(1)
+});
+var KnowledgeTypeSchema = z.enum([
+  "model",
+  // entities, data structures, relationships
+  "decision",
+  // architectural/technical choices with rationale
+  "guideline",
+  // recommended practices (recommend) or anti-patterns (avoid)
+  "pitfall",
+  // known risks, failure modes, troubleshooting
+  "process"
+  // workflows, state machines, operational steps
+]);
+var MaturitySchema = z.enum(["draft", "verified", "proven"]);
+var LayerSchema = z.enum(["personal", "team"]);
+var StableIdSchema = z.string().regex(/^K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d{4,}$/);
+var KnowledgeEntryFrontmatterSchema = z.object({
+  id: StableIdSchema,
+  // e.g., "KT-DEC-0042"
+  type: KnowledgeTypeSchema,
+  // one of 5 types
+  maturity: MaturitySchema,
+  // draft | verified | proven
+  layer: LayerSchema,
+  // personal | team
+  layer_reason: z.string().optional(),
+  // why this layer (for ambiguous cases)
+  created_at: z.string()
+  // ISO 8601 timestamp
+  // Note: 'tags' and other fields can be added later but core schema is these 6
+});
+var KNOWLEDGE_TYPE_CODES = {
+  model: "MOD",
+  decision: "DEC",
+  guideline: "GLD",
+  pitfall: "PIT",
+  process: "PRO"
+};
+function formatKnowledgeId(layer, type, counter) {
+  const layerPrefix = layer === "personal" ? "KP" : "KT";
+  const typeCode = KNOWLEDGE_TYPE_CODES[type];
+  return `${layerPrefix}-${typeCode}-${String(counter).padStart(4, "0")}`;
+}
+function parseKnowledgeId(id) {
+  const match = id.match(/^(KP|KT)-(MOD|DEC|GLD|PIT|PRO)-(\d+)$/);
+  if (!match) return null;
+  const layer = match[1] === "KP" ? "personal" : "team";
+  const typeCode = match[2];
+  const entry = Object.entries(KNOWLEDGE_TYPE_CODES).find(([, code]) => code === typeCode);
+  if (!entry) return null;
+  const type = entry[0];
+  return { layer, type, counter: parseInt(match[3], 10) };
+}
+
+export {
+  structuredWarningSchema,
+  planContextInputSchema,
+  planContextOutputSchema,
+  planContextAnnotations,
+  planContextHintNarrowEntrySchema,
+  planContextHintOutputSchema,
+  getKnowledgeInputSchema,
+  getKnowledgeOutputSchema,
+  getKnowledgeAnnotations,
+  knowledgeSectionsInputSchema,
+  knowledgeSectionsOutputSchema,
+  knowledgeSectionsAnnotations,
+  ProposedReasonSchema,
+  PROPOSED_REASON_DESCRIPTIONS,
+  FabExtractKnowledgeInputSchema,
+  FabExtractKnowledgeInputShape,
+  FabExtractKnowledgeOutputSchema,
+  fabExtractKnowledgeAnnotations,
+  FabReviewInputSchema,
+  FabReviewOutputSchema,
+  fabReviewAnnotations,
+  ledgerSourceSchema,
+  ledgerQuerySchema,
+  historyStateQuerySchema,
+  humanLockApproveRequestSchema,
+  humanLockFileParamsSchema,
+  annotateIntentRequestSchema,
+  KnowledgeTypeSchema,
+  MaturitySchema,
+  LayerSchema,
+  StableIdSchema,
+  KnowledgeEntryFrontmatterSchema,
+  KNOWLEDGE_TYPE_CODES,
+  formatKnowledgeId,
+  parseKnowledgeId
+};

package/dist/i18n/index.d.ts

@@ -12,7 +12,7 @@ declare function detectNodeLocale(): Locale;
 
 declare function normalizeLocale(raw: string | null | undefined): Locale;
 
-declare const PROTECTED_TOKENS: readonly ["fab_plan_context", "fab_get_rule_sections", "fabric_rules", "ledger_entry", "ledger_entry_id", "agent_meta", "AGENTS.md", "FABRIC.md", ".fabric/agents/", ".fabric/agents/_cross/", ".fabric/agents.meta.json", ".fabric/human-lock.json", ".fabric/init-context.json", ".fabric/forensic.json", ".fabric/.intent-ledger.jsonl", ".fabric/events.jsonl", "@HUMAN", "shadow constraints", "Shadow Mirroring", "CORE RULES", "DO NOT TRANSLATE", "MUST", "NEVER"];
+declare const PROTECTED_TOKENS: readonly ["fab_plan_context", "fab_get_knowledge_sections", "fab_extract_knowledge", "fab_review", "AGENTS.md", ".fabric/agents/", ".fabric/agents/_cross/", ".fabric/agents.meta.json", ".fabric/human-lock.json", ".fabric/events.jsonl", ".fabric/knowledge/", "knowledge_proposed", "@HUMAN", "MUST", "NEVER"];
 type ProtectedToken = (typeof PROTECTED_TOKENS)[number];
 
 declare const enMessages: Messages;

package/dist/i18n/index.js

@@ -6,7 +6,7 @@ import {
   enMessages,
   normalizeLocale,
   zhCNMessages
-} from "../chunk-KHIM6MWS.js";
+} from "../chunk-U2SR2M4L.js";
 export {
   PROTECTED_TOKENS,
   createTranslator,