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

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   LEGACY_KB_MARKER_BEGIN,
   LEGACY_KB_MARKER_END,
   LEGACY_KB_REGEX
-} from "./chunk-LTDB2UDN.js";
+} from "./chunk-MDWTGOAY.js";
 import {
   PROTECTED_TOKENS,
   createTranslator,
@@ -16,7 +16,7 @@ import {
   normalizeLocale,
   resolveFabricLocale,
   zhCNMessages
-} from "./chunk-7CX32MYL.js";
+} from "./chunk-R2J7DAED.js";
 import {
   FabExtractKnowledgeInputSchema,
   FabExtractKnowledgeInputShape,
@@ -327,28 +327,125 @@ 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 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 = z5.object({
-  warnBytes: z5.number().int().positive().optional(),
-  hardBytes: z5.number().int().positive().optional()
+var mcpPayloadLimitsSchema = z6.object({
+  warnBytes: z6.number().int().positive().optional(),
+  hardBytes: z6.number().int().positive().optional()
 }).optional();
-var selectionTokenTtlMsSchema = z5.number().int().min(3e4).max(36e5);
-var fabricLanguageSchema = z5.enum([
+var selectionTokenTtlMsSchema = z6.number().int().min(3e4).max(36e5);
+var fabricLanguageSchema = z6.enum([
   "match-existing",
   "zh-CN",
   "en",
   "zh-CN-hybrid"
 ]);
-var defaultLayerFilterSchema = z5.enum(["team", "personal", "both"]);
-var fabricConfigSchema = z5.object({
+var defaultLayerFilterSchema = z6.enum(["team", "personal", "both"]);
+var fabricConfigSchema = z6.object({
   clientPaths: clientPathsSchema.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
@@ -356,7 +453,7 @@ var fabricConfigSchema = z5.object({
   // 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: z5.array(z5.string()).optional(),
+  scanIgnores: z6.array(z6.string()).optional(),
   audit_mode: auditModeSchema.optional(),
   mcpPayloadLimits: mcpPayloadLimitsSchema,
   // Backward-compat: both fields are optional with defaults so existing
@@ -371,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
@@ -380,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
@@ -391,102 +488,102 @@ 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: z5.number().int().min(1).optional().default(60),
+  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: z5.number().int().min(1).optional().default(2),
+  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: z5.number().int().min(1).max(50).optional().default(10),
+  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: z5.number().int().min(50).max(2e3).optional().default(500),
+  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: z5.number().int().positive().optional().default(50),
+  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: z5.number().int().positive().optional().default(8),
+  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: z5.number().int().positive().optional().default(20),
+  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: z5.number().int().positive().optional().default(10),
+  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: z5.number().int().positive().optional().default(8),
+  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: z5.number().int().positive().optional().default(14),
+  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: z5.boolean().optional().default(false),
+  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: z5.boolean().optional().default(false),
+  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
@@ -494,7 +591,7 @@ var fabricConfigSchema = z5.object({
   // 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: z5.number().int().min(0).optional().default(0),
+  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`
@@ -507,7 +604,7 @@ var fabricConfigSchema = z5.object({
   // 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: z5.union([z5.literal(7), z5.literal(30), z5.literal(90)]).optional(),
+  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
@@ -524,7 +621,7 @@ var fabricConfigSchema = z5.object({
   //
   // Default `[]` keeps the field optional on existing configs — fresh
   // installs land with no opt-outs.
-  onboard_slots_opted_out: z5.array(z5.string()).optional().default([]),
+  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
@@ -536,20 +633,20 @@ var fabricConfigSchema = z5.object({
   // 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: z5.number().int().min(1).max(50).optional().default(8),
+  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: z5.array(z5.enum(["archive", "review", "import", "maintenance"])).optional(),
+  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: z5.number().int().min(1).max(20).optional().default(5),
+  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.
@@ -559,7 +656,7 @@ var fabricConfigSchema = z5.object({
   // 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: z5.number().int().min(1).max(50).optional().default(5),
+  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
@@ -568,29 +665,29 @@ var fabricConfigSchema = z5.object({
   // 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: z5.number().int().min(0).max(168).optional().default(0),
+  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: z5.number().int().min(0).max(168).optional().default(0),
+  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: z5.number().int().min(1).max(3650).optional(),
-  orphan_demote_endorsed_days: z5.number().int().min(1).max(3650).optional(),
-  orphan_demote_draft_days: z5.number().int().min(1).max(3650).optional(),
+  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: z5.number().int().min(40).max(240).optional().default(80),
+  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
@@ -600,7 +697,7 @@ var fabricConfigSchema = z5.object({
   // 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: z5.boolean().optional().default(true),
+  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
@@ -620,8 +717,8 @@ var fabricConfigSchema = z5.object({
 });
 
 // src/schemas/fabric-config-introspect.ts
-import { z as z6 } from "zod";
-var positiveIntSchema = z6.coerce.number().int().positive();
+import { z as z7 } from "zod";
+var positiveIntSchema = z7.coerce.number().int().positive();
 function makePositiveIntField(key, defaultValue) {
   return {
     key,
@@ -757,156 +854,982 @@ var PANEL_FIELDS = [
   )
 ];
 
+// 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 z7 } from "zod";
-var forensicCodeSampleSchema = z7.object({
-  path: z7.string(),
-  lines: z7.string(),
-  snippet: z7.string(),
-  pattern_hint: z7.string()
-});
-var forensicEvidenceAnchorSchema = z7.object({
-  file: z7.string(),
-  line: z7.string(),
-  snippet: z7.string()
-});
-var forensicAssertionCoverageSchema = z7.object({
-  ratio: z7.number().min(0).max(1),
-  total: z7.number().int().nonnegative(),
-  matched: z7.number().int().nonnegative(),
-  co_occurring_patterns: z7.array(z7.string())
-});
-var forensicAssertionSchema = z7.object({
-  type: z7.enum(["framework", "pattern", "invariant", "domain"]),
-  statement: z7.string(),
-  confidence: z7.enum(["HIGH", "MEDIUM", "LOW"]),
-  evidence: z7.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: z7.string().optional(),
-  alternatives: z7.array(z7.string()).optional()
-});
-var forensicTopologySchema = z7.object({
-  total_files: z7.number().int().nonnegative(),
-  by_ext: z7.record(z7.number().int().nonnegative()),
-  key_dirs: z7.array(z7.string()),
-  max_depth: z7.number().int().nonnegative()
-});
-var forensicEntryPointSchema = z7.object({
-  path: z7.string(),
-  reason: z7.string(),
-  size_bytes: z7.number().int().nonnegative().optional()
-});
-var forensicFrameworkSchema = z7.object({
-  kind: z7.string(),
-  version: z7.string(),
-  subkind: z7.string(),
-  evidence: z7.array(z7.string())
-});
-var forensicReadmeSchema = z7.object({
-  quality: z7.enum(["missing", "stub", "ok"]),
-  line_count: z7.number().int().nonnegative(),
-  has_contributing: z7.boolean()
-});
-var candidateFileEntrySchema = z7.object({
-  path: z7.string(),
-  family: z7.enum(["entry", "component", "config", "test", "domain"]),
-  rationale: z7.string()
-});
-var forensicSamplingBudgetSchema = z7.object({
-  max_files: z7.literal(15),
-  max_lines_per_file: z7.literal(100)
-});
-var forensicReportSchema = z7.object({
-  version: z7.string(),
-  generated_at: z7.string(),
-  generated_by: z7.string(),
-  target: z7.string(),
-  project_name: z7.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: z7.array(forensicEntryPointSchema),
-  code_samples: z7.array(forensicCodeSampleSchema),
-  assertions: z7.array(forensicAssertionSchema),
-  candidate_files: z7.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: z7.array(z7.string()).optional()
+  recommendations_for_skill: z15.array(z15.string()).optional()
 });
 
 // src/schemas/init-context.ts
-import { z as z8 } from "zod";
-var initContextFrameworkSchema = z8.object({
-  kind: z8.string(),
-  version: z8.string(),
-  subkind: z8.string()
-});
-var initContextInvariantConfidenceSnapshotSchema = z8.object({
-  confidence: z8.enum(["HIGH", "MEDIUM", "LOW"]),
-  evidence_refs: z8.array(z8.string())
-});
-var initContextSourceEvidenceSchema = z8.object({
-  file: z8.string(),
-  lines: z8.string()
-});
-var initContextInvariantSchema = z8.object({
-  type: z8.enum(["ban", "require", "protect"]),
-  rule: z8.string(),
-  rationale: z8.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: z8.array(initContextSourceEvidenceSchema).optional()
-});
-var initContextDomainGroupSchema = z8.object({
-  name: z8.string(),
-  paths: z8.array(z8.string()),
-  summary: z8.string().optional(),
-  topology_type: z8.enum(["mirror", "cross-cutting"]).optional(),
-  target_path: z8.string().optional()
-});
-var initContextInterviewTrailEntrySchema = z8.object({
-  phase: z8.string(),
-  question: z8.string(),
-  answer: z8.string(),
-  presentation: z8.string().optional(),
-  user_corrections: z8.array(z8.string()).optional()
-});
-var initContextSchema = z8.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: z8.array(z8.string()),
-  invariants: z8.array(initContextInvariantSchema),
-  domain_groups: z8.array(initContextDomainGroupSchema),
-  interview_trail: z8.array(initContextInterviewTrailEntrySchema),
-  forensic_ref: z8.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 z9 } from "zod";
-var metaUpdatedEventSchema = z9.object({
-  type: z9.literal("meta:updated"),
+import { z as z17 } from "zod";
+var metaUpdatedEventSchema = z17.object({
+  type: z17.literal("meta:updated"),
   payload: agentsMetaSchema
 });
-var lockDriftEventSchema = z9.object({
-  type: z9.literal("lock:drift"),
-  payload: z9.object({
-    locked: z9.array(humanLockEntrySchema),
-    drifted: z9.array(humanLockEntrySchema)
+var lockDriftEventSchema = z17.object({
+  type: z17.literal("lock:drift"),
+  payload: z17.object({
+    locked: z17.array(humanLockEntrySchema),
+    drifted: z17.array(humanLockEntrySchema)
   })
 });
-var lockApprovedEventSchema = z9.object({
-  type: z9.literal("lock:approved"),
-  payload: z9.object({
-    locked: z9.array(humanLockEntrySchema),
-    approved: z9.array(humanLockEntrySchema)
+var lockApprovedEventSchema = z17.object({
+  type: z17.literal("lock:approved"),
+  payload: z17.object({
+    locked: z17.array(humanLockEntrySchema),
+    approved: z17.array(humanLockEntrySchema)
   })
 });
-var ledgerAppendedEventSchema = z9.object({
-  type: z9.literal("ledger:appended"),
+var ledgerAppendedEventSchema = z17.object({
+  type: z17.literal("ledger:appended"),
   payload: ledgerEntrySchema
 });
-var driftDetectedEventSchema = z9.object({
-  type: z9.literal("drift:detected"),
+var driftDetectedEventSchema = z17.object({
+  type: z17.literal("drift:detected"),
   payload: forensicReportSchema
 });
-var fabricEventSchema = z9.discriminatedUnion("type", [
+var fabricEventSchema = z17.discriminatedUnion("type", [
   metaUpdatedEventSchema,
   lockDriftEventSchema,
   lockApprovedEventSchema,
@@ -915,143 +1838,258 @@ var fabricEventSchema = z9.discriminatedUnion("type", [
 ]);
 
 // src/schemas/event-ledger.ts
-import { z as z10 } 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: z10.literal("fabric-event"),
-  id: z10.string(),
-  ts: z10.number().int().nonnegative(),
-  schema_version: z10.literal(1),
-  correlation_id: z10.string().optional(),
-  session_id: z10.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 = z10.record(z10.string());
-var knowledgeContextPlannedEventSchema = z10.object({
+var stringRecordSchema = z18.record(z18.string());
+var knowledgeContextPlannedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_context_planned"),
-  target_paths: z10.array(z10.string()),
-  required_stable_ids: z10.array(z10.string()),
-  ai_selectable_stable_ids: z10.array(z10.string()),
-  final_stable_ids: z10.array(z10.string()),
-  selection_token: z10.string().optional(),
-  client_hash: z10.string().optional(),
-  intent: z10.string().optional(),
-  known_tech: z10.array(z10.string()).optional(),
-  diagnostics: z10.array(z10.unknown()).optional()
-});
-var knowledgeSelectionEventSchema = z10.object({
+  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: z10.literal("knowledge_selection"),
-  selection_token: z10.string(),
-  target_paths: z10.array(z10.string()),
-  required_stable_ids: z10.array(z10.string()),
-  ai_selectable_stable_ids: z10.array(z10.string()),
-  ai_selected_stable_ids: z10.array(z10.string()),
-  final_stable_ids: z10.array(z10.string()),
+  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: z10.array(z10.string()),
-  ignored_stable_ids: z10.array(z10.string())
+  rejected_stable_ids: z18.array(z18.string()),
+  ignored_stable_ids: z18.array(z18.string())
 });
-var knowledgeSectionsFetchedEventSchema = z10.object({
+var knowledgeSectionsFetchedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_sections_fetched"),
-  selection_token: z10.string(),
-  target_paths: z10.array(z10.string()).optional(),
-  requested_sections: z10.array(z10.string()),
-  final_stable_ids: z10.array(z10.string()),
-  ai_selected_stable_ids: z10.array(z10.string()),
-  diagnostics: z10.array(z10.unknown()).optional()
-});
-var editIntentCheckedEventSchema = z10.object({
+  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: z10.literal("edit_intent_checked"),
-  path: z10.string(),
-  compliant: z10.boolean(),
-  intent: z10.string(),
-  ledger_entry_id: z10.string(),
+  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: z10.enum(["ai", "human", "hook"]).optional(),
-  commit_sha: z10.string().optional(),
-  parent_sha: z10.string().optional(),
-  parent_ledger_entry_id: z10.string().optional(),
-  diff_stat: z10.string().optional(),
-  annotation: z10.string().optional(),
-  matched_rule_context_ts: z10.number().int().nonnegative().nullable(),
-  window_ms: z10.number().int().nonnegative()
-});
-var knowledgeDriftDetectedEventSchema = z10.object({
+  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: z10.literal("knowledge_drift_detected"),
-  revision: z10.string().optional(),
-  drifted_stable_ids: z10.array(z10.string()),
-  missing_files: z10.array(z10.string()),
-  stale_files: z10.array(z10.string()),
-  details: z10.array(
-    z10.object({
-      file: z10.string(),
-      stable_id: z10.string(),
-      expected_hash: z10.string(),
-      actual_hash: z10.string().nullable()
+  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 = z10.object({
+var mcpEventLedgerEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("mcp_event"),
-  mcp_event_id: z10.string(),
-  stream_id: z10.string(),
-  message: z10.unknown()
+  event_type: z18.literal("mcp_event"),
+  mcp_event_id: z18.string(),
+  stream_id: z18.string(),
+  message: z18.unknown()
 });
-var reapplyCompletedEventSchema = z10.object({
+var reapplyCompletedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("reapply_completed"),
-  preserved_ledger: z10.boolean(),
-  preserved_meta: z10.boolean(),
-  rules_count: z10.number().int().nonnegative()
+  event_type: z18.literal("reapply_completed"),
+  preserved_ledger: z18.boolean(),
+  preserved_meta: z18.boolean(),
+  rules_count: z18.number().int().nonnegative()
 });
-var installDiffAppliedEventSchema = z10.object({
+var installDiffAppliedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("install_diff_applied"),
-  applied: z10.array(z10.string()),
-  canonical: z10.array(z10.string()),
-  drifted: z10.array(z10.string())
+  event_type: z18.literal("install_diff_applied"),
+  applied: z18.array(z18.string()),
+  canonical: z18.array(z18.string()),
+  drifted: z18.array(z18.string())
 });
-var eventLedgerTruncatedEventSchema = z10.object({
+var eventLedgerTruncatedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("event_ledger_truncated"),
-  byte_offset: z10.number().int().nonnegative(),
-  byte_length: z10.number().int().nonnegative(),
-  corrupted_path: z10.string()
+  event_type: z18.literal("event_ledger_truncated"),
+  byte_offset: z18.number().int().nonnegative(),
+  byte_length: z18.number().int().nonnegative(),
+  corrupted_path: z18.string()
 });
-var mcpConfigMigratedEventSchema = z10.object({
+var mcpConfigMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("mcp_config_migrated"),
-  source: z10.literal("doctor_fix"),
-  removed_from: z10.string()
+  event_type: z18.literal("mcp_config_migrated"),
+  source: z18.literal("doctor_fix"),
+  removed_from: z18.string()
 });
-var bootstrapMarkerMigratedEventSchema = z10.object({
+var bootstrapMarkerMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("bootstrap_marker_migrated"),
-  path: z10.string(),
-  migrated_count: z10.number().int().nonnegative(),
-  legacy_marker: z10.literal("fabric:knowledge-base"),
-  new_marker: z10.literal("fabric:bootstrap"),
-  timestamp: z10.string()
-});
-var metaReconciledOnStartupEventSchema = z10.object({
+  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 = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("meta_reconciled_on_startup"),
-  reconciled_files: z10.array(z10.string()),
-  duration_ms: z10.number().int().nonnegative(),
-  source: z10.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 = z10.object({
+var metaReconciledEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("meta_reconciled"),
-  reconciled_files: z10.array(z10.string()),
-  duration_ms: z10.number().int().nonnegative(),
+  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
@@ -1065,7 +2103,7 @@ var metaReconciledEventSchema = z10.object({
   // 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: z10.enum([
+  trigger: z18.enum([
     "doctor",
     "manual",
     "auto-heal-description",
@@ -1073,195 +2111,195 @@ var metaReconciledEventSchema = z10.object({
     "post-approve",
     "post-modify"
   ]),
-  source: z10.literal("reconcileKnowledge"),
+  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: z10.enum(["revision_drift"]).optional()
+  force_write_reason: z18.enum(["revision_drift"]).optional()
 });
-var claudeSkillPathMigratedEventSchema = z10.object({
+var claudeSkillPathMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("claude_skill_path_migrated"),
-  from: z10.string(),
-  to: z10.string()
+  event_type: z18.literal("claude_skill_path_migrated"),
+  from: z18.string(),
+  to: z18.string()
 });
-var claudeHookPathMigratedEventSchema = z10.object({
+var claudeHookPathMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("claude_hook_path_migrated"),
-  from: z10.string(),
-  to: z10.string()
+  event_type: z18.literal("claude_hook_path_migrated"),
+  from: z18.string(),
+  to: z18.string()
 });
-var codexSkillPathMigratedEventSchema = z10.object({
+var codexSkillPathMigratedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("codex_skill_path_migrated"),
-  from: z10.string(),
-  to: z10.string()
+  event_type: z18.literal("codex_skill_path_migrated"),
+  from: z18.string(),
+  to: z18.string()
 });
-var initScanCompletedEventSchema = z10.object({
+var initScanCompletedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("init_scan_completed"),
-  written_stable_ids: z10.array(z10.string()),
-  duration_ms: z10.number().int().nonnegative(),
-  source: z10.enum(["init", "scan", "doctor_fix", "doctor-rescan"]).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 = z10.object({
+var knowledgeProposedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_proposed"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional()
+  event_type: z18.literal("knowledge_proposed"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgePromoteStartedEventSchema = z10.object({
+var knowledgePromoteStartedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_promote_started"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional()
+  event_type: z18.literal("knowledge_promote_started"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgePromotedEventSchema = z10.object({
+var knowledgePromotedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_promoted"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional()
+  event_type: z18.literal("knowledge_promoted"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgePromoteFailedEventSchema = z10.object({
+var knowledgePromoteFailedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_promote_failed"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string()
+  event_type: z18.literal("knowledge_promote_failed"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string()
 });
-var knowledgeLayerChangedEventSchema = z10.object({
+var knowledgeLayerChangedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_layer_changed"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional(),
-  from_layer: z10.enum(["team", "personal"]),
-  to_layer: z10.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: z10.string().optional()
+  previous_stable_id: z18.string().optional()
 });
-var knowledgeIdRedirectEventSchema = z10.object({
+var knowledgeIdRedirectEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_id_redirect"),
-  timestamp: z10.string().datetime(),
-  previous_stable_id: z10.string(),
-  new_stable_id: z10.string(),
-  reason: z10.string().optional()
+  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 knowledgeSlugRenamedEventSchema = z10.object({
+var knowledgeSlugRenamedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_slug_renamed"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional(),
-  from_slug: z10.string(),
-  to_slug: z10.string()
-});
-var knowledgeDemotedEventSchema = z10.object({
+  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 knowledgeDemotedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_demoted"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional()
+  event_type: z18.literal("knowledge_demoted"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgeArchivedEventSchema = z10.object({
+var knowledgeArchivedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_archived"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional()
+  event_type: z18.literal("knowledge_archived"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgeArchiveAttemptedEventSchema = z10.object({
+var knowledgeArchiveAttemptedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_archive_attempted"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional()
+  event_type: z18.literal("knowledge_archive_attempted"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string().optional()
 });
-var knowledgeUnarchivedEventSchema = z10.object({
+var knowledgeUnarchivedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_unarchived"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional(),
+  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: z10.string().optional(),
+  archive_path: z18.string().optional(),
   // Post-move canonical path (e.g. ".fabric/knowledge/team/decisions/KT-D-0007--single-cjs-hook.md").
-  restored_to: z10.string().optional()
+  restored_to: z18.string().optional()
 });
-var knowledgeDeferredEventSchema = z10.object({
+var knowledgeDeferredEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_deferred"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string().optional(),
-  until: z10.string().datetime().optional()
+  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 knowledgeRejectedEventSchema = z10.object({
+var knowledgeRejectedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_rejected"),
-  stable_id: z10.string().optional(),
-  timestamp: z10.string().datetime(),
-  reason: z10.string()
+  event_type: z18.literal("knowledge_rejected"),
+  stable_id: z18.string().optional(),
+  timestamp: z18.string().datetime(),
+  reason: z18.string()
 });
-var knowledgeConsumedEventSchema = z10.object({
+var knowledgeConsumedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_consumed"),
-  stable_id: z10.string(),
-  consumed_at: z10.string().datetime(),
-  client_hash: z10.string()
+  event_type: z18.literal("knowledge_consumed"),
+  stable_id: z18.string(),
+  consumed_at: z18.string().datetime(),
+  client_hash: z18.string()
 });
-var knowledgeScopeDegradedEventSchema = z10.object({
+var knowledgeScopeDegradedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_scope_degraded"),
-  stable_id: z10.string(),
-  timestamp: z10.string().datetime(),
-  from_scope: z10.enum(["narrow", "broad"]),
-  to_scope: z10.enum(["narrow", "broad"]),
-  reason: z10.string()
-});
-var doctorRunEventSchema = z10.object({
+  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 doctorRunEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("doctor_run"),
-  mode: z10.enum(["lint", "fix-knowledge"]),
-  issues: z10.number().int().nonnegative(),
-  mutations: z10.number().int().nonnegative().optional(),
-  timestamp: z10.string().datetime()
+  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 knowledgePathDangledEventSchema = z10.object({
+var knowledgePathDangledEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_path_dangled"),
-  stable_id: z10.string(),
-  removed_glob: z10.string()
+  event_type: z18.literal("knowledge_path_dangled"),
+  stable_id: z18.string(),
+  removed_glob: z18.string()
 });
-var relevanceMigrationRunEventSchema = z10.object({
+var relevanceMigrationRunEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("relevance_migration_run"),
-  timestamp: z10.string().datetime(),
-  scanned_count: z10.number().int().nonnegative(),
-  touched_count: z10.number().int().nonnegative()
+  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 = z10.object({
+var pendingAutoArchivedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("pending_auto_archived"),
-  pending_path: z10.string(),
-  archived_to: z10.string(),
-  reason: z10.string()
+  event_type: z18.literal("pending_auto_archived"),
+  pending_path: z18.string(),
+  archived_to: z18.string(),
+  reason: z18.string()
 });
-var assistantTurnObservedEventSchema = z10.object({
+var assistantTurnObservedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("assistant_turn_observed"),
-  kb_line_raw: z10.string().nullable(),
-  cite_ids: z10.array(z10.string()).default([]),
-  cite_tags: z10.array(z10.enum(["planned", "recalled", "chained-from", "dismissed", "none"])).default([]),
+  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
@@ -1269,72 +2307,72 @@ var assistantTurnObservedEventSchema = z10.object({
   // 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: z10.array(
-    z10.object({
-      operators: z10.array(
-        z10.object({
-          kind: z10.enum(["edit", "not_edit", "require", "forbid"]),
-          target: z10.string()
+  cite_commitments: z18.array(
+    z18.object({
+      operators: z18.array(
+        z18.object({
+          kind: z18.enum(["edit", "not_edit", "require", "forbid"]),
+          target: z18.string()
         })
       ),
-      skip_reason: z10.string().nullable()
+      skip_reason: z18.string().nullable()
     })
   ).default([]),
-  client: z10.enum(["cc", "codex", "cursor"]).optional(),
-  turn_id: z10.string(),
-  envelope_index: z10.number().int().nonnegative().optional(),
-  timestamp: z10.string().datetime()
+  client: z18.enum(["cc", "codex", "cursor"]).optional(),
+  turn_id: z18.string(),
+  envelope_index: z18.number().int().nonnegative().optional(),
+  timestamp: z18.string().datetime()
 });
-var citePolicyActivatedEventSchema = z10.object({
+var citePolicyActivatedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("cite_policy_activated"),
-  policy_version: z10.string(),
-  timestamp: z10.string().datetime()
+  event_type: z18.literal("cite_policy_activated"),
+  policy_version: z18.string(),
+  timestamp: z18.string().datetime()
 });
-var citeContractPolicyActivatedEventSchema = z10.object({
+var citeContractPolicyActivatedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("cite_contract_policy_activated")
+  event_type: z18.literal("cite_contract_policy_activated")
 });
-var eventsRotatedEventSchema = z10.object({
+var eventsRotatedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("events_rotated"),
-  cutoff_ts: z10.string().datetime(),
-  archived_count: z10.number().int().nonnegative(),
-  kept_count: z10.number().int().nonnegative(),
-  archive_path: z10.string()
+  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 = z10.object({
+var knowledgeMetaAutoHealedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_meta_auto_healed"),
-  previous_revision_hash: z10.string(),
-  revision_hash: z10.string(),
-  trigger: z10.literal("read"),
-  caller: z10.enum(["planContext", "getKnowledgeSections", "getKnowledge", "extractKnowledge"]).optional()
+  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 = z10.object({
+var serveLockClearedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("serve_lock_cleared"),
-  pid: z10.number().int().nonnegative(),
-  age_ms: z10.number().int().nonnegative(),
-  timestamp: z10.string().datetime()
+  event_type: z18.literal("serve_lock_cleared"),
+  pid: z18.number().int().nonnegative(),
+  age_ms: z18.number().int().nonnegative(),
+  timestamp: z18.string().datetime()
 });
-var knowledgeEnrichedEventSchema = z10.object({
+var knowledgeEnrichedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("knowledge_enriched"),
-  path: z10.string(),
-  added_fields: z10.array(z10.enum(["intent_clues", "tech_stack", "impact", "must_read_if"])),
-  mode: z10.enum(["auto", "preview", "readonly", "interactive"]),
-  timestamp: z10.string().datetime()
+  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 = z10.object({
+var sessionArchiveAttemptedEventSchema = z18.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("session_archive_attempted"),
-  outcome: z10.enum(["proposed", "viability_failed", "user_dismissed", "skipped_no_signal"]),
-  covered_through_ts: z10.number().int().nonnegative(),
-  candidates_proposed: z10.number().int().nonnegative().default(0),
-  knowledge_proposed_ids: z10.array(z10.string()).default([])
+  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 = z10.discriminatedUnion("event_type", [
+var eventLedgerEventSchema = z18.discriminatedUnion("event_type", [
   knowledgeContextPlannedEventSchema,
   knowledgeSelectionEventSchema,
   knowledgeSectionsFetchedEventSchema,
@@ -1417,98 +2455,6 @@ var eventLedgerEventSchema = z10.discriminatedUnion("event_type", [
   // covered_through_ts watermark, and `fabric doctor --archive-history`.
   sessionArchiveAttemptedEventSchema
 ]);
-
-// src/cite-line-parser.ts
-var ID_RE = /^K[TP]-[A-Z]+-\d+$/;
-var SENTINEL_RE = /^KB:\s*none\b\s*(?:\[[^\]]*\])?\s*$/i;
-var FULL_RE = /^KB:\s+(K[TP]-[A-Z]+-\d+(?:\s*,\s*K[TP]-[A-Z]+-\d+)*)(?:\s+\(([^)]*)\))?(?:\s+\[([^\]]+)\])?(?:\s+→\s*(.+))?\s*$/;
-var CHAINED_FROM_ID_RE = /chained-from\s+(K[TP]-[A-Z]+-\d+)/i;
-var ALLOWED_TAGS = /* @__PURE__ */ new Set([
-  "planned",
-  "recalled",
-  "chained-from",
-  "dismissed",
-  "none"
-]);
-function parseTag(rawTag) {
-  if (!rawTag) return "none";
-  const head = rawTag.trim().split(/[\s:]+/)[0].toLowerCase();
-  return ALLOWED_TAGS.has(head) ? head : "none";
-}
-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: [], tag: "none", commitment: null };
-  }
-  const fullMatch = trimmed.match(FULL_RE);
-  if (fullMatch) {
-    const primaryIds = fullMatch[1].split(",").map((part) => part.trim()).filter((part) => part.length > 0);
-    if (primaryIds.some((id) => !ID_RE.test(id))) return null;
-    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],
-      tag,
-      commitment: parseContractTail(fullMatch[4])
-    };
-  }
-  return null;
-}
-function parseCiteLine(raw) {
-  const result = {
-    cite_ids: [],
-    cite_tags: [],
-    cite_commitments: []
-  };
-  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 (const id of parsed.ids) {
-      result.cite_ids.push(id);
-    }
-    if (parsed.commitment !== null) {
-      for (let i = 0; i < parsed.ids.length; i += 1) {
-        result.cite_commitments.push(parsed.commitment);
-      }
-    }
-  }
-  return result;
-}
 export {
   AGENTS_META_IDENTITY_SOURCES,
   AGENTS_META_LAYERS,
@@ -1525,26 +2471,50 @@ export {
   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,
@@ -1553,7 +2523,11 @@ export {
   archiveScanOutputSchema,
   assistantTurnObservedEventSchema,
   auditModeSchema,
+  bindRequiredStore,
+  bindingsSnapshotPath,
   bootstrapMarkerMigratedEventSchema,
+  buildDebugBundle,
+  buildFailureTrace,
   candidateFileEntrySchema,
   citeContractMetricsSchema,
   citeContractPolicyActivatedEventSchema,
@@ -1564,6 +2538,8 @@ export {
   claudeSkillPathMigratedEventSchema,
   clientPathsSchema,
   codexSkillPathMigratedEventSchema,
+  createProjectRootResolver,
+  createStoreResolver,
   createTranslator,
   defaultAgentsMetaCounters,
   defaultLayerFilterSchema,
@@ -1572,19 +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,
@@ -1595,9 +2576,13 @@ export {
   forensicReportSchema,
   forensicSamplingBudgetSchema,
   forensicTopologySchema,
+  formatGlobalRef,
   formatKnowledgeId,
   getPanelFieldByKey,
   getPanelFields,
+  globalConfigSchema,
+  globalRefSchema,
+  hasSecrets,
   historyStateQuerySchema,
   humanLedgerEntrySchema,
   humanLockApproveRequestSchema,
@@ -1612,8 +2597,11 @@ export {
   initContextSchema,
   initContextSourceEvidenceSchema,
   initScanCompletedEventSchema,
+  initStore,
   installDiffAppliedEventSchema,
   isKnowledgeStableId,
+  isPersonalLeakIntoSharedStore,
+  isPersonalScope,
   knowledgeArchiveAttemptedEventSchema,
   knowledgeArchivedEventSchema,
   knowledgeConsumedEventSchema,
@@ -1630,6 +2618,7 @@ export {
   knowledgePromoteStartedEventSchema,
   knowledgePromotedEventSchema,
   knowledgeProposedEventSchema,
+  knowledgeProvenanceSchema,
   knowledgeRejectedEventSchema,
   knowledgeScopeDegradedEventSchema,
   knowledgeSectionsAnnotations,
@@ -1646,6 +2635,9 @@ export {
   ledgerEntrySchema,
   ledgerQuerySchema,
   ledgerSourceSchema,
+  lintCrossStoreReferences,
+  listStoreKnowledge,
+  localKnowledgeIdSchema,
   lockApprovedEventSchema,
   lockDriftEventSchema,
   mcpConfigMigratedEventSchema,
@@ -1654,9 +2646,17 @@ export {
   metaReconciledEventSchema,
   metaReconciledOnStartupEventSchema,
   metaUpdatedEventSchema,
+  mountedStoreSchema,
+  normalizeCiteTag,
   normalizeLocale,
   onboardSlotSchema,
+  parityCapabilitySchema,
+  parityClientExpectationSchema,
+  parityClientSchema,
+  parityMatrixSchema,
+  paritySurfaceSchema,
   parseCiteLine,
+  parseGlobalRef,
   parseKnowledgeId,
   pendingAutoArchivedEventSchema,
   planContextAnnotations,
@@ -1664,18 +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
 };