opencode-swarm 7.164.6 → 7.164.8

package/dist/cli/index-7qefgq4j.js

@@ -0,0 +1,71 @@
+// @bun
+// src/utils/canonical-root.ts
+import * as fsSync from "fs";
+import * as path from "path";
+var SESSION_KEY_SEPARATOR = String.fromCharCode(0);
+var canonicalRootMemo = new Map;
+var MAX_CANONICAL_ROOT_CACHE = 128;
+var _internals = {
+  realpathSyncNative: fsSync.realpathSync.native,
+  realpathSync: fsSync.realpathSync,
+  lstatSync: fsSync.lstatSync,
+  platform: () => process.platform
+};
+function normalizeIdentityPath(resolved) {
+  const normalized = _internals.platform() === "win32" ? path.win32.normalize(resolved) : path.posix.normalize(resolved);
+  return _internals.platform() === "win32" ? normalized.toLowerCase() : normalized;
+}
+function lexicalRootAliasKey(directory) {
+  return normalizeIdentityPath(path.resolve(directory));
+}
+function resolveCanonicalRootKey(directory) {
+  let resolved = path.resolve(directory);
+  try {
+    resolved = _internals.realpathSyncNative(resolved);
+  } catch {
+    try {
+      resolved = _internals.realpathSync(resolved);
+    } catch {}
+  }
+  return normalizeIdentityPath(resolved);
+}
+function canonicalRootKey(directory) {
+  const memoized = canonicalRootMemo.get(directory);
+  if (memoized !== undefined) {
+    try {
+      if (!_internals.lstatSync(directory).isSymbolicLink())
+        return memoized;
+    } catch {
+      return memoized;
+    }
+    const fresh = resolveCanonicalRootKey(directory);
+    if (fresh !== memoized)
+      canonicalRootMemo.set(directory, fresh);
+    return fresh;
+  }
+  const key = resolveCanonicalRootKey(directory);
+  if (!canonicalRootMemo.has(directory)) {
+    while (canonicalRootMemo.size >= MAX_CANONICAL_ROOT_CACHE) {
+      const oldest = canonicalRootMemo.keys().next().value;
+      if (oldest === undefined)
+        break;
+      canonicalRootMemo.delete(oldest);
+    }
+  }
+  canonicalRootMemo.set(directory, key);
+  return key;
+}
+function canonicalRootKeyFresh(directory) {
+  return resolveCanonicalRootKey(directory);
+}
+function sameProjectRoot(a, b) {
+  return canonicalRootKeyFresh(a) === canonicalRootKeyFresh(b);
+}
+function compositeSessionKey(directory, sessionId) {
+  return `${canonicalRootKey(directory)}${SESSION_KEY_SEPARATOR}${sessionId}`;
+}
+function sessionKeySuffix(sessionId) {
+  return `${SESSION_KEY_SEPARATOR}${sessionId}`;
+}
+
+export { _internals, lexicalRootAliasKey, canonicalRootKey, canonicalRootKeyFresh, sameProjectRoot, compositeSessionKey, sessionKeySuffix };

package/dist/cli/{index-zfwd65c2.js → index-8ntf8jnj.js}

@@ -1,19 +1,24 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-2c3np82d.js";
+} from "./index-8tqqmsav.js";
 import {
   observeStoreHealth
-} from "./index-p56xc59p.js";
+} from "./index-9ydhzegh.js";
+import {
+  canonicalRootKey,
+  canonicalRootKeyFresh,
+  sameProjectRoot
+} from "./index-7qefgq4j.js";
 import {
   withEvidenceLock
-} from "./index-fxxja498.js";
+} from "./index-2czt53wz.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-cyhw0der.js";
+} from "./index-t1qzjhnj.js";
 import {
   telemetry
-} from "./index-1dz8hv7p.js";
+} from "./index-kvq1e82k.js";
 import {
   exports_external,
   init_zod
@@ -166,13 +171,6 @@ function ensureSwarmDir(directory) {
 function buildCorrelationId(sessionID, repoFullName, prNumber) {
   return `${sessionID}::${repoFullName}::${prNumber}`;
 }
-function sameProjectRoot(recorded, current) {
-  const a = path.resolve(recorded);
-  const b = path.resolve(current);
-  if (process.platform === "win32")
-    return a.toLowerCase() === b.toLowerCase();
-  return a === b;
-}
 function fileSizeOrNull(filePath) {
   try {
     return fs.statSync(filePath).size;
@@ -887,22 +885,24 @@ function emitHealthTelemetry(directory, trigger, checkpoint) {
 }
 var legacyOverLimitWarned = new Map;
 function warnLegacyOverLimit(directory, size) {
-  if (legacyOverLimitWarned.has(directory))
+  const key = canonicalRootKey(directory);
+  if (legacyOverLimitWarned.has(key))
     return;
   if (legacyOverLimitWarned.size >= 32) {
     legacyOverLimitWarned.delete(legacyOverLimitWarned.keys().next().value);
   }
-  legacyOverLimitWarned.set(directory, true);
+  legacyOverLimitWarned.set(key, true);
   log(`[pr-monitor] legacy subscriptions.jsonl is ${size} bytes (>${PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes}); refusing to fold it \u2014 archive or split the file so its subscriptions can be re-subscribed, then remove it (reported via /swarm pr status)`);
 }
 var migrationCapacityWarned = new Map;
 function warnMigrationCapacity(directory, records) {
-  if (migrationCapacityWarned.has(directory))
+  const key = canonicalRootKey(directory);
+  if (migrationCapacityWarned.has(key))
     return;
   if (migrationCapacityWarned.size >= 32) {
     migrationCapacityWarned.delete(migrationCapacityWarned.keys().next().value);
   }
-  migrationCapacityWarned.set(directory, true);
+  migrationCapacityWarned.set(key, true);
   log(`[pr-monitor] legacy subscriptions.jsonl folds to ${records} records (>checkpoint capacity ${PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords}); migration refused \u2014 archive or split the file so its subscriptions can be re-subscribed, then remove it`);
 }
 function overlayLegacy(directory, checkpoint) {
@@ -1044,12 +1044,13 @@ async function loadViewForRead(directory) {
 }
 var bootstrapAttempted = new Map;
 async function bootstrapCheckpointFromLegacy(directory) {
-  if (bootstrapAttempted.has(directory))
+  const key = canonicalRootKeyFresh(directory);
+  if (bootstrapAttempted.has(key))
     return;
   if (bootstrapAttempted.size >= 32) {
     bootstrapAttempted.delete(bootstrapAttempted.keys().next().value);
   }
-  bootstrapAttempted.set(directory, true);
+  bootstrapAttempted.set(key, true);
   try {
     await withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
       if (readCheckpoint(directory).kind !== "absent")

package/dist/cli/{index-m1nrd3yd.js → index-8psybzzf.js}

@@ -462,7 +462,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect"]
     },
     repair_gate_evidence: {
-      description: "quarantine corrupt exact-task gate evidence and install a fresh blocked generation that requires every gate to rerun",
+      description: "quarantine recoverable exact-task gate evidence, rebuild from durable requirements, recover receipt-backed legacy marker wedges or the exact sentinel-only historical reset, and refuse every other receipt-less reconstruction",
       agents: ["architect"]
     },
     repair_knowledge_receipt_ledger: {

package/dist/cli/{index-2c3np82d.js → index-8tqqmsav.js}

@@ -7,7 +7,7 @@ import {
 } from "./index-r3mvsbtq.js";
 import {
   readCachedTextFile
-} from "./index-cyhw0der.js";
+} from "./index-t1qzjhnj.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";

package/dist/cli/{index-tegp2mny.js → index-93znbdam.js}

@@ -1,7 +1,10 @@
 // @bun
 import {
   atomicWriteFile
-} from "./index-ze5zyv28.js";
+} from "./index-mr3h3sm5.js";
+import {
+  canonicalRootKeyFresh
+} from "./index-7qefgq4j.js";
 import {
   init_logger,
   warn
@@ -189,8 +192,9 @@ function pointerStatFingerprint(directory) {
 }
 function resolveKnowledgeStoreDir(directory) {
   const localSwarm = path.join(directory, ".swarm");
+  const cacheKey = canonicalRootKeyFresh(directory);
   const now = Date.now();
-  const cached = _resolutionCache.get(directory);
+  const cached = _resolutionCache.get(cacheKey);
   const currentStat = pointerStatFingerprint(directory);
   if (cached && now < cached.expires && cached.pointerStat === currentStat) {
     return cached.linkDir ?? localSwarm;
@@ -211,12 +215,12 @@ function resolveKnowledgeStoreDir(directory) {
   } catch {
     linkDir = null;
   }
-  if (!_resolutionCache.has(directory) && _resolutionCache.size >= MAX_CACHE_ENTRIES) {
+  if (!_resolutionCache.has(cacheKey) && _resolutionCache.size >= MAX_CACHE_ENTRIES) {
     const oldest = _resolutionCache.keys().next().value;
     if (oldest !== undefined)
       _resolutionCache.delete(oldest);
   }
-  _resolutionCache.set(directory, {
+  _resolutionCache.set(cacheKey, {
     linkDir,
     expires: now + CACHE_TTL_MS,
     pointerStat: currentStat
@@ -228,7 +232,7 @@ function invalidateKnowledgeStoreDirCache(directory) {
     _resolutionCache.clear();
     return;
   }
-  _resolutionCache.delete(directory);
+  _resolutionCache.delete(canonicalRootKeyFresh(directory));
 }
 function isLinked(directory) {
   return readLinkPointer(directory) !== null;

package/dist/cli/{index-hdapetg1.js → index-9ek9d96g.js}

@@ -2,14 +2,14 @@
 import {
   init_loader,
   loadPluginConfigWithMeta
-} from "./index-ew99d4y6.js";
+} from "./index-apdp9bc1.js";
 import {
   init_schema
-} from "./index-5p1tzpwh.js";
+} from "./index-ypjffdrg.js";
 import {
   DEFAULT_WORKTREE_ISOLATION_CONFIG,
   init_constants
-} from "./index-m1nrd3yd.js";
+} from "./index-8psybzzf.js";
 
 // src/config/index.ts
 init_constants();

package/dist/cli/{index-p56xc59p.js → index-9ydhzegh.js}

@@ -1,12 +1,15 @@
 // @bun
+import {
+  canonicalRootKeyFresh
+} from "./index-7qefgq4j.js";
 import {
   atomicWriteSwarmFile
-} from "./index-cyhw0der.js";
+} from "./index-t1qzjhnj.js";
 import {
   pseudonymousRef,
   resolveLineageSalt,
   telemetry
-} from "./index-1dz8hv7p.js";
+} from "./index-kvq1e82k.js";
 
 // src/health/learning-health.ts
 import { promises as fs } from "fs";
@@ -178,15 +181,16 @@ var lastPersistAtByDirectory = new Map;
 var recentPersistDirectories = [];
 var MAX_TRACKED_DIRECTORIES = 16;
 function rememberPersistDirectory(directory) {
-  if (recentPersistDirectories.includes(directory)) {
-    const idx = recentPersistDirectories.indexOf(directory);
+  const key = canonicalRootKeyFresh(directory);
+  const idx = recentPersistDirectories.findIndex((entry) => entry.key === key);
+  if (idx >= 0) {
     recentPersistDirectories.splice(idx, 1);
   }
-  recentPersistDirectories.push(directory);
+  recentPersistDirectories.push({ key, directory });
   while (recentPersistDirectories.length > MAX_TRACKED_DIRECTORIES) {
     const evicted = recentPersistDirectories.shift();
     if (evicted !== undefined)
-      lastPersistAtByDirectory.delete(evicted);
+      lastPersistAtByDirectory.delete(evicted.key);
   }
 }
 var _internals = {
@@ -205,11 +209,12 @@ var _internals = {
 };
 var projectRefCache = new Map;
 function projectRef(directory) {
-  const cached = projectRefCache.get(directory);
+  const key = canonicalRootKeyFresh(directory);
+  const cached = projectRefCache.get(key);
   if (cached !== undefined)
     return cached;
-  const ref = pseudonymousRef(directory, resolveLineageSalt());
-  if (!projectRefCache.has(directory)) {
+  const ref = pseudonymousRef(key, resolveLineageSalt());
+  if (!projectRefCache.has(key)) {
     while (projectRefCache.size >= MAX_TRACKED_DIRECTORIES) {
       const oldest = projectRefCache.keys().next().value;
       if (oldest === undefined)
@@ -217,9 +222,12 @@ function projectRef(directory) {
       projectRefCache.delete(oldest);
     }
   }
-  projectRefCache.set(directory, ref);
+  projectRefCache.set(key, ref);
   return ref;
 }
+function legacyProjectRef(directory) {
+  return pseudonymousRef(directory, resolveLineageSalt());
+}
 function getScopeMap(alarm) {
   let map = alarmScopes.get(alarm);
   if (!map) {
@@ -361,13 +369,14 @@ function applyAlarmState(alarm, scopeClass, scopeKey, desired, severity, detail,
   }
 }
 function schedulePersist(directory, now, force) {
-  const target = directory ?? recentPersistDirectories.at(-1);
+  const target = directory ?? recentPersistDirectories.at(-1)?.directory;
   if (!target)
     return;
-  const last = lastPersistAtByDirectory.get(target) ?? 0;
+  const targetKey = canonicalRootKeyFresh(target);
+  const last = lastPersistAtByDirectory.get(targetKey) ?? 0;
   if (!force && now - last < PERSIST_DEBOUNCE_MS)
     return;
-  lastPersistAtByDirectory.set(target, now);
+  lastPersistAtByDirectory.set(targetKey, now);
   persistLearningHealth(target).catch(() => {
     return;
   });
@@ -462,13 +471,14 @@ function isAdoptableScopeKey(key) {
   if (typeof key !== "string" || key.length === 0 || key.length > 200) {
     return false;
   }
-  return /^[0-9a-zA-Z:_.-/]+$/.test(key);
+  return /^[-0-9a-zA-Z:_.\u002f]+$/.test(key);
 }
 function isFiniteCounter(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 function livenessMap(directory) {
-  let map = livenessGaps.get(directory);
+  const key = canonicalRootKeyFresh(directory);
+  let map = livenessGaps.get(key);
   if (!map) {
     if (livenessGaps.size >= MAX_TRACKED_DIRECTORIES) {
       let victim;
@@ -483,7 +493,7 @@ function livenessMap(directory) {
         livenessGaps.delete(victim);
     }
     map = new Map;
-    livenessGaps.set(directory, map);
+    livenessGaps.set(key, map);
   }
   return map;
 }
@@ -742,12 +752,13 @@ async function readLearningHealth(directory) {
     const now = _internals.now();
     evaluateLiveness(directory, now);
     const scopeOwner = projectRef(directory);
+    const legacyScopeOwner = legacyProjectRef(directory);
     const active = [];
     for (const [alarm, scopes] of alarmScopes) {
       for (const [key, scope] of scopes) {
         if (scope.status !== "active")
           continue;
-        const owned = key.startsWith(`${scopeOwner}/`) || key.startsWith("u/") || key.startsWith("store/");
+        const owned = key.startsWith(`${scopeOwner}/`) || key.startsWith(`${legacyScopeOwner}/`) || key.startsWith("u/") || key.startsWith("store/");
         if (!owned)
           continue;
         active.push({

package/dist/cli/{index-ew99d4y6.js → index-apdp9bc1.js}

@@ -6,7 +6,7 @@ import {
   PluginConfigSchema,
   init_schema,
   resolveExternalSkillsConfig
-} from "./index-5p1tzpwh.js";
+} from "./index-ypjffdrg.js";
 import {
   GIT_BINARY_ENV_VAR,
   init_git_executable

package/dist/cli/{index-12xzj0hm.js → index-b10yvv6h.js}

@@ -11,16 +11,16 @@ import {
 import {
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-5p1tzpwh.js";
+} from "./index-ypjffdrg.js";
 import {
   observeStoreHealth
-} from "./index-p56xc59p.js";
+} from "./index-9ydhzegh.js";
 import {
   init_constants
-} from "./index-m1nrd3yd.js";
+} from "./index-8psybzzf.js";
 import {
   telemetry
-} from "./index-1dz8hv7p.js";
+} from "./index-kvq1e82k.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-zjg5ajf5.js → index-bv90qkyw.js}

@@ -1,7 +1,10 @@
 // @bun
 import {
   loadDatabaseCtor
-} from "./index-zaab1wz9.js";
+} from "./index-n4fzmqz8.js";
+import {
+  canonicalExistingFilesystemPath
+} from "./index-ry16d01s.js";
 import {
   validateSpecContent
 } from "./index-n832052r.js";
@@ -9,9 +12,13 @@ import {
   advisoryWarn,
   init_warning_buffer
 } from "./index-4rhhvd1a.js";
+import {
+  canonicalRootKeyFresh,
+  lexicalRootAliasKey
+} from "./index-7qefgq4j.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-cyhw0der.js";
+} from "./index-t1qzjhnj.js";
 
 // src/sdd/effective-spec.ts
 import { createHash } from "crypto";
@@ -727,26 +734,9 @@ function withDurabilityClass(db, cls, fn) {
   }
 }
 
-// src/db/canonical-project.ts
-import { realpathSync } from "fs";
-import { resolve as resolve2 } from "path";
-var _internals = {
-  realpathSync
-};
-function canonicalProjectKey(directory) {
-  const lexical = resolve2(directory);
-  let canonical;
-  try {
-    canonical = _internals.realpathSync(lexical);
-  } catch {
-    canonical = lexical;
-  }
-  return process.platform === "win32" ? canonical.toLowerCase() : canonical;
-}
-
 // src/db/project-db.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, unlinkSync } from "fs";
-import { join as join2, resolve as resolve3 } from "path";
+import { join as join2 } from "path";
 
 // src/db/db-errors.ts
 class ProjectDbError extends Error {
@@ -964,6 +954,38 @@ var MIGRATIONS = [
   }
 ];
 var _projectDbs = new Map;
+var _projectDbAliases = new Map;
+var MAX_ALIASES_PER_PROJECT_DB = 128;
+function lexicalAliasKey(directory) {
+  return lexicalRootAliasKey(directory);
+}
+function unbindAlias(alias, physicalKey) {
+  if (_projectDbAliases.get(alias) === physicalKey) {
+    _projectDbAliases.delete(alias);
+  }
+  _projectDbs.get(physicalKey)?.aliases.delete(alias);
+}
+function bindAlias(record, physicalKey, alias) {
+  const previousKey = _projectDbAliases.get(alias);
+  if (previousKey !== undefined && previousKey !== physicalKey) {
+    unbindAlias(alias, previousKey);
+  }
+  record.aliases.delete(alias);
+  record.aliases.add(alias);
+  _projectDbAliases.set(alias, physicalKey);
+  while (record.aliases.size > MAX_ALIASES_PER_PROJECT_DB) {
+    const evicted = [...record.aliases].find((candidate) => candidate !== record.primaryAlias && candidate !== alias);
+    if (evicted === undefined)
+      break;
+    unbindAlias(evicted, physicalKey);
+  }
+}
+function closeRecord(physicalKey, record) {
+  record.db.close();
+  _projectDbs.delete(physicalKey);
+  for (const alias of [...record.aliases])
+    unbindAlias(alias, physicalKey);
+}
 function recordMigrationFailure(db, migration, err, markerDir) {
   const errorText = String(err instanceof Error ? err.message : err).slice(0, MIGRATION_FAILURE_ERROR_MAX_CHARS);
   try {
@@ -1032,28 +1054,20 @@ function runProjectMigrations(db, markerDir) {
     removeMigrationFailureMarker(markerDir);
 }
 function projectDbPath(directory) {
-  return join2(resolve3(directory), ".swarm", "swarm.db");
+  return join2(canonicalRootKeyFresh(directory), ".swarm", "swarm.db");
 }
 function projectDbExists(directory) {
-  return existsSync2(join2(canonicalProjectKey(directory), ".swarm", "swarm.db"));
-}
-function checkpointWalBestEffort(db) {
-  try {
-    const row = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
-    if (row && row.busy === 1) {
-      db.run("PRAGMA wal_checkpoint(PASSIVE);");
-    }
-  } catch {
-    try {
-      db.run("PRAGMA wal_checkpoint(PASSIVE);");
-    } catch {}
-  }
+  return existsSync2(projectDbPath(directory));
 }
 function getProjectDb(directory) {
-  const key = canonicalProjectKey(directory);
+  mkdirSync2(directory, { recursive: true });
+  const key = canonicalRootKeyFresh(directory);
+  const alias = lexicalAliasKey(directory);
   const existing = _projectDbs.get(key);
-  if (existing)
-    return existing;
+  if (existing) {
+    bindAlias(existing, key, alias);
+    return existing.db;
+  }
   const swarmDir = join2(key, ".swarm");
   try {
     mkdirSync2(swarmDir, { recursive: true });
@@ -1084,20 +1098,30 @@ function getProjectDb(directory) {
       throw err;
     throw new ProjectDbError("open_failed", `Failed to open .swarm/swarm.db for project ${key}: ${err instanceof Error ? err.message : String(err)}`);
   }
-  _projectDbs.set(key, db);
+  const record = {
+    db,
+    primaryAlias: alias,
+    aliases: new Set
+  };
+  _projectDbs.set(key, record);
+  bindAlias(record, key, alias);
   return db;
 }
 function closeProjectDb(directory) {
-  const key = canonicalProjectKey(directory);
-  const db = _projectDbs.get(key);
-  if (db) {
-    checkpointWalBestEffort(db);
-    try {
-      db.close();
-    } finally {
-      _projectDbs.delete(key);
-    }
+  const alias = lexicalAliasKey(directory);
+  const currentPath = canonicalExistingFilesystemPath(directory);
+  if (currentPath !== null) {
+    const currentKey = canonicalRootKeyFresh(directory);
+    const currentRecord = _projectDbs.get(currentKey);
+    if (currentRecord)
+      closeRecord(currentKey, currentRecord);
+    return;
+  }
+  const previousKey = _projectDbAliases.get(alias);
+  const previousRecord = previousKey === undefined ? undefined : _projectDbs.get(previousKey);
+  if (previousKey !== undefined && previousRecord) {
+    closeRecord(previousKey, previousRecord);
   }
 }
 
-export { DURABILITY_CLASSES, batchDurabilityClass, applySynchronousForClass, withDurabilityClass, canonicalProjectKey, DbWriteError, classifyDbWriteError, projectDbPath, projectDbExists, getProjectDb, closeProjectDb, detectSpeckit, resolveSpeckitProjection, loadSddStatusSync, buildOpenSpecProjectionSync, readEffectiveSpecSync, writeProjectedSpecSync, validateSpeckit };
+export { DURABILITY_CLASSES, batchDurabilityClass, applySynchronousForClass, withDurabilityClass, DbWriteError, classifyDbWriteError, projectDbPath, projectDbExists, getProjectDb, closeProjectDb, detectSpeckit, resolveSpeckitProjection, loadSddStatusSync, buildOpenSpecProjectionSync, readEffectiveSpecSync, writeProjectedSpecSync, validateSpeckit };

package/dist/cli/{index-zypacgjc.js → index-bz8vsc8r.js}

@@ -6,12 +6,12 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-rysxqae0.js";
+} from "./index-ghnbpez3.js";
 import {
   queryHistoricalOutcomes,
   readKnowledgeEvents,
   recordKnowledgeEvent
-} from "./index-gwg7a00b.js";
+} from "./index-g2e8b3wm.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -224,11 +224,11 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-01evhydg.js");
+    const { quarantineEntry } = await import("./knowledge-validator-exd900vc.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-t1scx08g.js");
-      const { loadPluginConfigWithMeta } = await import("./index-ty3vtqe2.js");
+      const { KnowledgeConfigSchema } = await import("./schema-mbb9g4w4.js");
+      const { loadPluginConfigWithMeta } = await import("./index-espcjyrx.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {