@fenglimg/fabric-shared 2.0.0 → 2.1.0-rc.2

package/dist/index.js

@@ -1,3 +1,12 @@
+import {
+  BOOTSTRAP_CANONICAL,
+  BOOTSTRAP_MARKER_BEGIN,
+  BOOTSTRAP_MARKER_END,
+  BOOTSTRAP_REGEX,
+  LEGACY_KB_MARKER_BEGIN,
+  LEGACY_KB_MARKER_END,
+  LEGACY_KB_REGEX
+} from "./chunk-MDWTGOAY.js";
 import {
   PROTECTED_TOKENS,
   createTranslator,
@@ -5,29 +14,37 @@ import {
   detectNodeLocale,
   enMessages,
   normalizeLocale,
+  resolveFabricLocale,
   zhCNMessages
-} from "./chunk-U2SR2M4L.js";
+} from "./chunk-R2J7DAED.js";
 import {
   FabExtractKnowledgeInputSchema,
   FabExtractKnowledgeInputShape,
   FabExtractKnowledgeOutputSchema,
   FabReviewInputSchema,
+  FabReviewInputShape,
   FabReviewOutputSchema,
+  FabReviewOutputShape,
   KNOWLEDGE_TYPE_CODES,
   KnowledgeEntryFrontmatterSchema,
   KnowledgeTypeSchema,
   LayerSchema,
   MaturitySchema,
+  ONBOARD_SLOT_NAMES,
+  ONBOARD_SLOT_TOTAL,
   PROPOSED_REASON_DESCRIPTIONS,
   ProposedReasonSchema,
   StableIdSchema,
   annotateIntentRequestSchema,
+  archiveScanAnnotations,
+  archiveScanInputSchema,
+  archiveScanOutputSchema,
+  citeContractMetricsSchema,
+  citeCoverageReportSchema,
+  citeLayerTypeBreakdownSchema,
   fabExtractKnowledgeAnnotations,
   fabReviewAnnotations,
   formatKnowledgeId,
-  getKnowledgeAnnotations,
-  getKnowledgeInputSchema,
-  getKnowledgeOutputSchema,
   historyStateQuerySchema,
   humanLockApproveRequestSchema,
   humanLockFileParamsSchema,
@@ -36,19 +53,30 @@ import {
   knowledgeSectionsOutputSchema,
   ledgerQuerySchema,
   ledgerSourceSchema,
+  onboardSlotSchema,
   parseKnowledgeId,
   planContextAnnotations,
   planContextHintNarrowEntrySchema,
   planContextHintOutputSchema,
   planContextInputSchema,
   planContextOutputSchema,
+  recallAnnotations,
+  recallInputSchema,
+  recallOutputSchema,
   structuredWarningSchema
-} from "./chunk-VQDCDCJA.js";
+} from "./chunk-WVPDH4BF.js";
 import "./chunk-LXNCAKJZ.js";
 
 // src/schemas/agents-meta.ts
 import { z } from "zod";
 var FABRIC_AGENTS_PREFIX = ".fabric/agents/";
+var KNOWLEDGE_TYPE_SINGULAR_TO_PLURAL = {
+  model: "models",
+  decision: "decisions",
+  guideline: "guidelines",
+  pitfall: "pitfalls",
+  process: "processes"
+};
 var AGENTS_META_LAYERS = ["L0", "L1", "L2"];
 var AGENTS_META_TOPOLOGY_TYPES = ["mirror", "cross-cutting", "domain", "local", "global"];
 var AGENTS_META_IDENTITY_SOURCES = ["declared", "derived"];
@@ -64,7 +92,15 @@ var ruleDescriptionSchema = z.object({
   entities: z.array(z.string()).optional(),
   // v2.0 knowledge entry fields (TASK-002 schemas). All optional for backward compat.
   id: z.string().optional(),
-  knowledge_type: z.enum(["model", "decision", "guideline", "pitfall", "process"]).optional(),
+  // rc.31 NEW-1: forward-compat for legacy on-disk agents.meta.json carrying
+  // singular knowledge_type values (model/decision/guideline/pitfall/process).
+  // Normalize to canonical plural form before enum validation so doctor and
+  // plan-context-hint can load pre-rc.28 meta files without aborting. Disk
+  // gets rewritten to plural on next reconcile (via knowledge-meta-builder).
+  knowledge_type: z.preprocess(
+    (value) => typeof value === "string" && value in KNOWLEDGE_TYPE_SINGULAR_TO_PLURAL ? KNOWLEDGE_TYPE_SINGULAR_TO_PLURAL[value] : value,
+    z.enum(["models", "decisions", "guidelines", "pitfalls", "processes"])
+  ).optional(),
   maturity: z.enum(["draft", "verified", "proven"]).optional(),
   knowledge_layer: z.enum(["personal", "team"]).optional(),
   layer_reason: z.string().optional(),
@@ -134,8 +170,7 @@ function withDerivedAgentsMetaNodeDefaults(node) {
   const identitySource = isKnowledgeEntry ? "declared" : deriveAgentsMetaIdentitySource(node);
   return {
     ...node,
-    layer: node.layer ?? node.level ?? deriveAgentsMetaLayer(node.file),
-    level: node.level ?? node.layer ?? deriveAgentsMetaLayer(node.file),
+    level: node.level ?? deriveAgentsMetaLayer(node.file),
     topology_type: node.topology_type ?? deriveAgentsMetaTopologyType(node.file),
     stable_id: stableId,
     identity_source: identitySource
@@ -164,7 +199,7 @@ function defaultAgentsMetaCounters() {
 }
 function deriveAgentsMetaStableId(file) {
   const normalized = normalizePath(file);
-  if (normalized === "AGENTS.md" || normalized === ".fabric/bootstrap/README.md") {
+  if (normalized === "AGENTS.md") {
     return "bootstrap";
   }
   return getDepthSource(normalized).replace(/\.md$/u, "");
@@ -181,7 +216,7 @@ function deriveAgentsMetaIdentitySource(node) {
 }
 function deriveAgentsMetaLayer(file) {
   const normalized = normalizePath(file);
-  if (normalized === "AGENTS.md" || normalized === ".fabric/bootstrap/README.md") {
+  if (normalized === "AGENTS.md") {
     return "L0";
   }
   if (hasCrossCuttingSegment(normalized)) {
@@ -292,31 +327,139 @@ var humanLockFileSchema = z4.object({
 });
 
 // src/schemas/fabric-config.ts
+import { z as z6 } from "zod";
+
+// src/schemas/store.ts
 import { z as z5 } from "zod";
-var auditModeSchema = z5.enum(["strict", "warn", "off"]);
-var clientPathsSchema = z5.object({
-  claudeCodeCLI: z5.string().optional(),
-  claudeCodeDesktop: z5.string().optional(),
-  cursor: z5.string().optional(),
-  codexCLI: z5.string().optional()
+var STORE_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+var storeUuidSchema = z5.string().regex(STORE_UUID_PATTERN, "store_uuid must be a canonical lowercase UUID");
+var PERSONAL_STORE_SENTINEL = "$personal";
+var storeIdentitySchema = z5.object({
+  // Intrinsic, immutable once minted. Read from store.json, never recomputed.
+  store_uuid: storeUuidSchema,
+  // ISO-8601. When the store was first initialized.
+  created_at: z5.string(),
+  // Optional human-facing canonical alias baked into the store (e.g. the
+  // team picks "platform-kb"). Local per-machine aliases are resolved by the
+  // StoreResolver from config and may differ; this is the suggested default.
+  canonical_alias: z5.string().optional(),
+  // Optional one-line description surfaced in `store list` / onboarding.
+  description: z5.string().optional(),
+  // The semantic scopes this store is *allowed* to hold. A shared (team)
+  // store MUST NOT list "personal" (R5#3 privacy boundary, enforced at write
+  // time in P2). Open coordinate strings — see schemas/scope.ts.
+  allowed_scopes: z5.array(z5.string()).optional()
+}).strict();
+var requiredStoreEntrySchema = z5.object({
+  id: z5.string().min(1),
+  suggested_remote: z5.union([z5.string().min(1), z5.literal(PERSONAL_STORE_SENTINEL)]).optional()
+}).strict();
+var STORE_KNOWLEDGE_TYPE_DIRS = [
+  "models",
+  "decisions",
+  "guidelines",
+  "pitfalls",
+  "processes"
+];
+var STORE_LAYOUT = {
+  identityFile: "store.json",
+  knowledgeDir: "knowledge",
+  bindingsDir: "bindings",
+  stateDir: "state"
+};
+var STORES_ROOT_DIR = "stores";
+var GLOBAL_STATE_DIR = "state";
+var GLOBAL_BINDINGS_DIR = "bindings";
+function storeKnowledgeTypeDir(type) {
+  return `${STORE_LAYOUT.knowledgeDir}/${type}`;
+}
+function storeRelativePath(storeUuid) {
+  return `${STORES_ROOT_DIR}/${storeUuid}`;
+}
+var mountedStoreSchema = z5.object({
+  // Intrinsic identity of the mounted store (matches its store.json).
+  store_uuid: storeUuidSchema,
+  // Local per-machine alias the user references this store by (resolver maps
+  // alias → uuid). May differ from the store's canonical_alias.
+  alias: z5.string().min(1),
+  // Git remote locator for this clone, if any. Absent = local-only store
+  // (valid; doctor nudges to add a remote for backup — R5#5, P6).
+  remote: z5.string().min(1).optional(),
+  // v2.1.0-rc.1 P3: marks the implicit personal store (the one minted by
+  // `install --global`). Exactly one mounted store carries personal=true; it
+  // is the write target for personal-scope entries (R5#3) and always in the
+  // read-set (S11). Optional (no default) so the output type stays a plain
+  // optional — consumers coalesce `?? false` when building resolver input.
+  personal: z5.boolean().optional(),
+  // Whether writes are accepted into this store from this machine. Optional;
+  // consumers coalesce `?? true`. Shared stores cloned read-only set false.
+  writable: z5.boolean().optional()
 }).strict();
-var mcpPayloadLimitsSchema = z5.object({
-  warnBytes: z5.number().int().positive().optional(),
-  hardBytes: z5.number().int().positive().optional()
+var globalConfigSchema = z5.object({
+  // Machine/account identity. Personal-knowledge id namespace (S33/S27).
+  uid: z5.string().min(1),
+  // All stores mounted on this machine. The implicit personal store is
+  // included here once initialized. Default empty so a fresh global config
+  // (before `install --global`) parses cleanly.
+  stores: z5.array(mountedStoreSchema).optional().default([])
+}).passthrough();
+
+// src/schemas/fabric-config.ts
+var auditModeSchema = z6.enum(["strict", "warn", "off"]);
+var clientPathsSchema = z6.object({
+  claudeCodeCLI: z6.string().optional(),
+  claudeCodeDesktop: z6.string().optional(),
+  cursor: z6.string().optional(),
+  codexCLI: z6.string().optional()
+}).strict();
+var mcpPayloadLimitsSchema = z6.object({
+  warnBytes: z6.number().int().positive().optional(),
+  hardBytes: z6.number().int().positive().optional()
 }).optional();
-var knowledgeLanguageSchema = z5.enum(["match-existing", "zh-CN", "en"]);
-var defaultLayerFilterSchema = z5.enum(["team", "personal", "both"]);
-var fabricConfigSchema = z5.object({
+var selectionTokenTtlMsSchema = z6.number().int().min(3e4).max(36e5);
+var fabricLanguageSchema = z6.enum([
+  "match-existing",
+  "zh-CN",
+  "en",
+  "zh-CN-hybrid"
+]);
+var defaultLayerFilterSchema = z6.enum(["team", "personal", "both"]);
+var fabricConfigSchema = z6.object({
   clientPaths: clientPathsSchema.optional(),
-  externalFixturePath: z5.string().optional(),
-  scanIgnores: z5.array(z5.string()).optional(),
-  auditMode: auditModeSchema.optional(),
+  // v2.1.0-rc.1 P0 (S13-projectid): the project's stable identity. A UUID
+  // bound at `fabric install` time; a remote-derived hash is only a SUGGESTED
+  // default, never authoritative (so re-homing the git remote does not change
+  // project identity). Optional under the zero-user clean-slate — pre-v2.1
+  // fabric-config.json files simply lack it and the ProjectRootResolver mints
+  // one on next install. `.fabric/fabric-config.json` carrying this field is
+  // also the upward marker the ProjectRootResolver searches for (S15/S32).
+  project_id: z6.string().optional(),
+  // v2.1.0-rc.1 P0 (S59/B3): the stores this repo expects mounted. Each entry
+  // names a store by alias/UUID with an optional suggested_remote (or the
+  // `$personal` sentinel). Drives the read-set (required_stores ∪ implicit
+  // personal, S11/S54) and `clone`'s missing-store onboarding (S51). Optional
+  // + absent → read-set is just the implicit personal store.
+  required_stores: z6.array(requiredStoreEntrySchema).optional(),
+  // v2.1.0-rc.1 P3 (S60 / `store switch-write`): alias of the store that
+  // non-personal-scope writes land in for this project. Set by
+  // `fabric store switch-write <alias>`; consumed as the resolver's
+  // activeWriteAlias. Absent → no active write store yet. Personal-scope
+  // writes always target the implicit personal store regardless (R5#3).
+  active_write_store: z6.string().optional(),
+  // rc.17 (R-cut): the dev/test fixture-path config field was removed
+  // end-to-end. The `EXTERNAL_FIXTURE_PATH` env var is now the sole source
+  // consumed by `resolveDevMode()`. No z.preprocess alias — pre-rc.17
+  // fabric-config.json files carrying the field will be silently dropped by
+  // the lenient root parser (no .strict() at root). Pre-user clean-slate per
+  // memory/feedback_clean_slate.md; mirrors the rc.12 hard-rename precedent
+  // documented above.
+  scanIgnores: z6.array(z6.string()).optional(),
   audit_mode: auditModeSchema.optional(),
   mcpPayloadLimits: mcpPayloadLimitsSchema,
   // Backward-compat: both fields are optional with defaults so existing
   // fabric-config.json files (pre-grill-followup) parse unchanged. The default
   // values themselves are load-bearing — see docs/data-schema.md.
-  knowledge_language: knowledgeLanguageSchema.optional().default("match-existing"),
+  fabric_language: fabricLanguageSchema.optional().default("match-existing"),
   default_layer_filter: defaultLayerFilterSchema.optional().default("both"),
   // Cooldown for the fabric-hint Stop hook (formerly archive-hint, renamed in
   // rc.5 TASK-010). After ANY of the three signals (archive / review / import)
@@ -325,7 +468,7 @@ var fabricConfigSchema = z5.object({
   // day if the user keeps ignoring it." Set to 24 to align with the archive
   // trigger threshold. The legacy `archive_hint_` key is retained for backward
   // compat with existing user fabric-config.json files.
-  archive_hint_cooldown_hours: z5.number().int().positive().optional().default(12),
+  archive_hint_cooldown_hours: z6.number().int().positive().optional().default(12),
   // Underseed-node threshold for the fabric-hint Stop hook's import signal
   // (rc.5 TASK-010). When the canonical knowledge node count is strictly less
   // than this value AND a successful `init_scan_completed` event happened at
@@ -334,7 +477,7 @@ var fabricConfigSchema = z5.object({
   // the rule-of-thumb that a workspace with fewer than ten knowledge entries
   // is below the floor for plan_context retrieval to be meaningful. Also
   // consumed by `doctor` lint #22 (knowledge_underseeded).
-  underseed_node_threshold: z5.number().int().positive().optional().default(10),
+  underseed_node_threshold: z6.number().int().positive().optional().default(10),
   // Edit-count threshold for the fabric-hint Stop hook's Signal A
   // (rc.6 TASK-022 / E5). Signal A fires when EITHER (a) >=24h have elapsed
   // since the last `knowledge_proposed` event, OR (b) >=archive_edit_threshold
@@ -345,185 +488,1348 @@ var fabricConfigSchema = z5.object({
   // there is probably something worth archiving"; lowered values nag more
   // aggressively, higher values rely on the 24h fallback. Missing or absent
   // edit-counter file degrades safely to the 24h-only path.
-  archive_edit_threshold: z5.number().int().positive().optional().default(20),
+  archive_edit_threshold: z6.number().int().positive().optional().default(20),
   // rc.7 T7: hours-since-last-knowledge_proposed cutoff for Signal A's
   // time branch. Was hardcoded as 24 in fabric-hint.cjs's THRESHOLD_HOURS;
   // externalized so chatty workspaces can lower the bar and quiet ones can
   // raise it. Default 24 preserves rc.6 behavior. See docs/configuration.md.
-  archive_hint_hours: z5.number().int().positive().optional().default(24),
+  archive_hint_hours: z6.number().int().positive().optional().default(24),
   // rc.7 T7: pending-count cutoff for Signal B (review skill). Was
   // hardcoded as 10 in fabric-hint.cjs's THRESHOLD_PENDING_COUNT.
   // Default 10 preserves rc.6 behavior. See docs/configuration.md for
   // small/medium/large repo recommendations.
-  review_hint_pending_count: z5.number().int().positive().optional().default(10),
+  review_hint_pending_count: z6.number().int().positive().optional().default(10),
   // rc.7 T7: pending-age cutoff (in days) for Signal B (review skill).
   // Was hardcoded as 7 in fabric-hint.cjs's THRESHOLD_PENDING_AGE_DAYS.
   // Default 7 preserves rc.6 behavior. See docs/configuration.md.
-  review_hint_pending_age_days: z5.number().int().positive().optional().default(7),
+  review_hint_pending_age_days: z6.number().int().positive().optional().default(7),
   // rc.7 T7 + T10 pre-wiring: days-since-last-doctor cutoff for the future
   // Signal D (maintenance hint). T10 will consume this to decide when the
   // fabric-hint Stop hook surfaces a "run `fabric doctor`" reminder.
   // Default 14 reflects a fortnightly cadence — long enough to avoid nag,
   // short enough to catch index drift before it compounds.
-  maintenance_hint_days: z5.number().int().positive().optional().default(14),
+  maintenance_hint_days: z6.number().int().positive().optional().default(14),
   // rc.7 T7 + T10 pre-wiring: cooldown between Signal D reminders, in
   // days. Once Signal D fires, it stays silent for this many days even if
   // the user doesn't run doctor. Default 7 keeps the reminder weekly at
   // worst — pairing 14d trigger + 7d cooldown means at most ~2 reminders
   // per month for a workspace that ignores them.
-  maintenance_hint_cooldown_days: z5.number().int().positive().optional().default(7)
+  maintenance_hint_cooldown_days: z6.number().int().positive().optional().default(7),
+  // rc.9+ (skill-contract-fix B1): first-run import window in months. The
+  // `fabric-import` skill scans this many months of git history on the very
+  // first invocation (when no prior `import_run_completed` event exists).
+  // Default 60 (~5 years) captures the bulk of a mature repo's signal in
+  // one pass; small / fresh repos can lower to 12-24 with no loss.
+  import_window_first_run_months: z6.number().int().min(1).optional().default(60),
+  // rc.9+ (skill-contract-fix B1): rerun import window in months. After
+  // the first successful import, subsequent runs only scan this many
+  // recent months — assumed everything older has already been crystallized
+  // into pending or canonical knowledge. Default 2 keeps incremental cost
+  // low; raise to 6 if the workspace pauses fabric-import for long stretches.
+  import_window_rerun_months: z6.number().int().min(1).optional().default(2),
+  // rc.9+ (skill-contract-fix B1): hard cap on pending entries produced
+  // per fabric-import invocation. Prevents one run from dumping hundreds
+  // of proposals when a backfill window is wide open. Default 10 matches
+  // the rule-of-thumb "human can triage ~10 pending entries in one
+  // review pass." Range 1-50.
+  import_max_pending_per_run: z6.number().int().min(1).max(50).optional().default(10),
+  // rc.9+ (skill-contract-fix B1): hard cap on commits scanned per
+  // fabric-import invocation. Bounds runtime on monorepos with high
+  // commit velocity. Default 500 covers ~2 months of typical churn;
+  // range 50-2000. Hitting the cap mid-window is logged but non-fatal.
+  import_max_commits_scan: z6.number().int().min(50).max(2e3).optional().default(500),
+  // rc.9+ (skill-contract-fix B1): canonical-node count above which
+  // fabric-import's pre-flight should warn / suggest review instead of
+  // proceeding. A workspace with 50+ canonical entries usually benefits
+  // more from `fabric-review` to consolidate than from importing more.
+  // Default 50; raise to 100+ for large polyglot repos.
+  import_skip_canonical_threshold: z6.number().int().positive().optional().default(50),
+  // rc.9+ (skill-contract-fix B1): max candidate entries surfaced per
+  // fabric-archive batch (one invocation of the skill). Pagination knob
+  // for the archive UI flow. Default 8 keeps each batch reviewable in
+  // one sitting; raise for large repos with high archive throughput.
+  archive_max_candidates_per_batch: z6.number().int().positive().optional().default(8),
+  // rc.9+ (skill-contract-fix B1): max recently-touched paths included
+  // in fabric-archive's "relevant context" lookup. Limits the size of
+  // the path-relevance digest the skill emits when ranking candidates.
+  // Default 20; large repos with deep directory fan-out can raise to
+  // 50+ if archive candidates feel under-contextualized.
+  archive_max_recent_paths: z6.number().int().positive().optional().default(20),
+  // rc.9+ (skill-contract-fix B1): max prior fabric-archive sessions
+  // summarised in the digest the skill loads on start. Prevents the
+  // digest from ballooning past the model context budget on workspaces
+  // that have archived repeatedly. Default 10; lower if context pressure
+  // bites, raise if you want longer-range archive trend visibility.
+  archive_digest_max_sessions: z6.number().int().positive().optional().default(10),
+  // rc.9+ (skill-contract-fix B1): max review results returned per
+  // topic when `fabric-review` clusters pending entries. Pagination
+  // knob analogous to archive_max_candidates_per_batch but scoped to
+  // each topic cluster. Default 8; raise to 15-20 for large repos
+  // where each topic legitimately groups many pending entries.
+  review_topic_result_cap: z6.number().int().positive().optional().default(8),
+  // rc.9+ (skill-contract-fix B1): age threshold (in days) above which
+  // a pending entry is considered "stale" by fabric-review and surfaced
+  // for explicit resolve-or-drop decision. Default 14; tighter than the
+  // 7d Signal-B trigger because review specifically targets the long
+  // tail. Large repos with slower cadence can raise to 30.
+  review_stale_pending_days: z6.number().int().positive().optional().default(14),
+  // v2.0.0-rc.34 TASK-05: reverse-unarchive opt-in. When true, callers of the
+  // `unarchiveKnowledge` primitive (and any future doctor auto-detect lint built
+  // on top) will execute the file move + ledger emit. When false (default),
+  // the same callers MUST short-circuit before any mutation — the primitive is
+  // shipped but inert until explicitly enabled. Opt-in posture mirrors the
+  // archive-flow precedent: destructive-ish file moves stay behind a flag.
+  reverse_unarchive_enabled: z6.boolean().optional().default(false),
+  // v2.0.0-rc.34 TASK-05: forces `unarchiveKnowledge` into dry-run mode even
+  // when called with `options.dryRun=false`. Lets operators preview a
+  // restoration pass before flipping `reverse_unarchive_enabled` to true.
+  reverse_unarchive_dry_run: z6.boolean().optional().default(false),
+  // v2.0.0-rc.34 TASK-06: long-session cite-policy evict window in user-prompt
+  // turns. UserPromptSubmit hook (Claude Code only) maintains a per-session
+  // counter and re-injects the cite contract reminder via
+  // hookSpecificOutput.additionalContext when `turn_count % interval === 0`.
+  // Default 0 = OFF (opt-in). Recommend 10-20 for active sessions; 5 for
+  // high-contract-criticality projects. Other strategies (time-based,
+  // token-budget) deferred to rc.35 per plan locked-decisions 2026-05-26.
+  cite_evict_interval: z6.number().int().min(0).optional().default(0),
+  // v2.0.0-rc.22 Scope A T3: sliding-window retention (in days) for the
+  // event ledger rotation primitive (`rotateEventLedgerIfNeeded`). Lines
+  // whose `ts` is older than `now - fabric_event_retention_days * 86_400_000`
+  // are partitioned into `.fabric/events.archive/events-rotated-YYYY-MM-DD.jsonl`.
+  // Locked to 7/30/90 — three operator-friendly preset windows. Default 30
+  // is applied at the consumer site (rotateEventLedgerIfNeeded), so this
+  // field stays `.optional()` without a `.default()` to keep the schema
+  // surface honest: absence means "use the library default", not "schema
+  // default of 30 was injected." 7 = ~tight, 30 = balanced, 90 = forensic.
+  // Mirrors cite-policy precedent of locking enum-style numeric tunables
+  // to a small literal set (vs free `.positive()`) to prevent fat-finger
+  // misconfig.
+  fabric_event_retention_days: z6.union([z6.literal(7), z6.literal(30), z6.literal(90)]).optional(),
+  // v2.0.0-rc.23 TASK-014 (F8c): onboard slot opt-out list. Tracks slot
+  // names the user explicitly dismissed during fabric-archive's first-run
+  // onboard phase (or via `fabric config dismiss-slot <slot>`). Dismissed
+  // slots are excluded from `fabric onboard-coverage`'s `missing` set and the
+  // doctor `Onboard coverage` advisory's recompute, so the user is never
+  // re-prompted for slots they consciously declined.
+  //
+  // Re-opening a dismissed slot requires `fabric config onboard-reset <slot>`
+  // — a deliberate two-command UX to keep the dismiss intent reversible
+  // but never silently undone. Schema is intentionally `z.array(z.string())`
+  // rather than `z.array(onboardSlotSchema)` so historical configs survive
+  // a slot rename without a Zod parse error; downstream consumers
+  // intersect against ONBOARD_SLOT_NAMES at read time.
+  //
+  // Default `[]` keeps the field optional on existing configs — fresh
+  // installs land with no opt-outs.
+  onboard_slots_opted_out: z6.array(z6.string()).optional().default([]),
+  // v2.0.0-rc.33 W2-1 (P0-9): TopK upper bound for the broad SessionStart hint
+  // banner emitted by knowledge-hint-broad.cjs. After plan-context-hint returns
+  // its full broad-scoped index, the hook slices the entries to this many
+  // before grouping/truncation rendering — keeps the banner from scrolling off
+  // screen on well-seeded repos (Werewolf-class projects routinely surface 40+
+  // broad entries which buried the actually-relevant top hits). Default 8 is
+  // calibrated against the rc.32 eval baseline (cite-coverage 3.1%): the
+  // banner needs to fit in ~1 screenful so the agent actually reads it.
+  // Range 1..50; values above 20 effectively disable the cap because the
+  // TRUNCATION_THRESHOLD=12 grouped-render kicks in. Mirrors the rc.7 T7 +
+  // archive_max_* pattern of externalizing previously-hardcoded thresholds.
+  hint_broad_top_k: z6.number().int().min(1).max(50).optional().default(8),
+  // v2.0.0-rc.37 NEW-16: durable per-signal dismiss for the fabric-hint Stop
+  // hook nudges. Any signal type listed here is suppressed at emit time across
+  // all sessions (the session-scoped sibling lives in a .fabric/.cache sidecar
+  // written on request). Mirrors the cite_evict_interval=0 opt-out convention —
+  // a knob for an existing surface, not a new feature. Unknown types ignored.
+  hint_dismiss_signals: z6.array(z6.enum(["archive", "review", "import", "maintenance"])).optional(),
+  // v2.0.0-rc.33 W2-1 (P0-9): TopK upper bound for the narrow PreToolUse hint
+  // emitted by knowledge-hint-narrow.cjs. After filtering to entries whose
+  // `relevance_scope === "narrow"` (rc.27 TASK-005 audit §2.5 fix), the hook
+  // slices to this many before the E3 emit-gate / renderSummary pipeline.
+  // Default 5 keeps each per-Edit hint terse — five lines max so the agent's
+  // working memory is not displaced by an unwieldy banner. Range 1..20.
+  hint_narrow_top_k: z6.number().int().min(1).max(20).optional().default(5),
+  // v2.0.0-rc.33 W2-1 (P0-9): per-file dedup window (in PreToolUse turns) for
+  // the narrow hint. Same (file_path, stable_id) tuple stays silent for this
+  // many turns even when the E3 cross-session cache would otherwise re-emit.
+  // Closes the rc.32 eval finding that a single hot file (e.g. werewolf
+  // GameRoom.tsx edited 30 times in a row) re-fired the same narrow hint
+  // each time, training the agent to ignore it. Default 5; range 1..50.
+  // Storage: .fabric/.cache/narrow-dedup-window.json — distinct from session-
+  // hints cache so a window-only suppression does not poison cross-session
+  // dedupe semantics.
+  hint_narrow_dedup_window_turns: z6.number().int().min(1).max(50).optional().default(5),
+  // v2.0.0-rc.33 W2-5 (P1-8): cooldown between broad SessionStart hint emits,
+  // in hours. Distinct from the archive_hint_cooldown_hours that gates the
+  // fabric-hint Stop hook — knowledge-hint-broad re-fires on every
+  // SessionStart by default (compact / clear / new-window), which on long
+  // sessions becomes redundant noise. Setting to 1 means "emit the broad
+  // menu at most once per hour"; 0 means "no cooldown, current behavior."
+  // Range 0..168 (one week). Stored alongside fabric-hint's cooldown cache
+  // under a distinct knowledge-hint-broad key.
+  hint_broad_cooldown_hours: z6.number().int().min(0).max(168).optional().default(0),
+  // v2.0.0-rc.33 W2-5 (P1-8): cooldown for the narrow PreToolUse hint.
+  // Same shape as hint_broad_cooldown_hours but applies to per-Edit hint
+  // re-emission across the cooldown window — independent of E3 session-
+  // hints dedupe. Default 0 preserves rc.32 behavior; set to e.g. 1 to
+  // throttle hint frequency during rapid-fire editing sprints. Range
+  // 0..168 (one week).
+  hint_narrow_cooldown_hours: z6.number().int().min(0).max(168).optional().default(0),
+  // v2.0.0-rc.33 W4-B3 (T5 P2): per-maturity inactivity thresholds (days)
+  // driving orphan_demote. Hardcoded at stable=90/endorsed=30/draft=14 in
+  // rc.32; chatty workspaces want them tighter, slow ones want them looser.
+  // Each field optional; absent → defaults inside doctor.ts apply. Ranges
+  // chosen so a typo can't accidentally disable the lint (min 1).
+  orphan_demote_stable_days: z6.number().int().min(1).max(3650).optional(),
+  orphan_demote_endorsed_days: z6.number().int().min(1).max(3650).optional(),
+  orphan_demote_draft_days: z6.number().int().min(1).max(3650).optional(),
+  // v2.0.0-rc.33 W4-A3 (T4 P2): per-entry summary truncation length used by
+  // knowledge-hint-{broad,narrow}.cjs. Hard-coded at 80 chars in rc.32 — too
+  // short for entries with parameterized summaries (e.g. "Use bcrypt with
+  // cost=12 for password hashing"), too long for terse pitfalls. Range 40..240;
+  // default 80 preserves rc.32 behavior. Both hooks read the same key so the
+  // banner styling stays consistent across SessionStart + PreToolUse.
+  hint_summary_max_len: z6.number().int().min(40).max(240).optional().default(80),
+  // v2.0.0-rc.33 W2-6 (P0-7 + P0-8): when true, knowledge-hint hooks emit
+  // their banners as `hookSpecificOutput.additionalContext` JSON on stdout
+  // (per Claude Code PreToolUse hook contract — see
+  // https://docs.claude.com/en/docs/claude-code/hooks#preToolUse), so the
+  // agent receives them in-context instead of as stderr breadcrumbs the
+  // user may not surface to the model. Default true reflects the rc.33 cite-
+  // coverage focus (rc.32 baseline 3.1% → primary cause: reminders never
+  // entered model context). Set false to revert to legacy stderr-only mode
+  // for hosts that don't honor the JSON contract.
+  hint_reminder_to_context: z6.boolean().optional().default(true),
+  // v2.0.0-rc.29 TASK-008 (BUG-F3): selection-token TTL override. The
+  // `fab_plan_context` MCP tool hands clients a `selection_token` whose default
+  // 5-minute lifetime (`SELECTION_TOKEN_TTL_MS` at
+  // packages/server/src/services/plan-context.ts:91) was hard-coded and could
+  // not be tuned for slow review cycles. Operators on long-running sessions
+  // (manual paste-and-review flows, debugger pauses, etc.) reported tokens
+  // expiring mid-review. Override here; absence means "use the library default
+  // of 5*60*1000 ms." Range 30s..1h keeps the value useful — below 30s the
+  // token expires before MCP round-trips finish; above 1h it stops being a
+  // meaningful liveness signal for the plan-context cache.
+  //
+  // The single-field schema is exported separately (`selectionTokenTtlMsSchema`)
+  // so the server-side per-field reader can validate without re-running the
+  // whole fabricConfigSchema on every plan_context call — that lets a corrupt
+  // unrelated field stay isolated from the hot read path.
+  selection_token_ttl_ms: selectionTokenTtlMsSchema.optional()
+});
+
+// src/schemas/fabric-config-introspect.ts
+import { z as z7 } from "zod";
+var positiveIntSchema = z7.coerce.number().int().positive();
+function makePositiveIntField(key, defaultValue) {
+  return {
+    key,
+    group: "B_hint_threshold",
+    widget: "text",
+    label_i18n_key: `cli.config.fields.${key}.label`,
+    description_i18n_key: `cli.config.fields.${key}.description`,
+    default: defaultValue,
+    validate(raw) {
+      const trimmed = raw.trim();
+      if (trimmed === "") {
+        return { ok: false, error: "Value is required (positive integer)." };
+      }
+      const parsed = positiveIntSchema.safeParse(trimmed);
+      if (!parsed.success) {
+        return {
+          ok: false,
+          error: "Must be a positive integer (e.g. 1, 12, 24)."
+        };
+      }
+      return { ok: true, value: parsed.data };
+    },
+    format_for_display(value) {
+      if (typeof value === "number") return String(value);
+      if (value === void 0 || value === null) return String(defaultValue);
+      return String(value);
+    }
+  };
+}
+function makeEnumField(key, group, enumValues, defaultValue) {
+  return {
+    key,
+    group,
+    widget: "select",
+    label_i18n_key: `cli.config.fields.${key}.label`,
+    description_i18n_key: `cli.config.fields.${key}.description`,
+    default: defaultValue,
+    enum_values: enumValues,
+    validate(raw) {
+      const trimmed = raw.trim();
+      if (!enumValues.includes(trimmed)) {
+        return {
+          ok: false,
+          error: `Must be one of: ${enumValues.join(", ")}.`
+        };
+      }
+      return { ok: true, value: trimmed };
+    },
+    format_for_display(value) {
+      if (typeof value === "string" && enumValues.includes(value)) return value;
+      if (value === void 0 || value === null) return defaultValue;
+      return String(value);
+    }
+  };
+}
+var SCHEMA_DEFAULTS = fabricConfigSchema.parse({});
+function pickNumberDefault(key) {
+  const v = SCHEMA_DEFAULTS[key];
+  if (typeof v !== "number") {
+    throw new Error(
+      `fabric-config-introspect: expected numeric default for ${String(key)}, got ${typeof v}`
+    );
+  }
+  return v;
+}
+function pickStringDefault(key) {
+  const v = SCHEMA_DEFAULTS[key];
+  if (typeof v !== "string") {
+    throw new Error(
+      `fabric-config-introspect: expected string default for ${String(key)}, got ${typeof v}`
+    );
+  }
+  return v;
+}
+var AUDIT_MODE_PANEL_DEFAULT = "warn";
+function getPanelFields() {
+  return PANEL_FIELDS;
+}
+function getPanelFieldByKey(key) {
+  return PANEL_FIELDS.find((f) => f.key === key);
+}
+var PANEL_FIELDS = [
+  // --- Group A: Locale (2) ---
+  makeEnumField(
+    "fabric_language",
+    "A_locale",
+    fabricLanguageSchema.options,
+    pickStringDefault("fabric_language")
+  ),
+  makeEnumField(
+    "default_layer_filter",
+    "A_locale",
+    defaultLayerFilterSchema.options,
+    pickStringDefault("default_layer_filter")
+  ),
+  // --- Group B: Hint thresholds (8 — see leading docstring for the
+  //     7-vs-8 reconciliation; archive_edit_threshold is the 8th key) ---
+  makePositiveIntField("archive_hint_hours", pickNumberDefault("archive_hint_hours")),
+  makePositiveIntField(
+    "archive_hint_cooldown_hours",
+    pickNumberDefault("archive_hint_cooldown_hours")
+  ),
+  makePositiveIntField(
+    "archive_edit_threshold",
+    pickNumberDefault("archive_edit_threshold")
+  ),
+  makePositiveIntField(
+    "underseed_node_threshold",
+    pickNumberDefault("underseed_node_threshold")
+  ),
+  makePositiveIntField(
+    "review_hint_pending_count",
+    pickNumberDefault("review_hint_pending_count")
+  ),
+  makePositiveIntField(
+    "review_hint_pending_age_days",
+    pickNumberDefault("review_hint_pending_age_days")
+  ),
+  makePositiveIntField(
+    "maintenance_hint_days",
+    pickNumberDefault("maintenance_hint_days")
+  ),
+  makePositiveIntField(
+    "maintenance_hint_cooldown_days",
+    pickNumberDefault("maintenance_hint_cooldown_days")
+  ),
+  // --- Group C: Audit (1) ---
+  makeEnumField(
+    "audit_mode",
+    "C_audit",
+    auditModeSchema.options,
+    AUDIT_MODE_PANEL_DEFAULT
+  )
+];
+
+// src/schemas/scope.ts
+import { z as z8 } from "zod";
+var PERSONAL_SCOPE = "personal";
+var KNOWN_SCOPE_PREFIXES = ["personal", "team", "project", "org"];
+var SCOPE_COORDINATE_PATTERN = /^[a-z0-9_-]+(:[a-z0-9_-]+)*$/u;
+var scopeCoordinateSchema = z8.string().min(1).regex(
+  SCOPE_COORDINATE_PATTERN,
+  "scope coordinate must be ':'-joined lowercase [a-z0-9_-] segments"
+);
+function scopeRoot(coordinate) {
+  const colon = coordinate.indexOf(":");
+  return colon === -1 ? coordinate : coordinate.slice(0, colon);
+}
+function isPersonalScope(coordinate) {
+  return scopeRoot(coordinate) === PERSONAL_SCOPE;
+}
+var entryScopeMetadataSchema = z8.object({
+  semantic_scope: scopeCoordinateSchema,
+  // Store alias or UUID. Validated as a non-empty string here; the resolver
+  // (P0.6) maps alias→UUID and verifies the store is in the read-set.
+  visibility_store: z8.string().min(1)
+}).strict();
+
+// src/schemas/store-stable-id.ts
+import { z as z9 } from "zod";
+var localKnowledgeIdSchema = StableIdSchema;
+var UID_SEGMENT_PATTERN = /^[a-z0-9-]+$/u;
+var uidSchema = z9.string().min(1).regex(UID_SEGMENT_PATTERN, "uid must be lowercase [a-z0-9-] segments");
+var GLOBAL_REF_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(:[a-z0-9-]+)?:K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d{4,}$/u;
+var globalRefSchema = z9.string().regex(GLOBAL_REF_PATTERN, "global_ref must be <store_uuid>[:<uid>]:<local_id>");
+function formatGlobalRef(parts) {
+  const { store_uuid, uid, local_id } = parts;
+  return uid === void 0 ? `${store_uuid}:${local_id}` : `${store_uuid}:${uid}:${local_id}`;
+}
+function parseGlobalRef(ref) {
+  if (!GLOBAL_REF_PATTERN.test(ref)) {
+    return null;
+  }
+  const localMatch = ref.match(/K[PT]-(?:MOD|DEC|GLD|PIT|PRO)-\d{4,}$/u);
+  if (localMatch === null) {
+    return null;
+  }
+  const local_id = localMatch[0];
+  const head = ref.slice(0, ref.length - local_id.length - 1);
+  const firstColon = head.indexOf(":");
+  if (firstColon === -1) {
+    return { store_uuid: head, local_id };
+  }
+  return {
+    store_uuid: head.slice(0, firstColon),
+    uid: head.slice(firstColon + 1),
+    local_id
+  };
+}
+var storeKnowledgeTypeCountersSchema = z9.object({
+  MOD: z9.number().int().nonnegative().default(0),
+  DEC: z9.number().int().nonnegative().default(0),
+  GLD: z9.number().int().nonnegative().default(0),
+  PIT: z9.number().int().nonnegative().default(0),
+  PRO: z9.number().int().nonnegative().default(0)
+}).default({ MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 });
+var storeCountersSchema = z9.object({
+  KP: storeKnowledgeTypeCountersSchema,
+  KT: storeKnowledgeTypeCountersSchema
+}).default({
+  KP: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 },
+  KT: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 }
 });
 
+// src/schemas/parity-matrix.ts
+import { z as z10 } from "zod";
+var PARITY_CLIENTS = ["claudeCode", "codexCLI", "cursor"];
+var parityClientSchema = z10.enum(PARITY_CLIENTS);
+var PARITY_SURFACES = ["skill", "hook", "mcp", "render"];
+var paritySurfaceSchema = z10.enum(PARITY_SURFACES);
+var parityClientExpectationSchema = z10.object({
+  supported: z10.boolean(),
+  mechanism: z10.string().optional(),
+  notes: z10.string().optional()
+}).strict();
+var parityCapabilitySchema = z10.object({
+  id: z10.string().min(1),
+  surface: paritySurfaceSchema,
+  description: z10.string().min(1),
+  clients: z10.object({
+    claudeCode: parityClientExpectationSchema,
+    codexCLI: parityClientExpectationSchema,
+    cursor: parityClientExpectationSchema
+  }).strict()
+}).strict();
+var parityMatrixSchema = z10.object({
+  // Schema/version tag of the matrix document itself.
+  version: z10.string().min(1),
+  // Free-form note on what release/milestone this matrix targets.
+  generated_for: z10.string().min(1),
+  capabilities: z10.array(parityCapabilitySchema).min(1)
+}).strict();
+
+// src/resolver/contracts.ts
+import { z as z11 } from "zod";
+var PROJECT_ROOT_SIGNALS = ["env", "marker", "cwd", "repo"];
+var projectRootSignalSchema = z11.enum(PROJECT_ROOT_SIGNALS);
+var projectRootSignalsSchema = z11.object({
+  // FABRIC_PROJECT_ROOT, if set.
+  env: z11.string().optional(),
+  // Nearest directory AT-OR-ABOVE cwd holding `.fabric/fabric-config.json`,
+  // if any (the upward marker search result; may equal cwd).
+  markerDir: z11.string().optional(),
+  // Always present — the process cwd.
+  cwd: z11.string().min(1),
+  // git repo root, if inside a repo.
+  repoRoot: z11.string().optional(),
+  // The `project_id` read from the winning root's fabric-config.json during
+  // (fs) signal collection. The pure resolver echoes it — it cannot invent a
+  // UUID. Worktrees of one repo share the committed config, hence the same
+  // project_id (S45 merge). Absent when no .fabric config exists at the root
+  // yet (fresh repo-fallback) → resolution still yields the root with a null
+  // projectId so the caller can mint+persist one at install time.
+  discoveredProjectId: z11.string().optional()
+}).strict();
+var projectRootResolutionSchema = z11.object({
+  // Absolute project root directory.
+  projectRoot: z11.string().min(1),
+  // Stable project identity. One repo = one .fabric = one project_id (S32);
+  // git worktrees of the same repo resolve to the SAME project_id (S45).
+  // Null when the resolved root has no fabric-config.json yet (fresh
+  // repo-fallback) — the caller mints + persists a UUID at install time.
+  projectId: z11.string().min(1).nullable(),
+  // Which signal won.
+  signalUsed: projectRootSignalSchema
+}).strict();
+var STORE_RESOLVER_WARNING_CODES = [
+  "missing_store",
+  // required_stores entry has no matching mounted store (S51)
+  "local_only_no_remote",
+  // mounted but local-only (R5#5 nudge, non-fatal)
+  "alias_unresolved"
+  // referenced alias maps to no mounted store
+];
+var storeResolverWarningCodeSchema = z11.enum(STORE_RESOLVER_WARNING_CODES);
+var storeResolverWarningSchema = z11.object({
+  code: storeResolverWarningCodeSchema,
+  // The alias/UUID/id the warning concerns.
+  ref: z11.string().min(1),
+  message: z11.string().min(1)
+}).strict();
+var readSetEntrySchema = z11.object({
+  store_uuid: z11.string().min(1),
+  alias: z11.string().min(1),
+  remote: z11.string().min(1).optional(),
+  // Whether this store accepts writes from the current context. Personal
+  // store is writable; shared stores writable iff mounted with write intent.
+  writable: z11.boolean()
+}).strict();
+var storeReadSetSchema = z11.object({
+  stores: z11.array(readSetEntrySchema),
+  warnings: z11.array(storeResolverWarningSchema)
+}).strict();
+var writeTargetSchema = z11.object({
+  store_uuid: z11.string().min(1),
+  alias: z11.string().min(1)
+}).strict();
+var storeResolveInputSchema = z11.object({
+  // Machine identity (S33) — namespaces personal ids; identifies personal store.
+  uid: z11.string().min(1),
+  // Stores mounted on this machine (from global config).
+  mountedStores: z11.array(
+    z11.object({
+      store_uuid: z11.string().min(1),
+      alias: z11.string().min(1),
+      remote: z11.string().min(1).optional(),
+      writable: z11.boolean().default(true),
+      // Marks the implicit personal store.
+      personal: z11.boolean().default(false)
+    }).strict()
+  ),
+  // The project's declared required_stores (ids/aliases + optional remote).
+  requiredStores: z11.array(
+    z11.object({
+      id: z11.string().min(1),
+      suggested_remote: z11.string().min(1).optional()
+    }).strict()
+  ),
+  // Alias selected as the active write store for non-personal scopes, if any.
+  activeWriteAlias: z11.string().min(1).optional()
+}).strict();
+var projectRootGoldenCaseSchema = z11.object({
+  name: z11.string().min(1),
+  note: z11.string().optional(),
+  signals: projectRootSignalsSchema,
+  // null expected = resolver should return no root for these signals.
+  expected: projectRootResolutionSchema.nullable()
+}).strict();
+var projectRootGoldenFileSchema = z11.object({
+  contract: z11.literal("project-root.golden"),
+  cases: z11.array(projectRootGoldenCaseSchema).min(1)
+}).strict();
+var readSetGoldenCaseSchema = z11.object({
+  name: z11.string().min(1),
+  note: z11.string().optional(),
+  input: storeResolveInputSchema,
+  // Scope under test for the write-target expectation.
+  writeScope: z11.string().min(1),
+  expected: z11.object({
+    readSet: storeReadSetSchema,
+    writeTarget: writeTargetSchema.nullable(),
+    writeWarnings: z11.array(storeResolverWarningSchema)
+  }).strict()
+}).strict();
+var readSetGoldenFileSchema = z11.object({
+  contract: z11.literal("read-set.golden"),
+  cases: z11.array(readSetGoldenCaseSchema).min(1)
+}).strict();
+
+// src/resolver/project-root-resolver.ts
+var ResolverNotImplementedError = class extends Error {
+  constructor(what) {
+    super(`${what} is not implemented yet (TDD target)`);
+    this.name = "ResolverNotImplementedError";
+  }
+};
+function createProjectRootResolver() {
+  return {
+    resolve(signals) {
+      const projectId = signals.discoveredProjectId ?? null;
+      if (signals.env !== void 0) {
+        return { projectRoot: signals.env, projectId, signalUsed: "env" };
+      }
+      if (signals.markerDir !== void 0) {
+        return {
+          projectRoot: signals.markerDir,
+          projectId,
+          signalUsed: signals.markerDir === signals.cwd ? "cwd" : "marker"
+        };
+      }
+      if (signals.repoRoot !== void 0) {
+        return { projectRoot: signals.repoRoot, projectId, signalUsed: "repo" };
+      }
+      return null;
+    }
+  };
+}
+
+// src/resolver/store-resolver.ts
+function findPersonal(input) {
+  return input.mountedStores.find((s) => s.personal);
+}
+function personalEntry(input) {
+  const p = findPersonal(input);
+  if (p === void 0) {
+    return void 0;
+  }
+  const entry = { store_uuid: p.store_uuid, alias: p.alias, writable: p.writable };
+  if (p.remote !== void 0) {
+    entry.remote = p.remote;
+  }
+  return entry;
+}
+function createStoreResolver() {
+  return {
+    resolveReadSet(input) {
+      const stores = [];
+      const warnings = [];
+      for (const req of input.requiredStores) {
+        const matched = input.mountedStores.find(
+          (m) => !m.personal && (m.alias === req.id || m.store_uuid === req.id)
+        );
+        if (matched === void 0) {
+          const suffix = req.suggested_remote === void 0 ? "" : ` (suggested remote: ${req.suggested_remote})`;
+          warnings.push({
+            code: "missing_store",
+            ref: req.id,
+            message: `required store '${req.id}' is not mounted; run \`fabric store add\`${suffix}`
+          });
+          continue;
+        }
+        const entry = {
+          store_uuid: matched.store_uuid,
+          alias: matched.alias,
+          writable: matched.writable
+        };
+        if (matched.remote !== void 0) {
+          entry.remote = matched.remote;
+        } else {
+          warnings.push({
+            code: "local_only_no_remote",
+            ref: matched.alias,
+            message: `store '${matched.alias}' is local-only; add a git remote to back it up (\`fabric store ... \` / doctor nudge)`
+          });
+        }
+        stores.push(entry);
+      }
+      const personal = personalEntry(input);
+      if (personal !== void 0) {
+        stores.push(personal);
+      }
+      return { stores, warnings };
+    },
+    resolveWriteTarget(input, scope) {
+      if (isPersonalScope(scope)) {
+        const p = findPersonal(input);
+        if (p === void 0) {
+          return {
+            target: null,
+            warnings: [
+              {
+                code: "missing_store",
+                ref: "personal",
+                message: "no personal store is mounted; run `fabric install --global` first"
+              }
+            ]
+          };
+        }
+        return { target: { store_uuid: p.store_uuid, alias: p.alias }, warnings: [] };
+      }
+      const active = input.activeWriteAlias === void 0 ? void 0 : input.mountedStores.find((m) => m.writable && m.alias === input.activeWriteAlias);
+      if (active === void 0) {
+        return {
+          target: null,
+          warnings: [
+            {
+              code: "alias_unresolved",
+              ref: input.activeWriteAlias ?? scope,
+              message: `no writable store for scope '${scope}'; set an active write store with \`fabric store switch-write\``
+            }
+          ]
+        };
+      }
+      return { target: { store_uuid: active.store_uuid, alias: active.alias }, warnings: [] };
+    },
+    aliasToUuid(input, alias) {
+      return input.mountedStores.find((m) => m.alias === alias)?.store_uuid;
+    }
+  };
+}
+
+// src/resolver/store-disk-reader.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+function readStoreIdentity(absDir) {
+  const identityFile = join(absDir, STORE_LAYOUT.identityFile);
+  if (!existsSync(identityFile)) {
+    return null;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(identityFile, "utf8"));
+  } catch {
+    return null;
+  }
+  const parsed = storeIdentitySchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+function recognizeStoreDir(absDir) {
+  return readStoreIdentity(absDir) !== null;
+}
+var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".cjs",
+  ".mjs",
+  ".js",
+  ".ts",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".py",
+  ".rb",
+  ".pl"
+]);
+function hasScriptExtension(name) {
+  const dot = name.lastIndexOf(".");
+  return dot !== -1 && SCRIPT_EXTENSIONS.has(name.slice(dot).toLowerCase());
+}
+function findStoreExecutableViolations(absDir) {
+  const violations = [];
+  const walk = (dir, rel) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (rel === "" && entry === ".git") {
+        continue;
+      }
+      const abs = join(dir, entry);
+      const relPath = rel === "" ? entry : `${rel}/${entry}`;
+      let stat;
+      try {
+        stat = statSync(abs);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(abs, relPath);
+        continue;
+      }
+      if ((stat.mode & 73) !== 0 || hasScriptExtension(entry)) {
+        violations.push(relPath);
+      }
+    }
+  };
+  walk(absDir, "");
+  return violations;
+}
+
+// src/resolver/store-qualified-id.ts
+var LOCAL_ID = /^K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d{4,}$/u;
+function splitRef(ref) {
+  const localMatch = ref.match(/K[PT]-(?:MOD|DEC|GLD|PIT|PRO)-\d{4,}$/u);
+  if (localMatch === null) {
+    return null;
+  }
+  const localId = localMatch[0];
+  if (localId === ref) {
+    return { storeQualifier: null, localId };
+  }
+  const head = ref.slice(0, ref.length - localId.length);
+  if (!head.endsWith(":")) {
+    return null;
+  }
+  return { storeQualifier: head.slice(0, -1), localId };
+}
+function resolveStoreQualifiedId(ref, candidates) {
+  const split = splitRef(ref);
+  if (split === null || !LOCAL_ID.test(split.localId)) {
+    return { resolved: null, ambiguous: false, matches: [] };
+  }
+  const { storeQualifier, localId } = split;
+  if (storeQualifier !== null) {
+    const match = candidates.find(
+      (c) => c.local_id === localId && (c.alias === storeQualifier || c.store_uuid === storeQualifier)
+    );
+    return match === void 0 ? { resolved: null, ambiguous: false, matches: [] } : { resolved: match, ambiguous: false, matches: [match] };
+  }
+  const matches = candidates.filter((c) => c.local_id === localId);
+  if (matches.length === 1) {
+    return { resolved: matches[0], ambiguous: false, matches };
+  }
+  return { resolved: null, ambiguous: matches.length > 1, matches };
+}
+
+// src/resolver/resolution.ts
+function specificity(scope) {
+  return scope.split(":").length;
+}
+function resolveCandidates(candidates, options = {}) {
+  const storeOrder = options.storeOrder ?? [];
+  const storeRank = (uuid) => {
+    const idx = storeOrder.indexOf(uuid);
+    return idx === -1 ? storeOrder.length : idx;
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const c of candidates) {
+    if (seen.has(c.global_ref)) {
+      continue;
+    }
+    seen.add(c.global_ref);
+    deduped.push(c);
+  }
+  const byLocal = /* @__PURE__ */ new Map();
+  for (const c of deduped) {
+    const stores = byLocal.get(c.local_id) ?? /* @__PURE__ */ new Set();
+    stores.add(c.store_uuid);
+    byLocal.set(c.local_id, stores);
+  }
+  const warnings = [];
+  for (const [localId, stores] of byLocal) {
+    if (stores.size > 1) {
+      warnings.push({
+        code: "shadowed_local_id",
+        ref: localId,
+        message: `local id '${localId}' exists in ${stores.size} stores; references must be store-qualified`
+      });
+    }
+  }
+  for (const uuid of options.unavailableRequiredStores ?? []) {
+    warnings.push({
+      code: "required_store_unavailable",
+      ref: uuid,
+      message: `required store '${uuid}' is unavailable; results may be incomplete (not silently degraded)`
+    });
+  }
+  const sorted = [...deduped].sort((a, b) => {
+    const specDiff = specificity(b.semantic_scope) - specificity(a.semantic_scope);
+    if (specDiff !== 0) {
+      return specDiff;
+    }
+    const rankDiff = storeRank(a.store_uuid) - storeRank(b.store_uuid);
+    if (rankDiff !== 0) {
+      return rankDiff;
+    }
+    return a.global_ref < b.global_ref ? -1 : a.global_ref > b.global_ref ? 1 : 0;
+  });
+  const resolved = sorted.map((c, i) => ({
+    ...c,
+    rank: i,
+    reason: `scope '${scopeRoot(c.semantic_scope)}' (specificity ${specificity(
+      c.semantic_scope
+    )}), store '${c.alias}' (priority ${storeRank(c.store_uuid)})`
+  }));
+  return { resolved, warnings };
+}
+
+// src/store/core.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var STORE_PENDING_DIR = "pending";
+var STORE_GITIGNORE = [
+  "# v2.1 store \u2014 volatile / derived data is never committed",
+  "state/",
+  "agents.meta.json",
+  ".cache/",
+  ""
+].join("\n");
+function git(cwd, args) {
+  execFileSync("git", args, { cwd, stdio: ["ignore", "ignore", "pipe"] });
+}
+function initStore(absDir, identity, options = {}) {
+  const parsed = storeIdentitySchema.parse(identity);
+  const identityFile = join2(absDir, STORE_LAYOUT.identityFile);
+  if (existsSync2(identityFile)) {
+    throw new Error(`store already initialized at ${absDir} (store.json exists)`);
+  }
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+    mkdirSync(join2(absDir, STORE_LAYOUT.knowledgeDir, type), { recursive: true });
+  }
+  mkdirSync(join2(absDir, STORE_LAYOUT.knowledgeDir, STORE_PENDING_DIR), { recursive: true });
+  mkdirSync(join2(absDir, STORE_LAYOUT.bindingsDir), { recursive: true });
+  mkdirSync(join2(absDir, STORE_LAYOUT.stateDir), { recursive: true });
+  writeFileSync(identityFile, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  writeFileSync(join2(absDir, ".gitignore"), STORE_GITIGNORE, "utf8");
+  if (options.git !== false) {
+    git(absDir, ["init", "-b", "main"]);
+  }
+  const readBack = readStoreIdentity(absDir);
+  if (readBack === null) {
+    throw new Error(`store init wrote an unrecognizable store.json at ${absDir}`);
+  }
+  return readBack;
+}
+function listMarkdown(dir) {
+  if (!existsSync2(dir)) {
+    return [];
+  }
+  return readdirSync2(dir).filter((name) => name.endsWith(".md")).sort().map((name) => join2(dir, name));
+}
+function listStoreKnowledge(store) {
+  const refs = [];
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+    for (const file of listMarkdown(join2(store.dir, STORE_LAYOUT.knowledgeDir, type))) {
+      refs.push({ store_uuid: store.store_uuid, alias: store.alias, type, file });
+    }
+  }
+  return refs;
+}
+function readKnowledgeAcrossStores(stores) {
+  return stores.flatMap((store) => listStoreKnowledge(store));
+}
+function aggregatePendingAcrossStores(stores) {
+  return stores.flatMap(
+    (store) => listMarkdown(join2(store.dir, STORE_LAYOUT.knowledgeDir, STORE_PENDING_DIR)).map((file) => ({
+      store_uuid: store.store_uuid,
+      alias: store.alias,
+      type: STORE_PENDING_DIR,
+      file
+    }))
+  );
+}
+
+// src/store/secret-scan.ts
+var SECRET_RULES = [
+  { rule: "aws-access-key-id", re: /\bAKIA[0-9A-Z]{16}\b/ },
+  { rule: "private-key-block", re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/ },
+  { rule: "openai-api-key", re: /\bsk-[A-Za-z0-9]{20,}\b/ },
+  { rule: "github-token", re: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/ },
+  { rule: "slack-token", re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
+  {
+    rule: "credential-assignment",
+    re: /(?:password|passwd|secret|api[_-]?key|access[_-]?token|token)\s*[:=]\s*['"][^'"\s]{8,}['"]/i
+  }
+];
+function scanForSecrets(content) {
+  const findings = [];
+  const lines = content.split(/\r?\n/u);
+  for (let i = 0; i < lines.length; i++) {
+    for (const { rule, re } of SECRET_RULES) {
+      if (re.test(lines[i])) {
+        findings.push({ rule, line: i + 1 });
+      }
+    }
+  }
+  return findings;
+}
+function hasSecrets(content) {
+  return scanForSecrets(content).length > 0;
+}
+var REDACTION_PLACEHOLDER_PREFIX = "[REDACTED:";
+function redactSecrets(content) {
+  let out = content;
+  for (const { rule, re } of SECRET_RULES) {
+    const flags = re.flags.includes("i") ? "gi" : "g";
+    out = out.replace(new RegExp(re.source, flags), `${REDACTION_PLACEHOLDER_PREFIX}${rule}]`);
+  }
+  return out;
+}
+
+// src/store/cross-store-lint.ts
+function lintCrossStoreReferences(input) {
+  if (input.entryVisibility !== "shared") {
+    return [];
+  }
+  const violations = [];
+  for (const ref of input.referencedGlobalRefs) {
+    const parsed = parseGlobalRef(ref);
+    if (parsed === null) {
+      continue;
+    }
+    if (input.storeVisibility[parsed.store_uuid] === "personal") {
+      violations.push({
+        code: "personal-ref-in-shared",
+        ref,
+        to_store_uuid: parsed.store_uuid,
+        message: `shared-store entry references personal-store id '${ref}' \u2014 personal knowledge must not leak into a shared store`
+      });
+    }
+  }
+  return violations;
+}
+function isPersonalLeakIntoSharedStore(entryLayer, storeVisibility) {
+  return entryLayer === "personal" && storeVisibility === "shared";
+}
+
+// src/store/observability.ts
+function redactValue(value) {
+  return typeof value === "string" ? redactSecrets(value) : value;
+}
+function buildFailureTrace(stage, error, context = {}, code) {
+  const rawMessage = error instanceof Error ? error.message : typeof error === "string" ? error : String(error);
+  const derivedCode = code ?? (error instanceof Error && error.name ? error.name : "error");
+  const redactedContext = {};
+  for (const [key, value] of Object.entries(context)) {
+    redactedContext[key] = redactValue(value);
+  }
+  return {
+    stage,
+    code: derivedCode,
+    message: redactSecrets(rawMessage),
+    context: redactedContext
+  };
+}
+function buildDebugBundle(input) {
+  const redactDeep = (value) => {
+    if (typeof value === "string") {
+      return redactSecrets(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map(redactDeep);
+    }
+    if (value !== null && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = redactDeep(v);
+      }
+      return out;
+    }
+    return value;
+  };
+  return {
+    version: 1,
+    config: redactDeep(input.config),
+    diagnostics: redactDeep(input.diagnostics) ?? [],
+    events: input.includeEvents === true ? (input.events ?? []).map(redactSecrets) : [],
+    redacted: true
+  };
+}
+
+// src/schemas/provenance.ts
+import { z as z12 } from "zod";
+var knowledgeProvenanceSchema = z12.object({
+  store_uuid: storeUuidSchema,
+  alias: z12.string().min(1),
+  local_id: localKnowledgeIdSchema,
+  global_ref: globalRefSchema,
+  // Optional scope coordinate of the entry (resolution axis); present when the
+  // surfacing tool has read the entry's frontmatter.
+  semantic_scope: scopeCoordinateSchema.optional()
+}).strict();
+
+// src/schemas/mcp-store-contracts.ts
+import { z as z13 } from "zod";
+var MCP_STORE_AWARE_TOOLS = [
+  "fab_recall",
+  "fab_plan_context",
+  "fab_get_knowledge_sections",
+  "fab_archive_scan",
+  "fab_extract_knowledge",
+  "fab_review"
+];
+var storeAwareEntrySchema = z13.object({
+  stable_id: z13.string(),
+  global_ref: globalRefSchema,
+  provenance: knowledgeProvenanceSchema
+}).strict();
+var writtenToStoreSchema = z13.object({
+  store_uuid: storeUuidSchema,
+  alias: z13.string().min(1)
+}).strict();
+var MCP_STORE_AWARE_CONTRACTS = {
+  fab_recall: { tool: "fab_recall", surfacesEntries: true, echoesWrittenStore: false },
+  fab_plan_context: { tool: "fab_plan_context", surfacesEntries: true, echoesWrittenStore: false },
+  fab_get_knowledge_sections: {
+    tool: "fab_get_knowledge_sections",
+    surfacesEntries: true,
+    echoesWrittenStore: false
+  },
+  fab_archive_scan: {
+    tool: "fab_archive_scan",
+    surfacesEntries: false,
+    echoesWrittenStore: true
+  },
+  fab_extract_knowledge: {
+    tool: "fab_extract_knowledge",
+    surfacesEntries: false,
+    echoesWrittenStore: true
+  },
+  fab_review: { tool: "fab_review", surfacesEntries: true, echoesWrittenStore: true }
+};
+
+// src/schemas/bindings-snapshot.ts
+import { z as z14 } from "zod";
+var resolvedBindingsSnapshotSchema = z14.object({
+  // Schema version of the snapshot document.
+  version: z14.literal(1),
+  // The project this snapshot is bound to (S13).
+  project_id: z14.string().min(1),
+  // ISO-8601 generation timestamp (provenance / staleness signal for doctor).
+  generated_at: z14.string().min(1),
+  // Pre-resolved read-set (required_stores ∪ implicit personal + warnings).
+  read_set: storeReadSetSchema,
+  // Pre-resolved active write target for non-personal scopes (null if none).
+  write_target: writeTargetSchema.nullable()
+}).strict();
+
+// src/store/bindings.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function bindingsSnapshotPath(globalRoot, projectId) {
+  return join3(globalRoot, GLOBAL_STATE_DIR, GLOBAL_BINDINGS_DIR, `${projectId}_resolved.json`);
+}
+function writeBindingsSnapshot(options) {
+  const resolver = createStoreResolver();
+  const read_set = resolver.resolveReadSet(options.resolveInput);
+  const { target } = resolver.resolveWriteTarget(options.resolveInput, options.writeScope);
+  const snapshot = resolvedBindingsSnapshotSchema.parse({
+    version: 1,
+    project_id: options.projectId,
+    generated_at: options.now,
+    read_set,
+    write_target: target
+  });
+  const path = bindingsSnapshotPath(options.globalRoot, options.projectId);
+  mkdirSync2(join3(path, ".."), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+  return snapshot;
+}
+function readBindingsSnapshot(globalRoot, projectId) {
+  const path = bindingsSnapshotPath(globalRoot, projectId);
+  if (!existsSync3(path)) {
+    return null;
+  }
+  try {
+    const parsed = resolvedBindingsSnapshotSchema.safeParse(JSON.parse(readFileSync2(path, "utf8")));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/store/store-lifecycle.ts
+function findMountedStore(config, aliasOrUuid) {
+  return config.stores.find((s) => s.alias === aliasOrUuid || s.store_uuid === aliasOrUuid);
+}
+function addMountedStore(config, store) {
+  const aliasClash = config.stores.find(
+    (s) => s.alias === store.alias && s.store_uuid !== store.store_uuid
+  );
+  if (aliasClash !== void 0) {
+    throw new Error(
+      `alias '${store.alias}' already mounts store ${aliasClash.store_uuid}; choose another alias`
+    );
+  }
+  const existing = config.stores.find((s) => s.store_uuid === store.store_uuid);
+  const stores = existing === void 0 ? [...config.stores, store] : config.stores.map((s) => s.store_uuid === store.store_uuid ? store : s);
+  return { ...config, stores };
+}
+function detachMountedStore(config, alias) {
+  const detached = config.stores.find((s) => s.alias === alias) ?? null;
+  if (detached === null) {
+    return { config, detached: null };
+  }
+  return {
+    config: { ...config, stores: config.stores.filter((s) => s.alias !== alias) },
+    detached
+  };
+}
+function bindRequiredStore(required, entry) {
+  return required.some((r) => r.id === entry.id) ? required.map((r) => r.id === entry.id ? entry : r) : [...required, entry];
+}
+function explainStore(config, alias) {
+  const store = findMountedStore(config, alias);
+  if (store === void 0) {
+    return null;
+  }
+  return {
+    alias: store.alias,
+    store_uuid: store.store_uuid,
+    remote: store.remote ?? null,
+    local_only: store.remote === void 0
+  };
+}
+
 // src/schemas/forensic-report.ts
-import { z as z6 } from "zod";
-var forensicCodeSampleSchema = z6.object({
-  path: z6.string(),
-  lines: z6.string(),
-  snippet: z6.string(),
-  pattern_hint: z6.string()
-});
-var forensicEvidenceAnchorSchema = z6.object({
-  file: z6.string(),
-  line: z6.string(),
-  snippet: z6.string()
-});
-var forensicAssertionCoverageSchema = z6.object({
-  ratio: z6.number().min(0).max(1),
-  total: z6.number().int().nonnegative(),
-  matched: z6.number().int().nonnegative(),
-  co_occurring_patterns: z6.array(z6.string())
-});
-var forensicAssertionSchema = z6.object({
-  type: z6.enum(["framework", "pattern", "invariant", "domain"]),
-  statement: z6.string(),
-  confidence: z6.enum(["HIGH", "MEDIUM", "LOW"]),
-  evidence: z6.array(forensicEvidenceAnchorSchema),
+import { z as z15 } from "zod";
+var forensicCodeSampleSchema = z15.object({
+  path: z15.string(),
+  lines: z15.string(),
+  snippet: z15.string(),
+  pattern_hint: z15.string()
+});
+var forensicEvidenceAnchorSchema = z15.object({
+  file: z15.string(),
+  line: z15.string(),
+  snippet: z15.string()
+});
+var forensicAssertionCoverageSchema = z15.object({
+  ratio: z15.number().min(0).max(1),
+  total: z15.number().int().nonnegative(),
+  matched: z15.number().int().nonnegative(),
+  co_occurring_patterns: z15.array(z15.string())
+});
+var forensicAssertionSchema = z15.object({
+  type: z15.enum(["framework", "pattern", "invariant", "domain"]),
+  statement: z15.string(),
+  confidence: z15.enum(["HIGH", "MEDIUM", "LOW"]),
+  evidence: z15.array(forensicEvidenceAnchorSchema),
   coverage: forensicAssertionCoverageSchema,
-  proposed_rule: z6.string().optional(),
-  alternatives: z6.array(z6.string()).optional()
-});
-var forensicTopologySchema = z6.object({
-  total_files: z6.number().int().nonnegative(),
-  by_ext: z6.record(z6.number().int().nonnegative()),
-  key_dirs: z6.array(z6.string()),
-  max_depth: z6.number().int().nonnegative()
-});
-var forensicEntryPointSchema = z6.object({
-  path: z6.string(),
-  reason: z6.string(),
-  size_bytes: z6.number().int().nonnegative().optional()
-});
-var forensicFrameworkSchema = z6.object({
-  kind: z6.string(),
-  version: z6.string(),
-  subkind: z6.string(),
-  evidence: z6.array(z6.string())
-});
-var forensicReadmeSchema = z6.object({
-  quality: z6.enum(["missing", "stub", "ok"]),
-  line_count: z6.number().int().nonnegative(),
-  has_contributing: z6.boolean()
-});
-var candidateFileEntrySchema = z6.object({
-  path: z6.string(),
-  family: z6.enum(["entry", "component", "config", "test", "domain"]),
-  rationale: z6.string()
-});
-var forensicSamplingBudgetSchema = z6.object({
-  max_files: z6.literal(15),
-  max_lines_per_file: z6.literal(100)
-});
-var forensicReportSchema = z6.object({
-  version: z6.string(),
-  generated_at: z6.string(),
-  generated_by: z6.string(),
-  target: z6.string(),
-  project_name: z6.string(),
+  proposed_rule: z15.string().optional(),
+  alternatives: z15.array(z15.string()).optional()
+});
+var forensicTopologySchema = z15.object({
+  total_files: z15.number().int().nonnegative(),
+  by_ext: z15.record(z15.number().int().nonnegative()),
+  key_dirs: z15.array(z15.string()),
+  max_depth: z15.number().int().nonnegative()
+});
+var forensicEntryPointSchema = z15.object({
+  path: z15.string(),
+  reason: z15.string(),
+  size_bytes: z15.number().int().nonnegative().optional()
+});
+var forensicFrameworkSchema = z15.object({
+  kind: z15.string(),
+  version: z15.string(),
+  subkind: z15.string(),
+  evidence: z15.array(z15.string())
+});
+var forensicReadmeSchema = z15.object({
+  quality: z15.enum(["missing", "stub", "ok"]),
+  line_count: z15.number().int().nonnegative(),
+  has_contributing: z15.boolean()
+});
+var candidateFileEntrySchema = z15.object({
+  path: z15.string(),
+  family: z15.enum(["entry", "component", "config", "test", "domain"]),
+  rationale: z15.string()
+});
+var forensicSamplingBudgetSchema = z15.object({
+  max_files: z15.literal(15),
+  max_lines_per_file: z15.literal(100)
+});
+var forensicReportSchema = z15.object({
+  version: z15.string(),
+  generated_at: z15.string(),
+  generated_by: z15.string(),
+  target: z15.string(),
+  project_name: z15.string(),
   framework: forensicFrameworkSchema,
   topology: forensicTopologySchema,
-  entry_points: z6.array(forensicEntryPointSchema),
-  code_samples: z6.array(forensicCodeSampleSchema),
-  assertions: z6.array(forensicAssertionSchema),
-  candidate_files: z6.array(candidateFileEntrySchema),
+  entry_points: z15.array(forensicEntryPointSchema),
+  code_samples: z15.array(forensicCodeSampleSchema),
+  assertions: z15.array(forensicAssertionSchema),
+  candidate_files: z15.array(candidateFileEntrySchema),
   sampling_budget: forensicSamplingBudgetSchema,
   readme: forensicReadmeSchema,
-  recommendations_for_skill: z6.array(z6.string()).optional()
+  recommendations_for_skill: z15.array(z15.string()).optional()
 });
 
 // src/schemas/init-context.ts
-import { z as z7 } from "zod";
-var initContextFrameworkSchema = z7.object({
-  kind: z7.string(),
-  version: z7.string(),
-  subkind: z7.string()
-});
-var initContextInvariantConfidenceSnapshotSchema = z7.object({
-  confidence: z7.enum(["HIGH", "MEDIUM", "LOW"]),
-  evidence_refs: z7.array(z7.string())
-});
-var initContextSourceEvidenceSchema = z7.object({
-  file: z7.string(),
-  lines: z7.string()
-});
-var initContextInvariantSchema = z7.object({
-  type: z7.enum(["ban", "require", "protect"]),
-  rule: z7.string(),
-  rationale: z7.string().optional(),
+import { z as z16 } from "zod";
+var initContextFrameworkSchema = z16.object({
+  kind: z16.string(),
+  version: z16.string(),
+  subkind: z16.string()
+});
+var initContextInvariantConfidenceSnapshotSchema = z16.object({
+  confidence: z16.enum(["HIGH", "MEDIUM", "LOW"]),
+  evidence_refs: z16.array(z16.string())
+});
+var initContextSourceEvidenceSchema = z16.object({
+  file: z16.string(),
+  lines: z16.string()
+});
+var initContextInvariantSchema = z16.object({
+  type: z16.enum(["ban", "require", "protect"]),
+  rule: z16.string(),
+  rationale: z16.string().optional(),
   confidence_snapshot: initContextInvariantConfidenceSnapshotSchema.optional(),
-  source_evidence: z7.array(initContextSourceEvidenceSchema).optional()
-});
-var initContextDomainGroupSchema = z7.object({
-  name: z7.string(),
-  paths: z7.array(z7.string()),
-  summary: z7.string().optional(),
-  topology_type: z7.enum(["mirror", "cross-cutting"]).optional(),
-  target_path: z7.string().optional()
-});
-var initContextInterviewTrailEntrySchema = z7.object({
-  phase: z7.string(),
-  question: z7.string(),
-  answer: z7.string(),
-  presentation: z7.string().optional(),
-  user_corrections: z7.array(z7.string()).optional()
-});
-var initContextSchema = z7.object({
+  source_evidence: z16.array(initContextSourceEvidenceSchema).optional()
+});
+var initContextDomainGroupSchema = z16.object({
+  name: z16.string(),
+  paths: z16.array(z16.string()),
+  summary: z16.string().optional(),
+  topology_type: z16.enum(["mirror", "cross-cutting"]).optional(),
+  target_path: z16.string().optional()
+});
+var initContextInterviewTrailEntrySchema = z16.object({
+  phase: z16.string(),
+  question: z16.string(),
+  answer: z16.string(),
+  presentation: z16.string().optional(),
+  user_corrections: z16.array(z16.string()).optional()
+});
+var initContextSchema = z16.object({
   framework: initContextFrameworkSchema,
-  architecture_patterns: z7.array(z7.string()),
-  invariants: z7.array(initContextInvariantSchema),
-  domain_groups: z7.array(initContextDomainGroupSchema),
-  interview_trail: z7.array(initContextInterviewTrailEntrySchema),
-  forensic_ref: z7.string()
+  architecture_patterns: z16.array(z16.string()),
+  invariants: z16.array(initContextInvariantSchema),
+  domain_groups: z16.array(initContextDomainGroupSchema),
+  interview_trail: z16.array(initContextInterviewTrailEntrySchema),
+  forensic_ref: z16.string()
 });
 
 // src/schemas/events.ts
-import { z as z8 } from "zod";
-var metaUpdatedEventSchema = z8.object({
-  type: z8.literal("meta:updated"),
+import { z as z17 } from "zod";
+var metaUpdatedEventSchema = z17.object({
+  type: z17.literal("meta:updated"),
   payload: agentsMetaSchema
 });
-var lockDriftEventSchema = z8.object({
-  type: z8.literal("lock:drift"),
-  payload: z8.object({
-    locked: z8.array(humanLockEntrySchema),
-    drifted: z8.array(humanLockEntrySchema)
+var lockDriftEventSchema = z17.object({
+  type: z17.literal("lock:drift"),
+  payload: z17.object({
+    locked: z17.array(humanLockEntrySchema),
+    drifted: z17.array(humanLockEntrySchema)
   })
 });
-var lockApprovedEventSchema = z8.object({
-  type: z8.literal("lock:approved"),
-  payload: z8.object({
-    locked: z8.array(humanLockEntrySchema),
-    approved: z8.array(humanLockEntrySchema)
+var lockApprovedEventSchema = z17.object({
+  type: z17.literal("lock:approved"),
+  payload: z17.object({
+    locked: z17.array(humanLockEntrySchema),
+    approved: z17.array(humanLockEntrySchema)
   })
 });
-var ledgerAppendedEventSchema = z8.object({
-  type: z8.literal("ledger:appended"),
+var ledgerAppendedEventSchema = z17.object({
+  type: z17.literal("ledger:appended"),
   payload: ledgerEntrySchema
 });
-var driftDetectedEventSchema = z8.object({
-  type: z8.literal("drift:detected"),
+var driftDetectedEventSchema = z17.object({
+  type: z17.literal("drift:detected"),
   payload: forensicReportSchema
 });
-var fabricEventSchema = z8.discriminatedUnion("type", [
+var fabricEventSchema = z17.discriminatedUnion("type", [
   metaUpdatedEventSchema,
   lockDriftEventSchema,
   lockApprovedEventSchema,
@@ -532,271 +1838,541 @@ var fabricEventSchema = z8.discriminatedUnion("type", [
 ]);
 
 // src/schemas/event-ledger.ts
-import { z as z9 } from "zod";
+import { z as z18 } from "zod";
+
+// src/cite-line-parser.ts
+var ID_RE = /^K[TP]-[A-Z]+-\d+$/;
+var SENTINEL_RE = /^KB:\s*none\b\s*(?:\[[^\]]*\])?\s*$/i;
+var QUALIFIED_ID = String.raw`(?:[^\s,:]+:)?K[TP]-[A-Z]+-\d+`;
+var FULL_RE = new RegExp(
+  String.raw`^KB:\s+(${QUALIFIED_ID}(?:\s*,\s*${QUALIFIED_ID})*)(?:\s+\(([^)]*)\))?(?:\s+\[([^\]]+)\])?(?:\s+→\s*(.+))?\s*$`
+);
+function splitStorePrefix(token) {
+  const colon = token.lastIndexOf(":");
+  return colon === -1 ? { store: null, id: token } : { store: token.slice(0, colon), id: token.slice(colon + 1) };
+}
+var CHAINED_FROM_ID_RE = /chained-from\s+(K[TP]-[A-Z]+-\d+)/i;
+var LEGACY_CITE_TAG_REMAP = {
+  planned: "applied",
+  recalled: "applied",
+  "chained-from": "applied"
+};
+function normalizeCiteTag(rawTag) {
+  const head = rawTag.trim().split(/[\s:]+/)[0].toLowerCase();
+  if (head === "applied" || head === "dismissed" || head === "none") {
+    return head;
+  }
+  return LEGACY_CITE_TAG_REMAP[head] ?? "none";
+}
+function parseTag(rawTag) {
+  if (!rawTag) return "none";
+  return normalizeCiteTag(rawTag);
+}
+function parseContractTail(tail) {
+  const result = { operators: [], skip_reason: null };
+  if (!tail) return result;
+  const tokens = tail.trim().split(/\s+/).filter((t) => t.length > 0);
+  for (const token of tokens) {
+    const skipMatch = token.match(/^skip:(.+)$/i);
+    if (skipMatch) {
+      if (result.skip_reason === null) result.skip_reason = skipMatch[1];
+      continue;
+    }
+    const notEditMatch = token.match(/^!edit:(.+)$/i);
+    if (notEditMatch) {
+      result.operators.push({ kind: "not_edit", target: notEditMatch[1] });
+      continue;
+    }
+    const opMatch = token.match(/^(edit|require|forbid):(.+)$/i);
+    if (opMatch) {
+      result.operators.push({
+        kind: opMatch[1].toLowerCase(),
+        target: opMatch[2]
+      });
+    }
+  }
+  return result;
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return null;
+  if (SENTINEL_RE.test(trimmed)) {
+    return { ids: [], stores: [], tag: "none", commitment: null };
+  }
+  const fullMatch = trimmed.match(FULL_RE);
+  if (fullMatch) {
+    const split = fullMatch[1].split(",").map((part) => part.trim()).filter((part) => part.length > 0).map(splitStorePrefix);
+    if (split.some((entry) => !ID_RE.test(entry.id))) return null;
+    const primaryIds = split.map((entry) => entry.id);
+    const primaryStores = split.map((entry) => entry.store);
+    const rawTag = fullMatch[3];
+    const tag = parseTag(rawTag);
+    const chainedIds = [];
+    if (rawTag !== void 0) {
+      const chained = CHAINED_FROM_ID_RE.exec(rawTag);
+      if (chained !== null && ID_RE.test(chained[1])) {
+        chainedIds.push(chained[1]);
+      }
+    }
+    return {
+      ids: [...primaryIds, ...chainedIds],
+      // chained-from ids are never store-qualified → null per chained id.
+      stores: [...primaryStores, ...chainedIds.map(() => null)],
+      tag,
+      commitment: parseContractTail(fullMatch[4])
+    };
+  }
+  return null;
+}
+function parseCiteLine(raw) {
+  const result = {
+    cite_ids: [],
+    cite_tags: [],
+    cite_commitments: [],
+    cite_stores: []
+  };
+  if (typeof raw !== "string") return result;
+  for (const line of raw.split(/\r?\n/)) {
+    const parsed = parseLine(line);
+    if (!parsed) continue;
+    result.cite_tags.push(parsed.tag);
+    for (let i = 0; i < parsed.ids.length; i += 1) {
+      result.cite_ids.push(parsed.ids[i]);
+      result.cite_stores.push(parsed.stores[i] ?? null);
+    }
+    if (parsed.commitment !== null) {
+      for (let i = 0; i < parsed.ids.length; i += 1) {
+        result.cite_commitments.push(parsed.commitment);
+      }
+    }
+  }
+  return result;
+}
+
+// src/schemas/event-ledger.ts
+var citeTagSchema = z18.preprocess(
+  (value) => typeof value === "string" ? normalizeCiteTag(value) : value,
+  z18.enum(["applied", "dismissed", "none"])
+);
 var eventLedgerEnvelopeSchema = {
-  kind: z9.literal("fabric-event"),
-  id: z9.string(),
-  ts: z9.number().int().nonnegative(),
-  schema_version: z9.literal(1),
-  correlation_id: z9.string().optional(),
-  session_id: z9.string().optional()
+  kind: z18.literal("fabric-event"),
+  id: z18.string(),
+  ts: z18.number().int().nonnegative(),
+  schema_version: z18.literal(1),
+  correlation_id: z18.string().optional(),
+  session_id: z18.string().optional()
 };
-var stringRecordSchema = z9.record(z9.string());
-var knowledgeContextPlannedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_context_planned"),
-  target_paths: z9.array(z9.string()),
-  required_stable_ids: z9.array(z9.string()),
-  ai_selectable_stable_ids: z9.array(z9.string()),
-  final_stable_ids: z9.array(z9.string()),
-  selection_token: z9.string().optional(),
-  client_hash: z9.string().optional(),
-  intent: z9.string().optional(),
-  known_tech: z9.array(z9.string()).optional(),
-  diagnostics: z9.array(z9.unknown()).optional()
-});
-var knowledgeSelectionEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_selection"),
-  selection_token: z9.string(),
-  target_paths: z9.array(z9.string()),
-  required_stable_ids: z9.array(z9.string()),
-  ai_selectable_stable_ids: z9.array(z9.string()),
-  ai_selected_stable_ids: z9.array(z9.string()),
-  final_stable_ids: z9.array(z9.string()),
+var stringRecordSchema = z18.record(z18.string());
+var knowledgeContextPlannedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("knowledge_context_planned"),
+  target_paths: z18.array(z18.string()),
+  required_stable_ids: z18.array(z18.string()),
+  ai_selectable_stable_ids: z18.array(z18.string()),
+  final_stable_ids: z18.array(z18.string()),
+  selection_token: z18.string().optional(),
+  client_hash: z18.string().optional(),
+  intent: z18.string().optional(),
+  known_tech: z18.array(z18.string()).optional(),
+  diagnostics: z18.array(z18.unknown()).optional()
+});
+var knowledgeSelectionEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("knowledge_selection"),
+  selection_token: z18.string(),
+  target_paths: z18.array(z18.string()),
+  required_stable_ids: z18.array(z18.string()),
+  ai_selectable_stable_ids: z18.array(z18.string()),
+  ai_selected_stable_ids: z18.array(z18.string()),
+  final_stable_ids: z18.array(z18.string()),
   ai_selection_reasons: stringRecordSchema,
-  rejected_stable_ids: z9.array(z9.string()),
-  ignored_stable_ids: z9.array(z9.string())
-});
-var knowledgeSectionsFetchedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_sections_fetched"),
-  selection_token: z9.string(),
-  target_paths: z9.array(z9.string()).optional(),
-  requested_sections: z9.array(z9.string()),
-  final_stable_ids: z9.array(z9.string()),
-  ai_selected_stable_ids: z9.array(z9.string()),
-  diagnostics: z9.array(z9.unknown()).optional()
-});
-var editIntentCheckedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("edit_intent_checked"),
-  path: z9.string(),
-  compliant: z9.boolean(),
-  intent: z9.string(),
-  ledger_entry_id: z9.string(),
-  ledger_source: z9.enum(["ai", "human"]).optional(),
-  commit_sha: z9.string().optional(),
-  parent_sha: z9.string().optional(),
-  parent_ledger_entry_id: z9.string().optional(),
-  diff_stat: z9.string().optional(),
-  annotation: z9.string().optional(),
-  matched_rule_context_ts: z9.number().int().nonnegative().nullable(),
-  window_ms: z9.number().int().nonnegative()
-});
-var knowledgeDriftDetectedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_drift_detected"),
-  revision: z9.string().optional(),
-  drifted_stable_ids: z9.array(z9.string()),
-  missing_files: z9.array(z9.string()),
-  stale_files: z9.array(z9.string()),
-  details: z9.array(
-    z9.object({
-      file: z9.string(),
-      stable_id: z9.string(),
-      expected_hash: z9.string(),
-      actual_hash: z9.string().nullable()
+  rejected_stable_ids: z18.array(z18.string()),
+  ignored_stable_ids: z18.array(z18.string())
+});
+var knowledgeSectionsFetchedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("knowledge_sections_fetched"),
+  selection_token: z18.string(),
+  target_paths: z18.array(z18.string()).optional(),
+  requested_sections: z18.array(z18.string()),
+  final_stable_ids: z18.array(z18.string()),
+  ai_selected_stable_ids: z18.array(z18.string()),
+  diagnostics: z18.array(z18.unknown()).optional()
+});
+var editIntentCheckedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("edit_intent_checked"),
+  path: z18.string(),
+  compliant: z18.boolean(),
+  intent: z18.string(),
+  ledger_entry_id: z18.string(),
+  // rc.35 TASK-07 (P0-2): add "hook" — emitted by the PreToolUse narrow hook
+  // for every Edit/Write/MultiEdit fire so cite-coverage doctor metrics see
+  // actual edit signals (previously editsTouched was permanently 0 because
+  // no production caller of appendLedgerEntry existed).
+  ledger_source: z18.enum(["ai", "human", "hook"]).optional(),
+  commit_sha: z18.string().optional(),
+  parent_sha: z18.string().optional(),
+  parent_ledger_entry_id: z18.string().optional(),
+  diff_stat: z18.string().optional(),
+  annotation: z18.string().optional(),
+  matched_rule_context_ts: z18.number().int().nonnegative().nullable(),
+  window_ms: z18.number().int().nonnegative()
+});
+var knowledgeDriftDetectedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("knowledge_drift_detected"),
+  revision: z18.string().optional(),
+  drifted_stable_ids: z18.array(z18.string()),
+  missing_files: z18.array(z18.string()),
+  stale_files: z18.array(z18.string()),
+  details: z18.array(
+    z18.object({
+      file: z18.string(),
+      stable_id: z18.string(),
+      expected_hash: z18.string(),
+      actual_hash: z18.string().nullable()
     })
   ).optional()
 });
-var mcpEventLedgerEventSchema = z9.object({
+var mcpEventLedgerEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("mcp_event"),
+  mcp_event_id: z18.string(),
+  stream_id: z18.string(),
+  message: z18.unknown()
+});
+var reapplyCompletedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("reapply_completed"),
+  preserved_ledger: z18.boolean(),
+  preserved_meta: z18.boolean(),
+  rules_count: z18.number().int().nonnegative()
+});
+var installDiffAppliedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("mcp_event"),
-  mcp_event_id: z9.string(),
-  stream_id: z9.string(),
-  message: z9.unknown()
+  event_type: z18.literal("install_diff_applied"),
+  applied: z18.array(z18.string()),
+  canonical: z18.array(z18.string()),
+  drifted: z18.array(z18.string())
 });
-var reapplyCompletedEventSchema = z9.object({
+var eventLedgerTruncatedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("reapply_completed"),
-  preserved_ledger: z9.boolean(),
-  preserved_meta: z9.boolean(),
-  rules_count: z9.number().int().nonnegative()
+  event_type: z18.literal("event_ledger_truncated"),
+  byte_offset: z18.number().int().nonnegative(),
+  byte_length: z18.number().int().nonnegative(),
+  corrupted_path: z18.string()
 });
-var eventLedgerTruncatedEventSchema = z9.object({
+var mcpConfigMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("event_ledger_truncated"),
-  byte_offset: z9.number().int().nonnegative(),
-  byte_length: z9.number().int().nonnegative(),
-  corrupted_path: z9.string()
+  event_type: z18.literal("mcp_config_migrated"),
+  source: z18.literal("doctor_fix"),
+  removed_from: z18.string()
 });
-var mcpConfigMigratedEventSchema = z9.object({
+var bootstrapMarkerMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("mcp_config_migrated"),
-  source: z9.literal("doctor_fix"),
-  removed_from: z9.string()
+  event_type: z18.literal("bootstrap_marker_migrated"),
+  path: z18.string(),
+  migrated_count: z18.number().int().nonnegative(),
+  legacy_marker: z18.literal("fabric:knowledge-base"),
+  new_marker: z18.literal("fabric:bootstrap"),
+  timestamp: z18.string()
 });
-var metaReconciledOnStartupEventSchema = z9.object({
+var metaReconciledOnStartupEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("meta_reconciled_on_startup"),
-  reconciled_files: z9.array(z9.string()),
-  duration_ms: z9.number().int().nonnegative(),
-  source: z9.literal("reconcileKnowledge")
+  event_type: z18.literal("meta_reconciled_on_startup"),
+  reconciled_files: z18.array(z18.string()),
+  duration_ms: z18.number().int().nonnegative(),
+  source: z18.literal("reconcileKnowledge")
 });
-var metaReconciledEventSchema = z9.object({
+var metaReconciledEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("meta_reconciled"),
-  reconciled_files: z9.array(z9.string()),
-  duration_ms: z9.number().int().nonnegative(),
-  trigger: z9.enum(["doctor", "manual"]),
-  source: z9.literal("reconcileKnowledge")
+  event_type: z18.literal("meta_reconciled"),
+  reconciled_files: z18.array(z18.string()),
+  duration_ms: z18.number().int().nonnegative(),
+  // v2.0.0-rc.23 TASK-005 (a-B): added `auto-heal-description` trigger so the
+  // read-path plan_context handler can drive a full reconcile when it detects
+  // any node carrying `description === undefined` (legacy meta drift that the
+  // revision-hash gate cannot catch — a missing description doesn't move the
+  // revision). Symmetric to rc.22 D2 read-side auto-heal but covers the
+  // description-undefined case which the revision drift gate misses.
+  // v2.0.0-rc.27 TASK-001 (§2.9): `post-approve` / `post-modify` added so
+  // `fab_review` write-actions can flush newly-promoted entries into
+  // `agents.meta.json.nodes[id]` synchronously — without this the new entry
+  // remains description-less until the next plan_context auto-heal.
+  // v2.0.0-rc.29 TASK-005 (BUG-G1): `auto-heal-after-drift` added so
+  // `ensureKnowledgeFresh` hot-path can chain a paired reconcile (closing the
+  // drift→heal gap) when the caller opts in via `autoHealOnDrift: true`.
+  trigger: z18.enum([
+    "doctor",
+    "manual",
+    "auto-heal-description",
+    "auto-heal-after-drift",
+    "post-approve",
+    "post-modify"
+  ]),
+  source: z18.literal("reconcileKnowledge"),
+  // v2.0.0-rc.22 TASK-014 (Scope E): set when reconcileKnowledge forced a
+  // writeKnowledgeMeta on revision drift alone (no per-file content drift).
+  // Distinguishes top-level schema/revision repair from the standard per-file
+  // drift path. Optional so existing emitters stay unchanged.
+  force_write_reason: z18.enum(["revision_drift"]).optional()
 });
-var claudeSkillPathMigratedEventSchema = z9.object({
+var claudeSkillPathMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("claude_skill_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z18.literal("claude_skill_path_migrated"),
+  from: z18.string(),
+  to: z18.string()
 });
-var claudeHookPathMigratedEventSchema = z9.object({
+var claudeHookPathMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("claude_hook_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z18.literal("claude_hook_path_migrated"),
+  from: z18.string(),
+  to: z18.string()
 });
-var codexSkillPathMigratedEventSchema = z9.object({
+var codexSkillPathMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("codex_skill_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z18.literal("codex_skill_path_migrated"),
+  from: z18.string(),
+  to: z18.string()
 });
-var initScanCompletedEventSchema = z9.object({
+var initScanCompletedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("init_scan_completed"),
-  written_stable_ids: z9.array(z9.string()),
-  duration_ms: z9.number().int().nonnegative(),
-  source: z9.enum(["init", "scan", "doctor_fix"]).optional()
+  event_type: z18.literal("init_scan_completed"),
+  written_stable_ids: z18.array(z18.string()),
+  duration_ms: z18.number().int().nonnegative(),
+  source: z18.enum(["init", "scan", "doctor_fix", "doctor-rescan"]).optional()
 });
-var knowledgeProposedEventSchema = z9.object({
+var knowledgeProposedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_proposed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z18.literal("knowledge_proposed"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgePromoteStartedEventSchema = z9.object({
+var knowledgePromoteStartedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_promote_started"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z18.literal("knowledge_promote_started"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgePromotedEventSchema = z9.object({
+var knowledgePromotedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_promoted"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z18.literal("knowledge_promoted"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgePromoteFailedEventSchema = z9.object({
+var knowledgePromoteFailedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_promote_failed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string()
+  event_type: z18.literal("knowledge_promote_failed"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string()
 });
-var knowledgeLayerChangedEventSchema = z9.object({
+var knowledgeLayerChangedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_layer_changed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional(),
-  from_layer: z9.enum(["team", "personal"]),
-  to_layer: z9.enum(["team", "personal"])
+  event_type: z18.literal("knowledge_layer_changed"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional(),
+  from_layer: z18.enum(["team", "personal"]),
+  to_layer: z18.enum(["team", "personal"]),
+  // v2.0.0-rc.37 NEW-24: record the pre-flip stable_id so downstream consumers
+  // (fab_plan_context redirect surface, fab_get_knowledge_sections.redirect_to)
+  // can map a stale caller-held id back to the post-flip canonical id without
+  // requiring the caller to re-issue plan-context. Optional for forward-
+  // compatibility with rc ≤36 events that never carried this field.
+  previous_stable_id: z18.string().optional()
 });
-var knowledgeSlugRenamedEventSchema = z9.object({
+var knowledgeIdRedirectEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_slug_renamed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional(),
-  from_slug: z9.string(),
-  to_slug: z9.string()
+  event_type: z18.literal("knowledge_id_redirect"),
+  timestamp: z18.string().datetime(),
+  previous_stable_id: z18.string(),
+  new_stable_id: z18.string(),
+  reason: z18.string().optional()
 });
-var knowledgeDemotedEventSchema = z9.object({
+var knowledgeSlugRenamedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_demoted"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z18.literal("knowledge_slug_renamed"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional(),
+  from_slug: z18.string(),
+  to_slug: z18.string()
 });
-var knowledgeArchivedEventSchema = z9.object({
+var knowledgeDemotedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_archived"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z18.literal("knowledge_demoted"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgeArchiveAttemptedEventSchema = z9.object({
+var knowledgeArchivedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_archive_attempted"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z18.literal("knowledge_archived"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgeDeferredEventSchema = z9.object({
+var knowledgeArchiveAttemptedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_deferred"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional(),
-  until: z9.string().datetime().optional()
+  event_type: z18.literal("knowledge_archive_attempted"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgeRejectedEventSchema = z9.object({
+var knowledgeUnarchivedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_rejected"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string()
+  event_type: z18.literal("knowledge_unarchived"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional(),
+  // Pre-move archive path (e.g. ".fabric/.archive/decisions/KT-D-0007--single-cjs-hook.md").
+  archive_path: z18.string().optional(),
+  // Post-move canonical path (e.g. ".fabric/knowledge/team/decisions/KT-D-0007--single-cjs-hook.md").
+  restored_to: z18.string().optional()
 });
-var knowledgeConsumedEventSchema = z9.object({
+var knowledgeDeferredEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_consumed"),
-  stable_id: z9.string(),
-  consumed_at: z9.string().datetime(),
-  client_hash: z9.string()
+  event_type: z18.literal("knowledge_deferred"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional(),
+  until: z18.string().datetime().optional()
 });
-var knowledgeScopeDegradedEventSchema = z9.object({
+var knowledgeRejectedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_scope_degraded"),
-  stable_id: z9.string(),
-  timestamp: z9.string().datetime(),
-  from_scope: z9.enum(["narrow", "broad"]),
-  to_scope: z9.enum(["narrow", "broad"]),
-  reason: z9.string()
+  event_type: z18.literal("knowledge_rejected"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string()
 });
-var doctorRunEventSchema = z9.object({
+var knowledgeConsumedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("doctor_run"),
-  mode: z9.enum(["lint", "apply-lint"]),
-  issues: z9.number().int().nonnegative(),
-  mutations: z9.number().int().nonnegative().optional(),
-  timestamp: z9.string().datetime()
+  event_type: z18.literal("knowledge_consumed"),
+  stable_id: z18.string(),
+  consumed_at: z18.string().datetime(),
+  client_hash: z18.string()
 });
-var knowledgePathDangledEventSchema = z9.object({
+var knowledgeScopeDegradedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_path_dangled"),
-  stable_id: z9.string(),
-  removed_glob: z9.string()
+  event_type: z18.literal("knowledge_scope_degraded"),
+  stable_id: z18.string(),
+  timestamp: z18.string().datetime(),
+  from_scope: z18.enum(["narrow", "broad"]),
+  to_scope: z18.enum(["narrow", "broad"]),
+  reason: z18.string()
 });
-var pendingAutoArchivedEventSchema = z9.object({
+var doctorRunEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("pending_auto_archived"),
-  pending_path: z9.string(),
-  archived_to: z9.string(),
-  reason: z9.string()
+  event_type: z18.literal("doctor_run"),
+  mode: z18.enum(["lint", "fix-knowledge"]),
+  issues: z18.number().int().nonnegative(),
+  mutations: z18.number().int().nonnegative().optional(),
+  timestamp: z18.string().datetime()
 });
-var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
+var knowledgePathDangledEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("knowledge_path_dangled"),
+  stable_id: z18.string(),
+  removed_glob: z18.string()
+});
+var relevanceMigrationRunEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("relevance_migration_run"),
+  timestamp: z18.string().datetime(),
+  scanned_count: z18.number().int().nonnegative(),
+  touched_count: z18.number().int().nonnegative()
+});
+var pendingAutoArchivedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("pending_auto_archived"),
+  pending_path: z18.string(),
+  archived_to: z18.string(),
+  reason: z18.string()
+});
+var assistantTurnObservedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("assistant_turn_observed"),
+  kb_line_raw: z18.string().nullable(),
+  cite_ids: z18.array(z18.string()).default([]),
+  cite_tags: z18.array(citeTagSchema).default([]),
+  // v2.0.0-rc.24 TASK-01: per-cite contract commitments. Index-aligned with
+  // cite_ids/cite_tags (commitments[i] belongs to cite_ids[i]). Each slot
+  // carries `operators[]` (kind + glob target) or `skip_reason` when the cite
+  // cannot be operator-ized. Old rc.20-rc.23 events naturally parse with an
+  // empty array via `.default([])` and are excluded from contract-policy
+  // audits by the marker-gate (see cite_contract_policy_activated below).
+  // Mirrors the rc.20 cite_tags parallel-array evolution exactly.
+  cite_commitments: z18.array(
+    z18.object({
+      operators: z18.array(
+        z18.object({
+          kind: z18.enum(["edit", "not_edit", "require", "forbid"]),
+          target: z18.string()
+        })
+      ),
+      skip_reason: z18.string().nullable()
+    })
+  ).default([]),
+  client: z18.enum(["cc", "codex", "cursor"]).optional(),
+  turn_id: z18.string(),
+  envelope_index: z18.number().int().nonnegative().optional(),
+  timestamp: z18.string().datetime()
+});
+var citePolicyActivatedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("cite_policy_activated"),
+  policy_version: z18.string(),
+  timestamp: z18.string().datetime()
+});
+var citeContractPolicyActivatedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("cite_contract_policy_activated")
+});
+var eventsRotatedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("events_rotated"),
+  cutoff_ts: z18.string().datetime(),
+  archived_count: z18.number().int().nonnegative(),
+  kept_count: z18.number().int().nonnegative(),
+  archive_path: z18.string()
+});
+var knowledgeMetaAutoHealedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("knowledge_meta_auto_healed"),
+  previous_revision_hash: z18.string(),
+  revision_hash: z18.string(),
+  trigger: z18.literal("read"),
+  caller: z18.enum(["planContext", "getKnowledgeSections", "getKnowledge", "extractKnowledge"]).optional()
+});
+var serveLockClearedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("serve_lock_cleared"),
+  pid: z18.number().int().nonnegative(),
+  age_ms: z18.number().int().nonnegative(),
+  timestamp: z18.string().datetime()
+});
+var knowledgeEnrichedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("knowledge_enriched"),
+  path: z18.string(),
+  added_fields: z18.array(z18.enum(["intent_clues", "tech_stack", "impact", "must_read_if"])),
+  mode: z18.enum(["auto", "preview", "readonly", "interactive"]),
+  timestamp: z18.string().datetime()
+});
+var sessionArchiveAttemptedEventSchema = z18.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z18.literal("session_archive_attempted"),
+  outcome: z18.enum(["proposed", "viability_failed", "user_dismissed", "skipped_no_signal"]),
+  covered_through_ts: z18.number().int().nonnegative(),
+  candidates_proposed: z18.number().int().nonnegative().default(0),
+  knowledge_proposed_ids: z18.array(z18.string()).default([])
+});
+var eventLedgerEventSchema = z18.discriminatedUnion("event_type", [
   knowledgeContextPlannedEventSchema,
   knowledgeSelectionEventSchema,
   knowledgeSectionsFetchedEventSchema,
@@ -804,8 +2380,12 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   knowledgeDriftDetectedEventSchema,
   mcpEventLedgerEventSchema,
   reapplyCompletedEventSchema,
+  installDiffAppliedEventSchema,
   eventLedgerTruncatedEventSchema,
   mcpConfigMigratedEventSchema,
+  // v2.0.0-rc.19 TASK-004: bootstrap_marker_migrated — one-time fabric:knowledge-base
+  // → fabric:bootstrap marker rewrite emitted per file by `fabric doctor --fix`.
+  bootstrapMarkerMigratedEventSchema,
   metaReconciledOnStartupEventSchema,
   metaReconciledEventSchema,
   claudeSkillPathMigratedEventSchema,
@@ -818,10 +2398,14 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   knowledgePromotedEventSchema,
   knowledgePromoteFailedEventSchema,
   knowledgeLayerChangedEventSchema,
+  // v2.0.0-rc.37 NEW-24: dedicated old→new stable_id mapping event
+  knowledgeIdRedirectEventSchema,
   knowledgeSlugRenamedEventSchema,
   knowledgeDemotedEventSchema,
   knowledgeArchivedEventSchema,
   knowledgeArchiveAttemptedEventSchema,
+  // v2.0.0-rc.34 TASK-05: reverse of knowledge_archived
+  knowledgeUnarchivedEventSchema,
   knowledgeDeferredEventSchema,
   knowledgeRejectedEventSchema,
   // v2.0 rc.5 TASK-014: knowledge_consumed (consumption tracking)
@@ -835,42 +2419,127 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   // #24 when a glob in relevance_paths resolves to zero filesystem matches.
   knowledgePathDangledEventSchema,
   // v2.0.0-rc.7 T10: doctor_run — emitted by `fabric doctor` to drive Signal D.
-  doctorRunEventSchema
+  doctorRunEventSchema,
+  // v2.0.0-rc.9 TASK-003 (A3): relevance_migration_run — emitted by
+  // `doctor --apply-lint` after the lint #26 frontmatter back-fill pass.
+  relevanceMigrationRunEventSchema,
+  // v2.0.0-rc.20 TASK-02: assistant_turn_observed — per-turn cite-policy
+  // observation (raw KB: line text + parsed cite_ids/cite_tags + client).
+  assistantTurnObservedEventSchema,
+  // v2.0.0-rc.20 TASK-02: cite_policy_activated — session/policy-bump
+  // marker recording when a given policy_version became active.
+  citePolicyActivatedEventSchema,
+  // v2.0.0-rc.24 TASK-01: cite_contract_policy_activated — drift-gated
+  // idempotent marker opening the contract-policy audit window. Distinct
+  // from cite_policy_activated so contract metrics get their own window.
+  citeContractPolicyActivatedEventSchema,
+  // v2.0.0-rc.22 Scope D T-D1: knowledge_meta_auto_healed — emitted by
+  // loadActiveMeta when read-path drift triggers an in-place meta rebuild.
+  knowledgeMetaAutoHealedEventSchema,
+  // v2.0.0-rc.22 Scope A T3: events_rotated — emitted as the first line of
+  // the post-rotation events.jsonl when sliding-window-by-age rotation moves
+  // stale entries to events.archive/events-rotated-YYYY-MM-DD.jsonl.
+  eventsRotatedEventSchema,
+  // v2.0.0-rc.23 TASK-010 (e): serve_lock_cleared — emitted by
+  // `fabric doctor --fix` when a stale `.fabric/.serve.lock` with a dead PID is
+  // unlinked.
+  serveLockClearedEventSchema,
+  // v2.0.0-rc.23 TASK-007 (a-C2): knowledge_enriched — emitted by
+  // `fabric doctor --enrich-descriptions` once per modified canonical knowledge
+  // file when one or more of the four rc.23 description-grade frontmatter
+  // fields is back-filled.
+  knowledgeEnrichedEventSchema,
+  // v2.0.0-rc.25 TASK-01: session_archive_attempted — emitted by the
+  // fabric-archive skill at the end of every invocation. Drives Phase 0.0
+  // cross-session digest, outcome-based rescan filter (skips user_dismissed),
+  // covered_through_ts watermark, and `fabric doctor --archive-history`.
+  sessionArchiveAttemptedEventSchema
 ]);
 export {
   AGENTS_META_IDENTITY_SOURCES,
   AGENTS_META_LAYERS,
   AGENTS_META_TOPOLOGY_TYPES,
   AgentsMetaCountersSchema,
+  BOOTSTRAP_CANONICAL,
+  BOOTSTRAP_MARKER_BEGIN,
+  BOOTSTRAP_MARKER_END,
+  BOOTSTRAP_REGEX,
   FabExtractKnowledgeInputSchema,
   FabExtractKnowledgeInputShape,
   FabExtractKnowledgeOutputSchema,
   FabReviewInputSchema,
+  FabReviewInputShape,
   FabReviewOutputSchema,
+  FabReviewOutputShape,
+  GLOBAL_BINDINGS_DIR,
+  GLOBAL_REF_PATTERN,
+  GLOBAL_STATE_DIR,
   KNOWLEDGE_TEST_INDEX_SCHEMA_VERSION,
   KNOWLEDGE_TYPE_CODES,
+  KNOWN_SCOPE_PREFIXES,
   KnowledgeEntryFrontmatterSchema,
   KnowledgeTypeSchema,
+  LEGACY_KB_MARKER_BEGIN,
+  LEGACY_KB_MARKER_END,
+  LEGACY_KB_REGEX,
   LayerSchema,
+  MCP_STORE_AWARE_CONTRACTS,
+  MCP_STORE_AWARE_TOOLS,
   MaturitySchema,
+  ONBOARD_SLOT_NAMES,
+  ONBOARD_SLOT_TOTAL,
+  PARITY_CLIENTS,
+  PARITY_SURFACES,
+  PERSONAL_SCOPE,
+  PERSONAL_STORE_SENTINEL,
+  PROJECT_ROOT_SIGNALS,
   PROPOSED_REASON_DESCRIPTIONS,
   PROTECTED_TOKENS,
   ProposedReasonSchema,
+  REDACTION_PLACEHOLDER_PREFIX,
+  ResolverNotImplementedError,
+  SCOPE_COORDINATE_PATTERN,
+  STORES_ROOT_DIR,
+  STORE_GITIGNORE,
+  STORE_KNOWLEDGE_TYPE_DIRS,
+  STORE_LAYOUT,
+  STORE_PENDING_DIR,
+  STORE_RESOLVER_WARNING_CODES,
+  STORE_UUID_PATTERN,
   StableIdSchema,
+  UID_SEGMENT_PATTERN,
+  addMountedStore,
   agentsIdentitySourceSchema,
   agentsLayerSchema,
   agentsMetaNodeSchema,
   agentsMetaSchema,
   agentsTopologyTypeSchema,
+  aggregatePendingAcrossStores,
   aiLedgerEntrySchema,
   allocateKnowledgeId,
   annotateIntentRequestSchema,
+  archiveScanAnnotations,
+  archiveScanInputSchema,
+  archiveScanOutputSchema,
+  assistantTurnObservedEventSchema,
   auditModeSchema,
+  bindRequiredStore,
+  bindingsSnapshotPath,
+  bootstrapMarkerMigratedEventSchema,
+  buildDebugBundle,
+  buildFailureTrace,
   candidateFileEntrySchema,
+  citeContractMetricsSchema,
+  citeContractPolicyActivatedEventSchema,
+  citeCoverageReportSchema,
+  citeLayerTypeBreakdownSchema,
+  citePolicyActivatedEventSchema,
   claudeHookPathMigratedEventSchema,
   claudeSkillPathMigratedEventSchema,
   clientPathsSchema,
   codexSkillPathMigratedEventSchema,
+  createProjectRootResolver,
+  createStoreResolver,
   createTranslator,
   defaultAgentsMetaCounters,
   defaultLayerFilterSchema,
@@ -879,17 +2548,24 @@ export {
   deriveAgentsMetaLayer,
   deriveAgentsMetaStableId,
   deriveAgentsMetaTopologyType,
+  detachMountedStore,
   detectNodeLocale,
   doctorRunEventSchema,
   driftDetectedEventSchema,
   editIntentCheckedEventSchema,
   enMessages,
+  entryScopeMetadataSchema,
   eventLedgerEventSchema,
   eventLedgerTruncatedEventSchema,
+  eventsRotatedEventSchema,
+  explainStore,
   fabExtractKnowledgeAnnotations,
   fabReviewAnnotations,
   fabricConfigSchema,
   fabricEventSchema,
+  fabricLanguageSchema,
+  findMountedStore,
+  findStoreExecutableViolations,
   forensicAssertionCoverageSchema,
   forensicAssertionSchema,
   forensicCodeSampleSchema,
@@ -900,10 +2576,13 @@ export {
   forensicReportSchema,
   forensicSamplingBudgetSchema,
   forensicTopologySchema,
+  formatGlobalRef,
   formatKnowledgeId,
-  getKnowledgeAnnotations,
-  getKnowledgeInputSchema,
-  getKnowledgeOutputSchema,
+  getPanelFieldByKey,
+  getPanelFields,
+  globalConfigSchema,
+  globalRefSchema,
+  hasSecrets,
   historyStateQuerySchema,
   humanLedgerEntrySchema,
   humanLockApproveRequestSchema,
@@ -918,7 +2597,11 @@ export {
   initContextSchema,
   initContextSourceEvidenceSchema,
   initScanCompletedEventSchema,
+  initStore,
+  installDiffAppliedEventSchema,
   isKnowledgeStableId,
+  isPersonalLeakIntoSharedStore,
+  isPersonalScope,
   knowledgeArchiveAttemptedEventSchema,
   knowledgeArchivedEventSchema,
   knowledgeConsumedEventSchema,
@@ -926,13 +2609,16 @@ export {
   knowledgeDeferredEventSchema,
   knowledgeDemotedEventSchema,
   knowledgeDriftDetectedEventSchema,
-  knowledgeLanguageSchema,
+  knowledgeEnrichedEventSchema,
+  knowledgeIdRedirectEventSchema,
   knowledgeLayerChangedEventSchema,
+  knowledgeMetaAutoHealedEventSchema,
   knowledgePathDangledEventSchema,
   knowledgePromoteFailedEventSchema,
   knowledgePromoteStartedEventSchema,
   knowledgePromotedEventSchema,
   knowledgeProposedEventSchema,
+  knowledgeProvenanceSchema,
   knowledgeRejectedEventSchema,
   knowledgeScopeDegradedEventSchema,
   knowledgeSectionsAnnotations,
@@ -944,10 +2630,14 @@ export {
   knowledgeTestIndexSchema,
   knowledgeTestLinkSchema,
   knowledgeTestOrphanAnnotationSchema,
+  knowledgeUnarchivedEventSchema,
   ledgerAppendedEventSchema,
   ledgerEntrySchema,
   ledgerQuerySchema,
   ledgerSourceSchema,
+  lintCrossStoreReferences,
+  listStoreKnowledge,
+  localKnowledgeIdSchema,
   lockApprovedEventSchema,
   lockDriftEventSchema,
   mcpConfigMigratedEventSchema,
@@ -956,7 +2646,17 @@ export {
   metaReconciledEventSchema,
   metaReconciledOnStartupEventSchema,
   metaUpdatedEventSchema,
+  mountedStoreSchema,
+  normalizeCiteTag,
   normalizeLocale,
+  onboardSlotSchema,
+  parityCapabilitySchema,
+  parityClientExpectationSchema,
+  parityClientSchema,
+  parityMatrixSchema,
+  paritySurfaceSchema,
+  parseCiteLine,
+  parseGlobalRef,
   parseKnowledgeId,
   pendingAutoArchivedEventSchema,
   planContextAnnotations,
@@ -964,10 +2664,52 @@ export {
   planContextHintOutputSchema,
   planContextInputSchema,
   planContextOutputSchema,
+  projectRootGoldenCaseSchema,
+  projectRootGoldenFileSchema,
+  projectRootResolutionSchema,
+  projectRootSignalSchema,
+  projectRootSignalsSchema,
+  readBindingsSnapshot,
+  readKnowledgeAcrossStores,
+  readSetEntrySchema,
+  readSetGoldenCaseSchema,
+  readSetGoldenFileSchema,
+  readStoreIdentity,
   reapplyCompletedEventSchema,
+  recallAnnotations,
+  recallInputSchema,
+  recallOutputSchema,
+  recognizeStoreDir,
+  redactSecrets,
+  relevanceMigrationRunEventSchema,
+  requiredStoreEntrySchema,
+  resolveCandidates,
+  resolveFabricLocale,
+  resolveStoreQualifiedId,
+  resolvedBindingsSnapshotSchema,
   ruleDescriptionIndexItemSchema,
   ruleDescriptionSchema,
+  scanForSecrets,
+  scopeCoordinateSchema,
+  scopeRoot,
+  selectionTokenTtlMsSchema,
+  serveLockClearedEventSchema,
+  sessionArchiveAttemptedEventSchema,
+  storeAwareEntrySchema,
+  storeCountersSchema,
+  storeIdentitySchema,
+  storeKnowledgeTypeDir,
+  storeReadSetSchema,
+  storeRelativePath,
+  storeResolveInputSchema,
+  storeResolverWarningCodeSchema,
+  storeResolverWarningSchema,
+  storeUuidSchema,
   structuredWarningSchema,
+  uidSchema,
   withDerivedAgentsMetaNodeDefaults,
+  writeBindingsSnapshot,
+  writeTargetSchema,
+  writtenToStoreSchema,
   zhCNMessages
 };