@fenglimg/fabric-shared 2.3.0-rc.9 → 2.3.0

package/dist/index.js

@@ -1,4 +1,3 @@
-import "./chunk-LXNCAKJZ.js";
 import {
   BOOTSTRAP_CANONICAL_BY_LOCALE,
   BOOTSTRAP_CANONICAL_EN,
@@ -8,7 +7,8 @@ import {
   BOOTSTRAP_REGEX,
   matchBootstrapCanonicalLocale,
   resolveBootstrapCanonical
-} from "./chunk-KFFBQRL5.js";
+} from "./chunk-V7IUN5U2.js";
+import "./chunk-LXNCAKJZ.js";
 import {
   PROTECTED_TOKENS,
   createTranslator,
@@ -16,7 +16,7 @@ import {
   enMessages,
   resolveFabricLocale,
   zhCNMessages
-} from "./chunk-P6INRP3A.js";
+} from "./chunk-WXVFJBL5.js";
 import {
   GLOBAL_BINDINGS_DIR,
   GLOBAL_STATE_DIR,
@@ -40,6 +40,7 @@ import {
   resolveGlobalLocale,
   resolveGlobalRoot,
   saveGlobalConfig,
+  saveGlobalConfigAsync,
   storeAliasSchema,
   storeIdentitySchema,
   storeKnowledgeTypeDir,
@@ -51,7 +52,7 @@ import {
   storeRelativePath,
   storeRelativePathForMount,
   storeUuidSchema
-} from "./chunk-ASS2KBB7.js";
+} from "./chunk-OX6DWUK4.js";
 import {
   atomicWriteJson,
   withFileLock
@@ -116,7 +117,7 @@ import {
   scopeCoordinateSchema,
   scopeRoot,
   structuredWarningSchema
-} from "./chunk-TV264D7E.js";
+} from "./chunk-5M3HB554.js";
 
 // src/schemas/agents-meta.ts
 import { z } from "zod";
@@ -655,6 +656,11 @@ var fabricConfigSchema = z5.object({
   // relieve; until then they ship as inert-safe opt-outs.
   cite_policy_enabled: z5.boolean().optional().default(true),
   self_archive_policy_enabled: z5.boolean().optional().default(true),
+  // Peer micro-transfer P0-2: when true, fab_propose hard-refuses dump-shaped
+  // session_context / bodies (body altitude). Default false = warn-and-still-write
+  // so corpus recovery stays non-blocking. Env FABRIC_ALTITUDE_PROPOSE_GATE=1
+  // overrides this to true for CI/dogfood. Power-user JSON only (not on config TUI).
+  altitude_propose_gate: z5.boolean().optional().default(false),
   // 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
@@ -677,10 +683,13 @@ var fabricConfigSchema = z5.object({
   // fabric-hint Stop hook — knowledge-hint-broad re-fires on every
   // SessionStart by default (compact / clear / new-window), which on long
   // sessions becomes redundant noise. Setting to 1 means "emit the broad
-  // menu at most once per hour"; 0 means "no cooldown, current behavior."
+  // menu at most once per hour"; 0 means "no cooldown, re-fire every open."
+  // ISS-20260713-033 shipped a non-zero quiet DEFAULT of 24 (at most once per
+  // day) so repeat session-opens stay quiet; set 0 for verbose/debug.
   // 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: z5.number().int().min(0).max(168).optional().default(24),
+  // ISS-20260713-033
   // 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-
@@ -837,6 +846,7 @@ function makePositiveIntField(key, defaultValue) {
   return {
     key,
     group: "B_hint_threshold",
+    type: "number",
     widget: "text",
     label_i18n_key: `cli.config.fields.${key}.label`,
     description_i18n_key: `cli.config.fields.${key}.description`,
@@ -866,6 +876,7 @@ function makeEnumField(key, group, enumValues, defaultValue) {
   return {
     key,
     group,
+    type: "string",
     widget: "select",
     label_i18n_key: `cli.config.fields.${key}.label`,
     description_i18n_key: `cli.config.fields.${key}.description`,
@@ -892,6 +903,7 @@ function makeBooleanField(key, defaultValue) {
   return {
     key,
     group: "D_behavior",
+    type: "boolean",
     widget: "select",
     label_i18n_key: `cli.config.fields.${key}.label`,
     description_i18n_key: `cli.config.fields.${key}.description`,
@@ -1450,7 +1462,7 @@ function hasScriptExtension(name) {
   return dot !== -1 && SCRIPT_EXTENSIONS.has(name.slice(dot).toLowerCase());
 }
 var STORE_SCAN_MAX_DEPTH = 32;
-var STORE_SCAN_MAX_ENTRIES = 1e5;
+var STORE_SCAN_MAX_ENTRIES = 5e4;
 function findStoreExecutableViolations(absDir, options = {}) {
   const maxDepth = options.maxDepth ?? STORE_SCAN_MAX_DEPTH;
   const maxEntries = options.maxEntries ?? STORE_SCAN_MAX_ENTRIES;
@@ -1646,12 +1658,11 @@ async function initStore(absDir, identity, options = {}) {
   await mkdir(join2(absDir, STORE_LAYOUT.knowledgeDir, STORE_PENDING_DIR), { recursive: true });
   await mkdir(join2(absDir, STORE_LAYOUT.bindingsDir), { recursive: true });
   await mkdir(join2(absDir, STORE_LAYOUT.stateDir), { recursive: true });
-  await writeFile(identityFile, `${JSON.stringify(parsed, null, 2)}
-`, "utf8");
   await writeFile(join2(absDir, ".gitignore"), STORE_GITIGNORE, "utf8");
   if (options.git !== false) {
     await git(absDir, ["init", "-b", "main"]);
   }
+  await atomicWriteJson(identityFile, parsed, { indent: 2 });
   const readBack = await readStoreIdentityAsync(absDir);
   if (readBack === null) {
     throw new Error(`store init wrote an unrecognizable store.json at ${absDir}`);
@@ -1699,46 +1710,94 @@ async function readKnowledgeAcrossStores(stores) {
 function storeProjectsPath(storeDir) {
   return join2(storeDir, STORE_LAYOUT.projectsFile);
 }
+function storeProjectsLockPath(storeDir) {
+  return `${storeProjectsPath(storeDir)}.lock`;
+}
 async function readStoreProjects(storeDir) {
   const path = storeProjectsPath(storeDir);
+  let text;
+  try {
+    text = await readFile2(path, "utf8");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
   let raw;
   try {
-    raw = JSON.parse(await readFile2(path, "utf8"));
+    raw = JSON.parse(text);
   } catch {
-    return [];
+    throw new Error(
+      `projects.json at ${path} is not valid JSON \u2014 refusing to treat as empty (would risk overwrite on next add)`
+    );
   }
   const parsed = storeProjectsFileSchema.safeParse(raw);
-  return parsed.success ? parsed.data.projects : [];
+  if (!parsed.success) {
+    throw new Error(
+      `projects.json at ${path} failed schema validation \u2014 refusing to treat as empty (would risk overwrite on next add): ${parsed.error.message}`
+    );
+  }
+  return parsed.data.projects;
 }
 async function storeHasProject(storeDir, id) {
   return (await readStoreProjects(storeDir)).some((p) => p.id === id);
 }
 async function addStoreProject(storeDir, project) {
   const parsed = storeProjectSchema.parse(project);
-  const existing = await readStoreProjects(storeDir);
-  if (existing.some((p) => p.id === parsed.id)) {
-    throw new Error(`project '${parsed.id}' already exists in store at ${storeDir}`);
-  }
-  const next = [...existing, parsed];
-  const validated = storeProjectsFileSchema.parse({ projects: next });
-  await writeFile(storeProjectsPath(storeDir), `${JSON.stringify(validated, null, 2)}
-`, "utf8");
-  return validated.projects;
+  return withFileLock(storeProjectsLockPath(storeDir), async () => {
+    const existing = await readStoreProjects(storeDir);
+    if (existing.some((p) => p.id === parsed.id)) {
+      throw new Error(`project '${parsed.id}' already exists in store at ${storeDir}`);
+    }
+    const next = [...existing, parsed];
+    const validated = storeProjectsFileSchema.parse({ projects: next });
+    await atomicWriteJson(storeProjectsPath(storeDir), validated, { indent: 2 });
+    return validated.projects;
+  });
 }
 async function aggregatePendingAcrossStores(stores) {
-  const lists = await Promise.all(stores.map(
-    async (store) => (await 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
-    }))
-  ));
+  const lists = await Promise.all(
+    stores.map(async (store) => {
+      const pendingRoot = join2(store.dir, STORE_LAYOUT.knowledgeDir, STORE_PENDING_DIR);
+      const refs = [];
+      for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+        for (const file of await listMarkdown(join2(pendingRoot, type))) {
+          refs.push({
+            store_uuid: store.store_uuid,
+            alias: store.alias,
+            type: STORE_PENDING_DIR,
+            file
+          });
+        }
+      }
+      for (const file of await listMarkdown(pendingRoot)) {
+        refs.push({
+          store_uuid: store.store_uuid,
+          alias: store.alias,
+          type: STORE_PENDING_DIR,
+          file
+        });
+      }
+      return refs;
+    })
+  );
   return lists.flat();
 }
 
 // src/store/store-counters.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync } from "fs";
+import {
+  closeSync,
+  existsSync as existsSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { randomUUID } from "crypto";
 import { join as join3 } from "path";
 function storeCountersPath(storeDir) {
   return join3(storeDir, STORE_LAYOUT.countersFile);
@@ -1812,6 +1871,57 @@ function readEntryId(file) {
   const idPart = stem.split("--")[0];
   return idPart.length > 0 ? idPart : null;
 }
+function withCountersFileLockSync(lockPath, fn) {
+  const token = `${process.pid}.${randomUUID()}`;
+  const start = Date.now();
+  const maxWaitMs = 1e4;
+  const staleMs = 1e4;
+  for (; ; ) {
+    let fd;
+    try {
+      fd = openSync(lockPath, "wx");
+      writeFileSync(lockPath, token, "utf8");
+      try {
+        closeSync(fd);
+      } catch {
+      }
+      try {
+        return fn();
+      } finally {
+        try {
+          if (readFileSync2(lockPath, "utf8") === token) rmSync(lockPath, { force: true });
+        } catch {
+        }
+      }
+    } catch (err) {
+      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+      if (code !== "EEXIST") throw err;
+      try {
+        const st = statSync(lockPath);
+        if (Date.now() - st.mtimeMs > staleMs) {
+          const stale = readFileSync2(lockPath, "utf8");
+          if (readFileSync2(lockPath, "utf8") === stale) rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - start > maxWaitMs) {
+        throw new Error(`withCountersFileLockSync: timeout on ${lockPath}`);
+      }
+      const end = Date.now() + 20;
+      while (Date.now() < end) {
+      }
+    }
+  }
+}
+function atomicWriteCountersSync(path, counters) {
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  const body = `${JSON.stringify(counters, null, 2)}
+`;
+  writeFileSync(tmp, body, "utf8");
+  renameSync(tmp, path);
+}
 function reconcileStoreCounters(storeDir) {
   const current = readStoreCounters(storeDir);
   const next = {
@@ -1836,13 +1946,20 @@ function reconcileStoreCounters(storeDir) {
       next[layerKey][typeCode] = Math.max(next[layerKey][typeCode], parsed.counter);
     }
   }
-  writeFileSync(storeCountersPath(storeDir), `${JSON.stringify(next, null, 2)}
-`, "utf8");
+  withCountersFileLockSync(`${storeCountersPath(storeDir)}.lock`, () => {
+    const latest = readStoreCounters(storeDir);
+    for (const layer of ["KP", "KT"]) {
+      for (const code of ["MOD", "DEC", "GLD", "PIT", "PRO"]) {
+        next[layer][code] = Math.max(next[layer][code], latest[layer][code]);
+      }
+    }
+    atomicWriteCountersSync(storeCountersPath(storeDir), next);
+  });
   return next;
 }
 
 // src/store/project-config-io.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { join as join4 } from "path";
 function projectConfigPath(projectRoot) {
   return join4(projectRoot, ".fabric", "fabric-config.json");
@@ -1862,8 +1979,20 @@ function loadProjectConfig(projectRoot) {
 function saveProjectConfig(config, projectRoot) {
   const validated = fabricConfigSchema.parse(config);
   mkdirSync(join4(projectRoot, ".fabric"), { recursive: true });
-  writeFileSync2(projectConfigPath(projectRoot), `${JSON.stringify(validated, null, 2)}
-`, "utf8");
+  const target = projectConfigPath(projectRoot);
+  const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+  const body = `${JSON.stringify(validated, null, 2)}
+`;
+  try {
+    writeFileSync2(tmp, body, "utf8");
+    renameSync2(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
 }
 
 // src/store/resolve-input.ts
@@ -1976,6 +2105,31 @@ function scrubRemoteUrl(remote) {
   );
 }
 
+// src/store/git-remote-allowlist.ts
+var ALLOWED_REMOTE_RE = /^(?:https?:\/\/|ssh:\/\/|git:\/\/|git@[^:\s]+:)/i;
+var BLOCKED_REMOTE_RE = /^(?:ext::|file:\/\/|fd::|http\+\w+:\/\/|https\+\w+:\/\/)/i;
+var ABSOLUTE_LOCAL_PATH_RE = /^(?:\/|[A-Za-z]:[\\/])/;
+function isTestRuntime() {
+  return process.env.VITEST !== void 0 || process.env.VITEST_WORKER_ID !== void 0;
+}
+function isAllowedGitRemote(remote) {
+  const trimmed = remote.trim();
+  if (trimmed.length === 0) return false;
+  if (BLOCKED_REMOTE_RE.test(trimmed)) return false;
+  if (trimmed.startsWith("-")) return false;
+  if (ALLOWED_REMOTE_RE.test(trimmed)) return true;
+  return isTestRuntime() && ABSOLUTE_LOCAL_PATH_RE.test(trimmed);
+}
+function assertAllowedGitRemote(remote) {
+  const trimmed = remote.trim();
+  if (!isAllowedGitRemote(trimmed)) {
+    throw new Error(
+      `git remote not allowlisted: ${remote} (allowed: https://, http://, ssh://, git://, git@host:path; blocked: ext::, file://, option-like)`
+    );
+  }
+  return trimmed;
+}
+
 // src/scanner/scan-recommendations.ts
 function buildScanRecommendations(input, t) {
   const recs = [];
@@ -2101,7 +2255,8 @@ var MCP_STORE_AWARE_TOOLS = [
   "fab_get_knowledge_sections",
   "fab_archive_scan",
   "fab_propose",
-  "fab_review"
+  "fab_review",
+  "fab_pending"
 ];
 var storeAwareEntrySchema = z11.object({
   stable_id: z11.string(),
@@ -2130,7 +2285,10 @@ var MCP_STORE_AWARE_CONTRACTS = {
     surfacesEntries: false,
     echoesWrittenStore: true
   },
-  fab_review: { tool: "fab_review", surfacesEntries: true, echoesWrittenStore: true }
+  fab_review: { tool: "fab_review", surfacesEntries: true, echoesWrittenStore: true },
+  // W3-K K2: read-only list/search lifted from fab_review — surfaces pending/
+  // canonical entries with store provenance, does not write.
+  fab_pending: { tool: "fab_pending", surfacesEntries: true, echoesWrittenStore: false }
 };
 
 // src/schemas/bindings-snapshot.ts
@@ -2177,9 +2335,9 @@ import {
   mkdirSync as mkdirSync2,
   readdirSync as readdirSync3,
   readFileSync as readFileSync4,
-  renameSync,
-  statSync,
-  unlinkSync,
+  renameSync as renameSync3,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
 import { join as join5, resolve, sep } from "path";
@@ -2230,7 +2388,7 @@ function countMarkdownFiles(dir) {
     }
     let mtimeMs;
     try {
-      mtimeMs = statSync(fullPath).mtimeMs;
+      mtimeMs = statSync2(fullPath).mtimeMs;
     } catch {
       continue;
     }
@@ -2276,10 +2434,10 @@ function atomicWriteJsonSync(path, value) {
   try {
     writeFileSync3(tmpPath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
-    renameSync(tmpPath, path);
+    renameSync3(tmpPath, path);
   } catch (error) {
     try {
-      unlinkSync(tmpPath);
+      unlinkSync2(tmpPath);
     } catch {
     }
     throw error;
@@ -3180,6 +3338,54 @@ var fileMutatedEventSchema = z16.object({
   source_event_id: z16.string().optional(),
   store_id: z16.string().optional()
 });
+var storeMountedEventSchema = z16.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z16.literal("store_mounted"),
+  alias: z16.string(),
+  store_uuid: z16.string(),
+  personal: z16.boolean().optional(),
+  source: z16.string().optional()
+});
+var storeDetachedEventSchema = z16.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z16.literal("store_detached"),
+  alias: z16.string(),
+  store_uuid: z16.string().optional(),
+  source: z16.string().optional()
+});
+var storeBoundEventSchema = z16.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z16.literal("store_bound"),
+  alias: z16.string(),
+  store_uuid: z16.string().optional(),
+  project: z16.string().optional(),
+  source: z16.string().optional()
+});
+var writeStoreSwitchedEventSchema = z16.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z16.literal("write_store_switched"),
+  alias: z16.string(),
+  previous_alias: z16.string().optional(),
+  // Named switch_kind (not `kind`) so it never shadows the envelope
+  // kind: "fabric-event" discriminator required by every ledger row.
+  switch_kind: z16.enum(["project_write", "personal"]).optional(),
+  source: z16.string().optional()
+});
+var writeRouteChangedEventSchema = z16.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z16.literal("write_route_changed"),
+  scope: z16.string(),
+  alias: z16.string(),
+  previous_alias: z16.string().optional(),
+  source: z16.string().optional()
+});
+var narrowHintFailedEventSchema = z16.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z16.literal("narrow_hint_failed"),
+  hook_name: z16.string(),
+  reason: z16.string(),
+  bin: z16.string().optional()
+});
 var knowledgeBodyReadEventSchema = z16.object({
   ...eventLedgerEnvelopeSchema,
   event_type: z16.literal("knowledge_body_read"),
@@ -3292,6 +3498,14 @@ var eventLedgerEventSchema = z16.discriminatedUnion("event_type", [
   // lifecycle-refactor Wave 2 — dormant-hook activation markers.
   sessionEndedEventSchema,
   fileMutatedEventSchema,
+  // ISS-20260711-127: store topology admin events
+  storeMountedEventSchema,
+  storeDetachedEventSchema,
+  storeBoundEventSchema,
+  writeStoreSwitchedEventSchema,
+  writeRouteChangedEventSchema,
+  // ISS-20260711-215: narrow_hint_failed — CLI failure observability for narrow hook
+  narrowHintFailedEventSchema,
   // KT-DEC-0030: knowledge_body_read — PostToolUse native-Read consumption marker
   // (replaces knowledge_consumed as the funnel's "body opened" signal).
   knowledgeBodyReadEventSchema,
@@ -3299,6 +3513,49 @@ var eventLedgerEventSchema = z16.discriminatedUnion("event_type", [
   graphEdgeCandidateRequestedEventSchema
 ]);
 
+// src/high-value-predicate.ts
+var HIGH_VALUE_ARCHIVE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "knowledge_context_planned",
+  "edit_paths_recorded",
+  "edit_intent_checked"
+  // the real high-freq edit signal (rc.37 NEW-14/B3)
+]);
+var NORMATIVE_KEYWORDS = [
+  "\u4EE5\u540E",
+  "always",
+  "never",
+  "from now on",
+  "\u4E0B\u6B21",
+  "\u8BB0\u4E00\u4E0B",
+  "\u6C38\u8FDC\u4E0D\u8981"
+];
+function isHighValueArchiveCandidate(events, sessionId, watermarkTs) {
+  if (!Array.isArray(events)) return false;
+  if (typeof sessionId !== "string" || sessionId.length === 0) return false;
+  const wm = typeof watermarkTs === "number" ? watermarkTs : 0;
+  let latestTurn = null;
+  for (const raw of events) {
+    const e = raw;
+    if (!e || typeof e.ts !== "number" || e.ts <= wm) continue;
+    if (e.session_id !== sessionId) continue;
+    if (typeof e.event_type === "string" && HIGH_VALUE_ARCHIVE_EVENT_TYPES.has(e.event_type)) {
+      return true;
+    }
+    if (e.event_type === "assistant_turn_observed") {
+      if (latestTurn === null || typeof latestTurn.ts === "number" && e.ts > latestTurn.ts) {
+        latestTurn = e;
+      }
+    }
+  }
+  if (latestTurn !== null) {
+    const haystack = JSON.stringify(latestTurn).toLowerCase();
+    for (const kw of NORMATIVE_KEYWORDS) {
+      if (haystack.includes(kw.toLowerCase())) return true;
+    }
+  }
+  return false;
+}
+
 // src/text-tokenize.ts
 var CJK_CLASS = "\\u3400-\\u4dbf\\u4e00-\\u9fff\\uf900-\\ufaff\\u3040-\\u30ff\\uac00-\\ud7af";
 var RUN_RE = new RegExp(`[a-z0-9]+|[${CJK_CLASS}]+`, "gu");
@@ -3433,6 +3690,7 @@ export {
   archiveScanAnnotations,
   archiveScanInputSchema,
   archiveScanOutputSchema,
+  assertAllowedGitRemote,
   assistantTurnObservedEventSchema,
   auditModeSchema,
   bindRequiredStore,
@@ -3521,6 +3779,8 @@ export {
   initScanCompletedEventSchema,
   initStore,
   installDiffAppliedEventSchema,
+  isAllowedGitRemote,
+  isHighValueArchiveCandidate,
   isKnowledgeStableId,
   isNonPersonalRequiredStore,
   isPersonalLeakIntoSharedStore,
@@ -3577,6 +3837,7 @@ export {
   metaUpdatedEventSchema,
   migrateRequiredStores,
   mountedStoreSchema,
+  narrowHintFailedEventSchema,
   normalizeCiteTag,
   normalizeLocale,
   nudgeModeSchema,
@@ -3635,6 +3896,7 @@ export {
   ruleDescriptionIndexItemSchema,
   ruleDescriptionSchema,
   saveGlobalConfig,
+  saveGlobalConfigAsync,
   saveProjectConfig,
   scanForSecrets,
   scopeCoordinateSchema,
@@ -3650,14 +3912,17 @@ export {
   skillTriggerCandidateEventSchema,
   storeAliasSchema,
   storeAwareEntrySchema,
+  storeBoundEventSchema,
   storeCountersPath,
   storeCountersSchema,
+  storeDetachedEventSchema,
   storeHasProject,
   storeIdentitySchema,
   storeKnowledgeTypeDir,
   storeMountGroup,
   storeMountNameSchema,
   storeMountSubPath,
+  storeMountedEventSchema,
   storeProjectSchema,
   storeProjectsFileSchema,
   storeReadSetSchema,
@@ -3672,7 +3937,9 @@ export {
   uidSchema,
   withDerivedAgentsMetaNodeDefaults,
   writeBindingsSnapshot,
+  writeRouteChangedEventSchema,
   writeRouteSchema,
+  writeStoreSwitchedEventSchema,
   writeTargetSchema,
   writtenToStoreSchema,
   zhCNMessages