@remnic/core 1.0.3 → 1.1.1

package/dist/index.js

@@ -10,6 +10,19 @@ import {
   revokeToken,
   saveTokenStore
 } from "./chunk-O5ETUNBT.js";
+import {
+  runGraphRecall
+} from "./chunk-DGVM5SFL.js";
+import {
+  DEFAULT_PPR_DAMPING,
+  DEFAULT_PPR_ITERATIONS,
+  DEFAULT_PPR_TOLERANCE,
+  buildGraphFromMemories,
+  extractGraphEdges,
+  isEdgeType,
+  isNodeType,
+  queryGraph
+} from "./chunk-64NJRYU2.js";
 import {
   clearBulkImportSources,
   clearTrainingExportAdapters,
@@ -27,117 +40,184 @@ import {
   runBulkImportCliCommand,
   runBulkImportPipeline,
   validateImportTurn
-} from "./chunk-YFYL2SIJ.js";
-import "./chunk-KWP7T3DP.js";
-import "./chunk-AYPYCLR7.js";
-import "./chunk-X4WESCKA.js";
+} from "./chunk-INXV5JBT.js";
+import "./chunk-VDX363PS.js";
+import "./chunk-KUB6JU6H.js";
+import {
+  parseXrayBudgetFlag,
+  parseXrayCliOptions
+} from "./chunk-PVPWZSSI.js";
+import "./chunk-B5WXLVDY.js";
 import "./chunk-HL4DB7TO.js";
+import "./chunk-ULYOGL6R.js";
 import "./chunk-ZPKBYX2F.js";
 import "./chunk-3SLRNYNG.js";
 import "./chunk-LIRZNNUP.js";
 import "./chunk-Y4Z4I6WK.js";
 import {
+  reportBufferSurpriseDistribution
+} from "./chunk-ASAITVLA.js";
+import {
+  DEFAULT_SURPRISE_K,
+  computeSurprise
+} from "./chunk-5JRF2PZA.js";
+import {
+  getMemoryForActiveMemory,
+  recallForActiveMemory
+} from "./chunk-G4SK7DSQ.js";
+import "./chunk-6MKAMLQL.js";
+import {
+  DEFAULT_TAXONOMY,
   Orchestrator,
+  branchNamespaceName,
   buildProcedureRecallSection,
   decideSemanticDedup,
   defaultWorkspaceDir,
+  describeCodingScope,
+  generateResolverDocument,
+  getTaxonomyDir,
+  getTaxonomyFilePath,
+  loadTaxonomy,
   migrateFromEngram,
+  normalizeOriginUrl,
+  projectNamespaceName,
+  resolveCodingNamespaceOverlay,
+  resolveGitContext,
   rollbackFromEngramMigration,
-  sanitizeSessionKeyForFilename
-} from "./chunk-XMGSSBFX.js";
-import "./chunk-JROGC36Y.js";
+  sanitizeSessionKeyForFilename,
+  saveTaxonomy,
+  stableHash,
+  validateSlug,
+  validateTaxonomy
+} from "./chunk-VYM3VWOF.js";
+import "./chunk-RGLL5SPU.js";
+import "./chunk-UHGBNIOS.js";
 import "./chunk-FSFEQI74.js";
 import "./chunk-W6SL7OFG.js";
 import "./chunk-Z5AAYHUC.js";
 import "./chunk-S75M5ZRK.js";
 import "./chunk-TPB3I2AC.js";
-import "./chunk-UHGBNIOS.js";
-import "./chunk-BTY5RRRF.js";
-import "./chunk-ETOW6ACV.js";
-import "./chunk-KVE7R4CG.js";
 import "./chunk-JR4ZC3G4.js";
+import "./chunk-ZEM3OK2K.js";
+import "./chunk-ETOW6ACV.js";
+import "./chunk-5NPGSAVB.js";
 import "./chunk-C7VW7C3F.js";
 import "./chunk-K4FLSOR5.js";
 import "./chunk-V3RXWQIE.js";
 import "./chunk-5IZL4DCV.js";
+import "./chunk-VBVG2M5G.js";
+import "./chunk-KVBLZUKV.js";
+import "./chunk-X7XN6YU4.js";
+import {
+  DEFAULT_REASONING_TRACE_BOOST,
+  applyReasoningTraceBoost,
+  isReasoningTracePath,
+  looksLikeProblemSolvingQuery
+} from "./chunk-ZZTOURJI.js";
 import "./chunk-YDBIWGNI.js";
 import "./chunk-7DHTMOND.js";
-import "./chunk-S4LX5EBI.js";
-import "./chunk-X7XN6YU4.js";
-import "./chunk-5NPGSAVB.js";
 import "./chunk-YCN4BVDK.js";
 import "./chunk-D654IBA6.js";
 import "./chunk-H63EDPFJ.js";
+import {
+  applyMemoryWorthFilter,
+  buildMemoryWorthCounterMap
+} from "./chunk-3GPTTA4J.js";
+import {
+  computeMemoryWorth
+} from "./chunk-IISBCCWR.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
   intentCompatibilityScore,
   isTaskInitiationIntent,
   planRecallMode
-} from "./chunk-BKQJBXXX.js";
+} from "./chunk-GGD5W7TB.js";
 import "./chunk-YAZNBMNF.js";
-import "./chunk-ALXMCZEU.js";
-import {
-  buildEntityRecallSection
-} from "./chunk-74JR4N5J.js";
+import "./chunk-AJU4PJGY.js";
+import "./chunk-DF3RVK3X.js";
 import {
   clearVerdictCache,
   createVerdictCache,
+  getVerdictKind,
+  isDurableVerdict,
+  isValidCachedVerdict,
   judgeFactDurability,
+  normalizeCachedVerdict,
   verdictCacheSize
-} from "./chunk-LAYN4LDC.js";
+} from "./chunk-C4SQJZAF.js";
 import {
   ExtractionEngine
-} from "./chunk-2VFW5K5U.js";
-import "./chunk-UEYA6UC7.js";
+} from "./chunk-S3EEFKNY.js";
+import "./chunk-NZLQTHS5.js";
+import "./chunk-54V4BZWP.js";
 import "./chunk-NBNN5GOB.js";
-import "./chunk-UPMD5XND.js";
 import "./chunk-FEMOX5AD.js";
+import "./chunk-JL2PU6AI.js";
 import "./chunk-VEWZZM3H.js";
-import "./chunk-PAORGQRI.js";
+import {
+  resolveCategory
+} from "./chunk-6AUUAZEX.js";
+import {
+  FILTER_LABELS,
+  isDirectAnswerEligible
+} from "./chunk-Y4FHOFJ2.js";
+import "./chunk-ALXMCZEU.js";
+import {
+  buildEntityRecallSection
+} from "./chunk-FVA6TGI3.js";
+import {
+  buildExtensionsFooterForSummary,
+  loadDaySummaryPrompt
+} from "./chunk-GZCUW5IC.js";
+import {
+  expandTildePath
+} from "./chunk-EPQJM2GC.js";
 import "./chunk-PYXS46O7.js";
 import "./chunk-3QKK7QOS.js";
-import "./chunk-GJQPH5G3.js";
+import "./chunk-CUPFXL3J.js";
 import "./chunk-JRNQ3RNA.js";
-import "./chunk-MYQWXITD.js";
+import "./chunk-SPI27QT6.js";
 import "./chunk-CULXMQJH.js";
 import "./chunk-E6K4NIEU.js";
-import "./chunk-EABGC2TL.js";
-import "./chunk-LOBRX7VD.js";
 import {
   LanceDbBackend,
   MeilisearchBackend,
   OramaBackend
-} from "./chunk-HITJFT7E.js";
+} from "./chunk-7I7FKFZH.js";
 import "./chunk-YRMVARQP.js";
+import {
+  QmdClient
+} from "./chunk-YNQKWQT4.js";
 import {
   LEGACY_PLUGIN_ID,
   PLUGIN_ID,
   resolveRemnicPluginEntry
 } from "./chunk-U66YHYC7.js";
-import {
-  QmdClient
-} from "./chunk-7PA4OZEU.js";
-import "./chunk-J4IYOZZ5.js";
-import "./chunk-AAI7JARD.js";
+import "./chunk-EABGC2TL.js";
+import "./chunk-LOBRX7VD.js";
+import "./chunk-HMDCOMYU.js";
+import "./chunk-JXS5PDQ7.js";
+import "./chunk-LK6SGL53.js";
 import "./chunk-7SEAZFFB.js";
 import "./chunk-K6WK37A6.js";
-import "./chunk-LK6SGL53.js";
-import {
-  CODEX_THREAD_KEY_PREFIX
-} from "./chunk-3PG3H5TD.js";
-import "./chunk-FYIYMQ5N.js";
-import "./chunk-2NMMFZ5T.js";
 import {
   coerceInstallExtension,
   parseConfig
-} from "./chunk-OJFGVJS6.js";
+} from "./chunk-BK2EFTE2.js";
 import "./chunk-Z5LAYHGJ.js";
 import "./chunk-C6QPK5GG.js";
+import "./chunk-C2EFFULQ.js";
 import {
-  buildExtensionsFooterForSummary,
-  loadDaySummaryPrompt
-} from "./chunk-GZCUW5IC.js";
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-3PG3H5TD.js";
+import "./chunk-FYIYMQ5N.js";
+import "./chunk-2NMMFZ5T.js";
+import "./chunk-KVE7R4CG.js";
+import "./chunk-4WMCPJWX.js";
+import {
+  SmartBuffer
+} from "./chunk-JBMSGZEQ.js";
 import {
   MATERIALIZE_VERSION,
   SENTINEL_FILE,
@@ -147,7 +227,7 @@ import {
   materializeForNamespace,
   runCodexMaterialize,
   runPostConsolidationMaterialize
-} from "./chunk-RCICHSHL.js";
+} from "./chunk-BGJGXLZ7.js";
 import {
   REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT,
   discoverMemoryExtensions,
@@ -155,28 +235,28 @@ import {
   renderExtensionsFooter,
   resolveExtensionsRoot
 } from "./chunk-EJI5XIBB.js";
-import "./chunk-C2EFFULQ.js";
-import "./chunk-4WMCPJWX.js";
+import {
+  FallbackLlmClient
+} from "./chunk-3GXCSUXR.js";
+import "./chunk-XZ2TIKGC.js";
+import "./chunk-ODWDQNRE.js";
+import "./chunk-Y27UJK6V.js";
+import "./chunk-UZB5KHKX.js";
 import "./chunk-6HZ6AO2P.js";
 import "./chunk-JWPLJLDU.js";
 import {
   BootstrapEngine
 } from "./chunk-N53K2EXC.js";
-import "./chunk-URB2WSKZ.js";
-import "./chunk-UVJFDP7P.js";
 import "./chunk-XYIK4LF6.js";
-import "./chunk-QKAH5B6E.js";
-import "./chunk-KEG4GNGI.js";
-import "./chunk-ODWDQNRE.js";
-import "./chunk-Y27UJK6V.js";
-import "./chunk-UZB5KHKX.js";
+import "./chunk-URB2WSKZ.js";
+import "./chunk-PVGDJXVK.js";
 import "./chunk-NGAVDO7E.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-PMB3WGDL.js";
+} from "./chunk-DFTTJYSO.js";
 import {
   EngramMcpServer
-} from "./chunk-NSB3WSYS.js";
+} from "./chunk-HK3FGIEW.js";
 import {
   buildCitationGuidance,
   formatOaiMemCitation,
@@ -184,35 +264,46 @@ import {
   sanitizeNoteForCitation
 } from "./chunk-IQT3XTKW.js";
 import "./chunk-MARWOCVP.js";
-import {
-  formatZodError,
-  memoryStoreRequestSchema,
-  observeRequestSchema,
-  recallRequestSchema,
-  suggestionSubmitRequestSchema,
-  validateRequest
-} from "./chunk-MTLYEMJB.js";
 import {
   EngramAccessInputError,
-  EngramAccessService
-} from "./chunk-V7XCAHIB.js";
+  EngramAccessService,
+  computeProcedureStats,
+  formatProcedureStatsText
+} from "./chunk-GKFXUTJ2.js";
+import {
+  RECALL_XRAY_FORMATS,
+  parseXrayFormat,
+  renderXray,
+  renderXrayJson,
+  renderXrayMarkdown,
+  renderXrayText
+} from "./chunk-ZAIM4TUE.js";
+import "./chunk-SOBJ6NEY.js";
+import "./chunk-3OGMS3PE.js";
 import {
   isTrustZoneName
 } from "./chunk-EQINRHYR.js";
-import "./chunk-POBPGDWI.js";
-import "./chunk-QDYXG4CS.js";
-import "./chunk-QNJMBKFK.js";
+import {
+  memoryWorthOutcomeEligibleCategories,
+  recordMemoryOutcome
+} from "./chunk-EIR5VLIH.js";
 import "./chunk-EEQLFRUM.js";
 import {
   buildProcedureMarkdownBody,
   parseProcedureStepsFromBody
 } from "./chunk-QDW3E4RD.js";
-import "./chunk-4NRAJUDS.js";
+import "./chunk-3FPTCC3Z.js";
+import "./chunk-2LGMW3DJ.js";
+import {
+  CrossNamespaceBudget,
+  DEFAULT_CROSS_NAMESPACE_BUDGET
+} from "./chunk-GDFS42HT.js";
+import "./chunk-RBBWYEFJ.js";
 import "./chunk-DT5TVLJE.js";
+import {
+  resolvePrincipal
+} from "./chunk-N5AKDXAI.js";
 import "./chunk-TBBDFYXW.js";
-import "./chunk-DGXUHMOV.js";
-import "./chunk-LPSF4OQH.js";
-import "./chunk-XKECPATV.js";
 import {
   BRIEFING_FORMAT_ALLOWED,
   FileCalendarSource,
@@ -225,11 +316,11 @@ import {
   renderBriefingMarkdown,
   resolveBriefingSaveDir,
   validateBriefingFormat
-} from "./chunk-ECKDIK5F.js";
+} from "./chunk-WVVA7F5A.js";
 import {
   StorageManager
-} from "./chunk-POMSFKTB.js";
-import "./chunk-U2IQTSBY.js";
+} from "./chunk-F5VP6YCB.js";
+import "./chunk-LTCGGW2D.js";
 import {
   CITATION_UNKNOWN,
   DEFAULT_CITATION_FORMAT,
@@ -241,33 +332,193 @@ import {
   parseCitation,
   stripCitation
 } from "./chunk-4KAN3GZ3.js";
-import {
-  createVersion,
-  diffVersions,
-  getVersion,
-  listVersions,
-  revertToVersion
-} from "./chunk-6ZH4TU6I.js";
 import "./chunk-6PFRXT4K.js";
 import "./chunk-TP4FZJIZ.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-BOUYNNYD.js";
-import "./chunk-QSVPYQPG.js";
 import "./chunk-DM2T26WE.js";
+import "./chunk-QSVPYQPG.js";
 import "./chunk-M62O4P4T.js";
 import "./chunk-4DJQYKMN.js";
+import "./chunk-X6GF3FX2.js";
+import {
+  createVersion,
+  diffVersions,
+  getVersion,
+  listVersions,
+  revertToVersion
+} from "./chunk-FAAFWE4G.js";
 import {
   initLogger,
   log
 } from "./chunk-2ODBA7MQ.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
 import {
-  getMemoryForActiveMemory,
-  recallForActiveMemory
-} from "./chunk-G4SK7DSQ.js";
-import "./chunk-6MKAMLQL.js";
+  AccessAuditAdapter
+} from "./chunk-TVVEYCNW.js";
 import {
-  resolvePrincipal
-} from "./chunk-N5AKDXAI.js";
+  DEFAULT_ANOMALY_DETECTOR_CONFIG,
+  detectRecallAnomalies,
+  normalizeQueryText
+} from "./chunk-RFYAYKTD.js";
+import "./chunk-LBLXEFWK.js";
+import "./chunk-XKECPATV.js";
+import {
+  formatZodError,
+  memoryStoreRequestSchema,
+  observeRequestSchema,
+  recallRequestSchema,
+  suggestionSubmitRequestSchema,
+  validateRequest
+} from "./chunk-WCLICCGB.js";
+
+// src/coding/review-context.ts
+var REVIEW_KEYWORD_PATTERNS = [
+  /\breview\b/i,
+  /\bdiff\b/i,
+  /\bwhat changed\b/i,
+  /\blook at this pr\b/i,
+  /\bwhat('?s|\s+is)\s+in\s+this\s+(pr|patch|diff|change)\b/i,
+  /\bcode review\b/i
+];
+function isReviewPrompt(prompt) {
+  if (typeof prompt !== "string") return false;
+  const trimmed = prompt.trim();
+  if (!trimmed) return false;
+  return REVIEW_KEYWORD_PATTERNS.some((re) => re.test(trimmed));
+}
+function parseTouchedFiles(diff) {
+  if (typeof diff !== "string" || !diff.trim()) return [];
+  const touched = /* @__PURE__ */ new Set();
+  const lines = diff.split(/\r?\n/);
+  for (const line of lines) {
+    const gitPrefix = line.match(/^diff --git\s+/);
+    if (gitPrefix) {
+      const rest = line.slice(gitPrefix[0].length);
+      const paths = splitDiffGitPaths(rest);
+      if (paths) {
+        for (const raw of paths) {
+          const stripped = stripDiffPathPrefix(raw);
+          if (stripped && stripped !== "/dev/null") touched.add(stripped);
+        }
+      }
+      continue;
+    }
+    const headerPrefix = line.match(/^(?:---|\+\+\+)[ \t]+/);
+    if (headerPrefix) {
+      const tail = line.slice(headerPrefix[0].length).replace(/[ \t]+$/, "");
+      const raw = extractSingleDiffPathToken(tail);
+      if (raw) {
+        const stripped = stripDiffPathPrefix(raw);
+        if (stripped && stripped !== "/dev/null") touched.add(stripped);
+      }
+    }
+  }
+  return Array.from(touched).sort();
+}
+function extractSingleDiffPathToken(tail) {
+  if (tail.length === 0) return null;
+  if (tail[0] === '"') {
+    let j2 = 1;
+    while (j2 < tail.length) {
+      if (tail[j2] === "\\" && j2 + 1 < tail.length) {
+        j2 += 2;
+        continue;
+      }
+      if (tail[j2] === '"') break;
+      j2 += 1;
+    }
+    if (j2 >= tail.length) return null;
+    return tail.slice(0, j2 + 1);
+  }
+  let j = 0;
+  while (j < tail.length && tail[j] !== " " && tail[j] !== "	") j += 1;
+  return tail.slice(0, j);
+}
+function splitDiffGitPaths(rest) {
+  const tokens = [];
+  let i = 0;
+  while (i < rest.length && tokens.length < 2) {
+    while (i < rest.length && (rest[i] === " " || rest[i] === "	")) i += 1;
+    if (i >= rest.length) break;
+    if (rest[i] === '"') {
+      let j = i + 1;
+      while (j < rest.length) {
+        if (rest[j] === "\\" && j + 1 < rest.length) {
+          j += 2;
+          continue;
+        }
+        if (rest[j] === '"') break;
+        j += 1;
+      }
+      if (j >= rest.length) return null;
+      tokens.push(rest.slice(i, j + 1));
+      i = j + 1;
+    } else {
+      let j = i;
+      while (j < rest.length && rest[j] !== " " && rest[j] !== "	") j += 1;
+      tokens.push(rest.slice(i, j));
+      i = j;
+    }
+  }
+  if (tokens.length !== 2) return null;
+  return [tokens[0], tokens[1]];
+}
+function stripDiffPathPrefix(raw) {
+  let s = raw;
+  if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') {
+    s = s.slice(1, -1);
+    s = s.replace(/\\(["\\])/g, "$1");
+  }
+  s = s.replace(/\\/g, "/");
+  if (s.startsWith("a/") || s.startsWith("b/")) s = s.slice(2);
+  return s;
+}
+var BOOST_PER_MATCH = 0.5;
+var MAX_BOOST = 1;
+function countPathHits(entityRefs, touchedFiles) {
+  if (!entityRefs || entityRefs.length === 0) return 0;
+  if (touchedFiles.length === 0) return 0;
+  let hits = 0;
+  for (const ref of entityRefs) {
+    if (typeof ref !== "string" || !ref) continue;
+    const lowered = ref.toLowerCase();
+    for (const file of touchedFiles) {
+      const flower = file.toLowerCase();
+      if (lowered === flower) {
+        hits += 1;
+        break;
+      }
+      if (lowered.includes(flower) || flower.includes(lowered)) {
+        hits += 1;
+        break;
+      }
+    }
+  }
+  return hits;
+}
+function rankReviewCandidates(candidates, touchedFiles) {
+  const annotated = candidates.map((c) => {
+    const hits = countPathHits(c.entityRefs, touchedFiles);
+    const boost = Math.min(MAX_BOOST, hits * BOOST_PER_MATCH);
+    return { ...c, boost };
+  });
+  annotated.sort((a, b) => {
+    const adjA = a.score + a.boost;
+    const adjB = b.score + b.boost;
+    if (adjA !== adjB) return adjB - adjA;
+    if (a.id < b.id) return -1;
+    if (a.id > b.id) return 1;
+    return 0;
+  });
+  return annotated;
+}
+function packReviewContext(input) {
+  const touchedFiles = parseTouchedFiles(input.diff);
+  const rankedRecall = rankReviewCandidates(input.candidates, touchedFiles);
+  return { touchedFiles, rankedRecall };
+}
 
 // src/binary-lifecycle/types.ts
 var DEFAULT_SCAN_PATTERNS = [
@@ -680,7 +931,8 @@ var CATEGORY_DIR_MAP = {
   rule: "rules",
   skill: "skills",
   relationship: "relationships",
-  procedure: "procedures"
+  procedure: "procedures",
+  reasoning_trace: "reasoning-traces"
 };
 var ALL_CATEGORY_DIRS = [
   "facts",
@@ -4767,313 +5019,6 @@ function publisherForConnector(connectorId) {
   return publisherFor(hostIdForConnector(connectorId));
 }
 
-// src/taxonomy/default-taxonomy.ts
-var DEFAULT_TAXONOMY = {
-  version: 1,
-  categories: [
-    {
-      id: "corrections",
-      name: "Corrections",
-      description: "Corrections to previously stored information",
-      filingRules: ["Any update that supersedes a prior fact"],
-      priority: 10,
-      memoryCategories: ["correction"]
-    },
-    {
-      id: "principles",
-      name: "Principles",
-      description: "Rules, guidelines, and recurring patterns",
-      filingRules: ["A guiding principle, rule, or skill"],
-      priority: 20,
-      memoryCategories: ["principle", "rule", "skill"]
-    },
-    {
-      id: "procedures",
-      name: "Procedures",
-      description: "Ordered multi-step workflows the user repeats",
-      filingRules: ["A repeatable sequence of steps or commands for a task"],
-      priority: 25,
-      memoryCategories: ["procedure"]
-    },
-    {
-      id: "entities",
-      name: "Entities",
-      description: "People, organizations, places, projects",
-      filingRules: ["Named entity with attributes"],
-      priority: 30,
-      memoryCategories: ["entity", "relationship"]
-    },
-    {
-      id: "decisions",
-      name: "Decisions",
-      description: "Choices made and their rationale",
-      filingRules: ["A decision or commitment with reasoning"],
-      priority: 35,
-      memoryCategories: ["decision", "commitment"]
-    },
-    {
-      id: "preferences",
-      name: "Preferences",
-      description: "User likes, dislikes, and style choices",
-      filingRules: ["Anything expressing a preference or taste"],
-      priority: 40,
-      memoryCategories: ["preference"]
-    },
-    {
-      id: "facts",
-      name: "Facts",
-      description: "Objective statements about the world",
-      filingRules: ["Any factual claim or piece of information"],
-      priority: 50,
-      memoryCategories: ["fact"]
-    },
-    {
-      id: "moments",
-      name: "Moments",
-      description: "Significant events or experiences",
-      filingRules: ["A specific event worth remembering"],
-      priority: 60,
-      memoryCategories: ["moment"]
-    }
-  ]
-};
-
-// src/taxonomy/resolver.ts
-var DEFAULT_CATEGORY_ID = "facts";
-function resolveCategory(content, memoryCategory, taxonomy) {
-  const contentLower = content.toLowerCase();
-  const matches = taxonomy.categories.filter(
-    (cat) => cat.memoryCategories.includes(memoryCategory)
-  );
-  if (matches.length === 0) {
-    const fallback = taxonomy.categories.find((c) => c.id === DEFAULT_CATEGORY_ID) ?? taxonomy.categories[0];
-    if (!fallback) {
-      return {
-        categoryId: DEFAULT_CATEGORY_ID,
-        confidence: 0,
-        reason: "Taxonomy is empty; using default category",
-        alternatives: []
-      };
-    }
-    const alternatives2 = taxonomy.categories.filter((c) => c.id !== fallback.id).map((c) => ({
-      categoryId: c.id,
-      reason: c.description
-    }));
-    return {
-      categoryId: fallback.id,
-      confidence: 0.3,
-      reason: `No taxonomy category maps to MemoryCategory "${memoryCategory}"; falling back to "${fallback.name}"`,
-      alternatives: alternatives2
-    };
-  }
-  if (matches.length === 1) {
-    const match = matches[0];
-    const alternatives2 = taxonomy.categories.filter((c) => c.id !== match.id).map((c) => ({
-      categoryId: c.id,
-      reason: c.description
-    }));
-    return {
-      categoryId: match.id,
-      confidence: 1,
-      reason: `Unique match: MemoryCategory "${memoryCategory}" maps to "${match.name}"`,
-      alternatives: alternatives2
-    };
-  }
-  const scored = matches.map((cat) => ({
-    cat,
-    keywordScore: computeKeywordScore(contentLower, cat)
-  }));
-  scored.sort((a, b) => {
-    if (b.keywordScore !== a.keywordScore) return b.keywordScore - a.keywordScore;
-    return a.cat.priority - b.cat.priority;
-  });
-  const best = scored[0];
-  const runnerUp = scored[1];
-  const confidence = best.keywordScore > 0 && (!runnerUp || best.keywordScore > runnerUp.keywordScore) ? 0.9 : 0.7;
-  const alternatives = taxonomy.categories.filter((c) => c.id !== best.cat.id).map((c) => ({
-    categoryId: c.id,
-    reason: c.description
-  }));
-  const reason = best.keywordScore > 0 ? `Filing rules for "${best.cat.name}" matched content keywords (priority ${best.cat.priority})` : `Priority tie-break: "${best.cat.name}" has lowest priority number (${best.cat.priority})`;
-  return {
-    categoryId: best.cat.id,
-    confidence,
-    reason,
-    alternatives
-  };
-}
-function computeKeywordScore(contentLower, cat) {
-  let score = 0;
-  const ruleText = [...cat.filingRules, cat.description].join(" ").toLowerCase();
-  const keywords = ruleText.split(/[^a-z0-9]+/).filter((w) => w.length >= 3);
-  for (const kw of keywords) {
-    if (contentLower.includes(kw)) {
-      score += 1;
-    }
-  }
-  return score;
-}
-
-// src/taxonomy/resolver-doc-generator.ts
-function generateResolverDocument(taxonomy) {
-  const sorted = [...taxonomy.categories].sort((a, b) => {
-    if (a.priority !== b.priority) return a.priority - b.priority;
-    return a.id.localeCompare(b.id);
-  });
-  const lines = [
-    "# Memory Filing Resolver",
-    "",
-    "Given a new piece of knowledge, follow this tree to determine where it belongs.",
-    ""
-  ];
-  let step = 1;
-  for (const cat of sorted) {
-    lines.push(`## Step ${step}: ${cat.description}?`);
-    lines.push("");
-    for (const rule of cat.filingRules) {
-      lines.push(`- ${rule}`);
-    }
-    lines.push("");
-    lines.push(
-      `> YES: File under **${cat.id}/** (priority ${cat.priority})`
-    );
-    lines.push("");
-    step++;
-  }
-  lines.push("## Tie-breaking");
-  lines.push("");
-  lines.push(
-    "If a fact could go in multiple categories, file under the one with the **lowest priority number**."
-  );
-  lines.push("");
-  lines.push(`---`);
-  lines.push(`*Generated from taxonomy v${taxonomy.version}*`);
-  lines.push("");
-  return lines.join("\n");
-}
-
-// src/taxonomy/taxonomy-loader.ts
-import { readFile, mkdir, writeFile } from "fs/promises";
-import path16 from "path";
-var TAXONOMY_DIR = ".taxonomy";
-var TAXONOMY_FILE = "taxonomy.json";
-var MAX_SLUG_LENGTH = 32;
-var SLUG_RE = /^[a-z][a-z0-9-]*$/;
-function validateSlug(slug) {
-  if (slug.length === 0) {
-    throw new Error("Taxonomy category ID must not be empty");
-  }
-  if (slug.length > MAX_SLUG_LENGTH) {
-    throw new Error(
-      `Taxonomy category ID "${slug}" exceeds ${MAX_SLUG_LENGTH} characters`
-    );
-  }
-  if (!SLUG_RE.test(slug)) {
-    throw new Error(
-      `Taxonomy category ID "${slug}" is invalid: must be lowercase letters, digits, and hyphens, starting with a letter`
-    );
-  }
-}
-function validateTaxonomy(taxonomy) {
-  if (typeof taxonomy.version !== "number" || taxonomy.version < 1) {
-    throw new Error("Taxonomy version must be a positive integer");
-  }
-  if (!Array.isArray(taxonomy.categories)) {
-    throw new Error("Taxonomy categories must be an array");
-  }
-  const seenIds = /* @__PURE__ */ new Set();
-  for (const cat of taxonomy.categories) {
-    validateSlug(cat.id);
-    if (seenIds.has(cat.id)) {
-      throw new Error(`Duplicate taxonomy category ID: "${cat.id}"`);
-    }
-    seenIds.add(cat.id);
-    if (typeof cat.name !== "string" || cat.name.trim().length === 0) {
-      throw new Error(`Taxonomy category "${cat.id}" must have a non-empty name`);
-    }
-    if (typeof cat.description !== "string" || cat.description.trim().length === 0) {
-      throw new Error(`Taxonomy category "${cat.id}" must have a non-empty description`);
-    }
-    if (!Array.isArray(cat.filingRules)) {
-      throw new Error(`Taxonomy category "${cat.id}" filingRules must be an array`);
-    }
-    if (typeof cat.priority !== "number" || !Number.isFinite(cat.priority)) {
-      throw new Error(`Taxonomy category "${cat.id}" must have a finite numeric priority`);
-    }
-    if (!Array.isArray(cat.memoryCategories)) {
-      throw new Error(`Taxonomy category "${cat.id}" memoryCategories must be an array`);
-    }
-    if (cat.parentId !== void 0) {
-      if (typeof cat.parentId !== "string") {
-        throw new Error(`Taxonomy category "${cat.id}" parentId must be a string if set`);
-      }
-    }
-  }
-  for (const cat of taxonomy.categories) {
-    if (cat.parentId !== void 0 && !seenIds.has(cat.parentId)) {
-      throw new Error(
-        `Taxonomy category "${cat.id}" references unknown parentId "${cat.parentId}"`
-      );
-    }
-  }
-}
-async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path16.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
-  let raw;
-  try {
-    raw = await readFile(taxonomyPath, "utf-8");
-  } catch (err) {
-    if (err instanceof Error && err.code === "ENOENT") {
-      return structuredClone(DEFAULT_TAXONOMY);
-    }
-    throw err;
-  }
-  const parsed = JSON.parse(raw);
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("taxonomy.json must be a JSON object");
-  }
-  const obj = parsed;
-  const userVersion = typeof obj.version === "number" ? obj.version : DEFAULT_TAXONOMY.version;
-  const userCategories = Array.isArray(obj.categories) ? obj.categories : [];
-  const userIdCounts = /* @__PURE__ */ new Map();
-  for (const cat of userCategories) {
-    const id = typeof cat.id === "string" ? cat.id : String(cat.id);
-    userIdCounts.set(id, (userIdCounts.get(id) ?? 0) + 1);
-  }
-  const duplicateIds = [...userIdCounts.entries()].filter(([, count]) => count > 1).map(([id]) => id);
-  if (duplicateIds.length > 0) {
-    throw new Error(
-      `Duplicate category IDs in taxonomy.json: ${duplicateIds.map((id) => `"${id}"`).join(", ")}`
-    );
-  }
-  const mergedMap = /* @__PURE__ */ new Map();
-  for (const cat of DEFAULT_TAXONOMY.categories) {
-    mergedMap.set(cat.id, { ...cat });
-  }
-  for (const cat of userCategories) {
-    mergedMap.set(cat.id, cat);
-  }
-  const merged = {
-    version: userVersion,
-    categories: [...mergedMap.values()]
-  };
-  validateTaxonomy(merged);
-  return merged;
-}
-async function saveTaxonomy(memoryDir, taxonomy) {
-  validateTaxonomy(taxonomy);
-  const dir = path16.join(memoryDir, TAXONOMY_DIR);
-  await mkdir(dir, { recursive: true });
-  const filePath = path16.join(dir, TAXONOMY_FILE);
-  await writeFile(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
-}
-function getTaxonomyDir(memoryDir) {
-  return path16.join(memoryDir, TAXONOMY_DIR);
-}
-function getTaxonomyFilePath(memoryDir) {
-  return path16.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
-}
-
 // src/enrichment/types.ts
 function defaultEnrichmentPipelineConfig() {
   return {
@@ -5299,22 +5244,22 @@ async function runEnrichmentPipeline(entities, registry, config, log2) {
 }
 
 // src/enrichment/audit.ts
-import { mkdir as mkdir2, readFile as readFile2, appendFile } from "fs/promises";
+import { mkdir, readFile, appendFile } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import path17 from "path";
+import path16 from "path";
 var AUDIT_FILENAME = "enrichment-audit.jsonl";
 function auditFilePath(auditDir) {
-  return path17.join(auditDir, AUDIT_FILENAME);
+  return path16.join(auditDir, AUDIT_FILENAME);
 }
 async function appendAuditEntry(auditDir, entry) {
-  await mkdir2(auditDir, { recursive: true });
+  await mkdir(auditDir, { recursive: true });
   const line = JSON.stringify(entry) + "\n";
   await appendFile(auditFilePath(auditDir), line, "utf-8");
 }
 async function readAuditLog(auditDir, since) {
   const filePath = auditFilePath(auditDir);
   if (!existsSync2(filePath)) return [];
-  const raw = await readFile2(filePath, "utf-8");
+  const raw = await readFile(filePath, "utf-8");
   const entries = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -5331,24 +5276,156 @@ async function readAuditLog(auditDir, since) {
   }
   return entries;
 }
+
+// src/importers/base.ts
+var DEFAULT_IMPORT_BATCH_SIZE = 25;
+var MIN_IMPORT_BATCH_SIZE = 1;
+var MAX_IMPORT_BATCH_SIZE = 500;
+function validateImportBatchSize(value) {
+  if (value === void 0) return DEFAULT_IMPORT_BATCH_SIZE;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `batchSize must be a finite number, received ${String(value)}`
+    );
+  }
+  if (!Number.isInteger(value)) {
+    throw new Error(`batchSize must be an integer, received ${value}`);
+  }
+  if (value < MIN_IMPORT_BATCH_SIZE || value > MAX_IMPORT_BATCH_SIZE) {
+    throw new Error(
+      `batchSize must be between ${MIN_IMPORT_BATCH_SIZE} and ${MAX_IMPORT_BATCH_SIZE}, received ${value}`
+    );
+  }
+  return value;
+}
+function validateImportRateLimit(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `rateLimit must be a finite number (requests per second), received ${String(value)}`
+    );
+  }
+  if (value <= 0) {
+    throw new Error(
+      `rateLimit must be greater than 0 (requests per second), received ${value}`
+    );
+  }
+  return value;
+}
+function importedMemoryToTurn(memory) {
+  const timestamp = typeof memory.sourceTimestamp === "string" && memory.sourceTimestamp.length > 0 ? memory.sourceTimestamp : memory.importedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    role: "user",
+    content: memory.content,
+    timestamp,
+    participantName: memory.sourceLabel,
+    ...memory.sourceId !== void 0 ? { participantId: memory.sourceId } : {}
+  };
+}
+async function runImporter(adapter, input, target, options = {}) {
+  const batchSize = validateImportBatchSize(options.batchSize);
+  validateImportRateLimit(options.rateLimit);
+  const importedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const dryRun = options.dryRun === true;
+  const onProgress = options.onProgress;
+  onProgress?.({ processed: 0, total: 0, phase: "parse" });
+  const parseOptions = {
+    ...options.rateLimit !== void 0 ? { rateLimit: options.rateLimit } : {},
+    ...options.parseOptions ?? {}
+  };
+  const parsed = await adapter.parse(input, parseOptions);
+  onProgress?.({ processed: 0, total: 0, phase: "transform" });
+  const memoriesRaw = await adapter.transform(parsed, options.transformOptions);
+  if (!Array.isArray(memoriesRaw)) {
+    throw new Error(
+      `Importer '${adapter.name}' transform() returned a non-array. Adapters must produce ImportedMemory[].`
+    );
+  }
+  const memories = memoriesRaw.map((memory) => {
+    const sourceLabel = typeof memory.sourceLabel === "string" && memory.sourceLabel.length > 0 ? memory.sourceLabel : adapter.sourceLabel;
+    return {
+      ...memory,
+      sourceLabel,
+      importedAt: memory.importedAt ?? importedAt
+    };
+  });
+  if (dryRun) {
+    onProgress?.({
+      processed: memories.length,
+      total: memories.length,
+      phase: "dry-run"
+    });
+    return {
+      adapter: adapter.name,
+      sourceLabel: adapter.sourceLabel,
+      memoriesPlanned: memories.length,
+      memoriesWritten: 0,
+      batchesProcessed: 0,
+      dryRun: true,
+      importedAt
+    };
+  }
+  let batchesProcessed = 0;
+  let memoriesWritten = 0;
+  for (let i = 0; i < memories.length; i += batchSize) {
+    const batch = memories.slice(i, i + batchSize);
+    const result = await adapter.writeTo(target, batch, options);
+    memoriesWritten += result.memoriesIngested;
+    batchesProcessed += 1;
+    onProgress?.({
+      processed: Math.min(i + batch.length, memories.length),
+      total: memories.length,
+      phase: "write"
+    });
+  }
+  return {
+    adapter: adapter.name,
+    sourceLabel: adapter.sourceLabel,
+    memoriesPlanned: memories.length,
+    memoriesWritten,
+    batchesProcessed,
+    dryRun: false,
+    importedAt
+  };
+}
+async function defaultWriteMemoriesToOrchestrator(target, memories) {
+  if (memories.length === 0) {
+    return { memoriesIngested: 0 };
+  }
+  const turns = memories.map(importedMemoryToTurn);
+  await target.ingestBulkImportBatch(turns);
+  return { memoriesIngested: memories.length };
+}
 export {
+  AccessAuditAdapter,
   BRIEFING_FORMAT_ALLOWED,
   BootstrapEngine,
   CITATION_UNKNOWN,
   CODEX_THREAD_KEY_PREFIX,
   ClaudeCodeMemoryExtensionPublisher,
   CodexMemoryExtensionPublisher,
+  CrossNamespaceBudget,
+  DEFAULT_ANOMALY_DETECTOR_CONFIG,
   DEFAULT_CITATION_FORMAT,
+  DEFAULT_CROSS_NAMESPACE_BUDGET,
   DEFAULT_GRACE_PERIOD_DAYS,
+  DEFAULT_IMPORT_BATCH_SIZE,
   DEFAULT_MAX_BINARY_SIZE_BYTES,
+  DEFAULT_PPR_DAMPING,
+  DEFAULT_PPR_ITERATIONS,
+  DEFAULT_PPR_TOLERANCE,
+  DEFAULT_REASONING_TRACE_BOOST,
   DEFAULT_SCAN_PATTERNS,
+  DEFAULT_SURPRISE_K,
   DEFAULT_TAXONOMY,
+  FILTER_LABELS as DIRECT_ANSWER_FILTER_LABELS,
   EngramAccessHttpServer,
   EngramAccessInputError,
   EngramAccessService,
   EngramMcpServer,
   EnrichmentProviderRegistry,
   ExtractionEngine,
+  FallbackLlmClient,
   FileCalendarSource,
   FilesystemBackend,
   HermesMemoryExtensionPublisher,
@@ -5364,22 +5441,29 @@ export {
   PLUGIN_ID,
   PUBLISHERS,
   QmdClient,
+  RECALL_XRAY_FORMATS,
   REMNIC_CITATION_FORMAT,
   REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT,
   REMNIC_MCP_TOOL_INVENTORY,
   REMNIC_RECALL_DECISION_RULES,
   REMNIC_SEMANTIC_OVERVIEW,
   SENTINEL_FILE,
+  SmartBuffer,
   StorageManager,
   WebSearchProvider,
   appendAuditEntry,
+  applyMemoryWorthFilter,
+  applyReasoningTraceBoost,
   attachCitation,
+  branchNamespaceName,
   briefingFilename,
   buildBriefing,
   buildCitationGuidance,
   buildEntityRecallSection,
   buildExtensionsBlockForConsolidation,
   buildExtensionsFooterForSummary,
+  buildGraphFromMemories,
+  buildMemoryWorthCounterMap,
   buildProcedureMarkdownBody,
   buildProcedureRecallSection,
   checkMarketplaceManifest,
@@ -5387,6 +5471,9 @@ export {
   clearTrainingExportAdapters,
   clearVerdictCache,
   coerceInstallExtension,
+  computeMemoryWorth,
+  computeProcedureStats,
+  computeSurprise,
   convertMemoriesToRecords,
   createBackend,
   createSpace,
@@ -5396,14 +5483,19 @@ export {
   decideSemanticDedup,
   defaultEnrichmentPipelineConfig,
   defaultWorkspaceDir,
+  defaultWriteMemoriesToOrchestrator,
   deleteSpace,
   deriveSessionId,
+  describeCodingScope,
   describeMemoriesDir,
+  detectRecallAnomalies,
   diffVersions,
   discoverMemoryExtensions,
   doctorConnector,
   emptyManifest,
   ensureSentinel,
+  expandTildePath,
+  extractGraphEdges,
   findContradictions,
   findDuplicates,
   focusMatchesEntity,
@@ -5411,6 +5503,7 @@ export {
   formatBatchTranscript,
   formatCitation,
   formatOaiMemCitation,
+  formatProcedureStatsText,
   formatZodError,
   generateContextTree,
   generateMarketplaceManifest,
@@ -5427,18 +5520,27 @@ export {
   getTaxonomyDir,
   getTaxonomyFilePath,
   getTrainingExportAdapter,
+  getVerdictKind,
   getVersion,
   hasBroadGraphIntent,
   hasCitation,
   hostIdForConnector,
+  importedMemoryToTurn,
   inferIntentFromText,
   initLogger,
   installConnector,
   installFromMarketplace,
   intentCompatibilityScore,
+  isDirectAnswerEligible,
+  isDurableVerdict,
+  isEdgeType,
   isImportRole,
+  isNodeType,
+  isReasoningTracePath,
+  isReviewPrompt,
   isTaskInitiationIntent,
   isTrustZoneName,
+  isValidCachedVerdict,
   judgeFactDurability,
   listBulkImportSources,
   listConnectors,
@@ -5453,15 +5555,21 @@ export {
   loadTaxonomy,
   loadTokenStore,
   log,
+  looksLikeProblemSolvingQuery,
   manifestDir,
   manifestPath,
   matchesPatterns,
   materializeForNamespace,
   memoryStoreRequestSchema,
+  memoryWorthOutcomeEligibleCategories,
   mergeSpaces,
   migrateFromEngram,
+  normalizeCachedVerdict,
+  normalizeOriginUrl,
+  normalizeQueryText,
   observeRequestSchema,
   onboard,
+  packReviewContext,
   parseAllCitations,
   parseBriefingFocus,
   parseBriefingWindow,
@@ -5471,17 +5579,25 @@ export {
   parseOaiMemCitation,
   parseProcedureStepsFromBody,
   parseStrictCliDate,
+  parseTouchedFiles,
+  parseXrayBudgetFlag,
+  parseXrayCliOptions,
+  parseXrayFormat,
   performReview,
   planRecallMode,
+  projectNamespaceName,
   promoteSpace,
   publisherFor,
   publisherForConnector,
   pullFromSpace,
   pushToSpace,
+  queryGraph,
+  rankReviewCandidates,
   readAuditLog,
   readManifest,
   recallForActiveMemory,
   recallRequestSchema,
+  recordMemoryOutcome,
   registerBulkImportSource,
   registerPublisher,
   registerTrainingExportAdapter,
@@ -5489,10 +5605,17 @@ export {
   renderBriefingMarkdown,
   renderExtensionsBlock,
   renderExtensionsFooter,
+  renderXray,
+  renderXrayJson,
+  renderXrayMarkdown,
+  renderXrayText,
+  reportBufferSurpriseDistribution,
   resolveBriefingSaveDir,
   resolveCategory,
+  resolveCodingNamespaceOverlay,
   resolveConnectorFromToken,
   resolveExtensionsRoot,
+  resolveGitContext,
   resolvePrincipal,
   resolveRemnicPluginEntry,
   revertToVersion,
@@ -5503,6 +5626,8 @@ export {
   runBulkImportPipeline,
   runCodexMaterialize,
   runEnrichmentPipeline,
+  runGraphRecall,
+  runImporter,
   runPostConsolidationMaterialize,
   sanitizeNoteForCitation,
   sanitizeSessionKeyForFilename,
@@ -5512,11 +5637,14 @@ export {
   saveTokenStore,
   scanForBinaries,
   shareSpace,
+  stableHash,
   stripCitation,
   suggestionSubmitRequestSchema,
   switchSpace,
   syncChanges,
   validateBriefingFormat,
+  validateImportBatchSize,
+  validateImportRateLimit,
   validateImportTurn,
   validateMarketplaceManifest,
   validateRequest,