@remnic/core 1.1.31 → 9.3.516

package/dist/index.js

@@ -1,4 +1,4 @@
-import "./chunk-SKE7JYKA.js";
+import "./chunk-SFXKHM7P.js";
 import {
   PEERS_DIR_NAME,
   PEER_ID_MAX_LENGTH,
@@ -11,7 +11,7 @@ import {
   readPeerProfile,
   writePeer,
   writePeerProfile
-} from "./chunk-4DWOBS2A.js";
+} from "./chunk-PRQJ5ESM.js";
 import {
   EnrichmentProviderRegistry,
   WebSearchProvider,
@@ -19,7 +19,15 @@ import {
   defaultEnrichmentPipelineConfig,
   readAuditLog,
   runEnrichmentPipeline
-} from "./chunk-N2D6GXBM.js";
+} from "./chunk-HINSGUA7.js";
+import {
+  DEFAULT_IMPORT_BATCH_SIZE,
+  defaultWriteMemoriesToOrchestrator,
+  importedMemoryToTurn,
+  runImporter,
+  validateImportBatchSize,
+  validateImportRateLimit
+} from "./chunk-LUDUFZTV.js";
 import {
   MARKETPLACE_MANIFEST_FILENAME,
   MARKETPLACE_SCHEMA_VERSION,
@@ -35,17 +43,17 @@ import {
   saveRegistry,
   validateMarketplaceManifest,
   writeMarketplaceManifest
-} from "./chunk-326G7DJK.js";
+} from "./chunk-RW5DGAGO.js";
 import "./chunk-V5OCT34X.js";
 import {
   executeResolution,
   isValidResolutionVerb
-} from "./chunk-47VWKCAF.js";
+} from "./chunk-XSQ4SGM5.js";
 import {
   ACTIVE_STATUSES,
   judgeContradictionPairs,
   runContradictionScan
-} from "./chunk-DK5LDEQM.js";
+} from "./chunk-YR7XMOWK.js";
 import {
   computePairId,
   isCoolingDown,
@@ -54,7 +62,7 @@ import {
   resolvePair,
   writePair,
   writePairs
-} from "./chunk-APO3DCMU.js";
+} from "./chunk-HLAVGJ62.js";
 import {
   generateToken,
   getAllValidTokens,
@@ -64,7 +72,7 @@ import {
   resolveConnectorFromToken,
   revokeToken,
   saveTokenStore
-} from "./chunk-MSWG7JI6.js";
+} from "./chunk-G56P5RLD.js";
 import {
   runGraphRecall
 } from "./chunk-DGVM5SFL.js";
@@ -79,69 +87,75 @@ import {
   queryGraph
 } from "./chunk-64NJRYU2.js";
 import {
-  clearBulkImportSources,
   clearTrainingExportAdapters,
   convertMemoriesToRecords,
-  formatBatchTranscript,
-  getBulkImportSource,
   getTrainingExportAdapter,
-  isImportRole,
-  listBulkImportSources,
   listTrainingExportAdapters,
-  parseIsoTimestamp,
-  registerBulkImportSource,
   registerTrainingExportAdapter,
-  runBulkImportCliCommand,
-  runBulkImportPipeline,
-  validateImportTurn
-} from "./chunk-TPU5L5EY.js";
-import "./chunk-ICRIXAP2.js";
-import "./chunk-EHRTFRWW.js";
-import "./chunk-S7KDBTWT.js";
-import "./chunk-TZOLIGIG.js";
-import "./chunk-TK4UEOSK.js";
-import "./chunk-XKLD5OK4.js";
-import "./chunk-DOM4GKSW.js";
-import "./chunk-W4L6CZKA.js";
-import "./chunk-3JXBXXM2.js";
-import "./chunk-7OZ53EXP.js";
-import "./chunk-GIF42EW3.js";
-import "./chunk-6H2TESSP.js";
-import "./chunk-66DHUKLO.js";
+  runBulkImportCliCommand
+} from "./chunk-FCOQXV3T.js";
+import "./chunk-7F7Z6MOS.js";
+import "./chunk-MC4FJXPA.js";
+import "./chunk-LQHDIS7L.js";
+import "./chunk-JJEJJ7RK.js";
+import "./chunk-UP6MOYCB.js";
+import "./chunk-XSWKORGM.js";
+import "./chunk-HDDRVXX4.js";
+import "./chunk-4RR6ROTB.js";
 import "./chunk-Z734BLO3.js";
+import "./chunk-OZKVVUJB.js";
+import "./chunk-2DL3OFLD.js";
+import "./chunk-G4IAEX6D.js";
+import "./chunk-2NLLXCJG.js";
+import "./chunk-765K3SAT.js";
 import "./chunk-TKWGAOLV.js";
-import "./chunk-FIT6DMX6.js";
-import "./chunk-TPMQ3G6Z.js";
-import "./chunk-BVF3AGJP.js";
-import "./chunk-2IWUMAES.js";
-import "./chunk-PZIAX57I.js";
-import "./chunk-65PG43EQ.js";
+import "./chunk-UWY7GIVS.js";
+import "./chunk-HOJZMQ4J.js";
+import "./chunk-2NM43EWN.js";
+import "./chunk-LJBOVCQG.js";
+import "./chunk-E62SBGQ3.js";
+import "./chunk-XR6DNK4U.js";
+import "./chunk-RUZOJKNF.js";
+import "./chunk-S7WU3Y3D.js";
 import "./chunk-KJTKLXTH.js";
-import "./chunk-PK7H5L6Y.js";
-import "./chunk-LT3NLYSI.js";
-import "./chunk-TMM4S4IJ.js";
-import "./chunk-MRILGULB.js";
+import {
+  clearBulkImportSources,
+  formatBatchTranscript,
+  getBulkImportSource,
+  listBulkImportSources,
+  registerBulkImportSource,
+  resolveBulkImportContext,
+  runBulkImportPipeline,
+  validateBatchSize
+} from "./chunk-H2NCNXMS.js";
+import {
+  isImportRole,
+  parseIsoTimestamp,
+  validateImportTurn
+} from "./chunk-PU44GBL4.js";
+import "./chunk-YR6GIWWY.js";
+import "./chunk-V2RCP53Q.js";
+import "./chunk-R3PS27B4.js";
 import {
   clearAuthTokenSecretCache,
   isAgentAccessSecretRef,
   resolveAgentAccessAuthToken
-} from "./chunk-MXC3AP5I.js";
-import "./chunk-ZK7I7JYV.js";
+} from "./chunk-TGQ2NTWH.js";
 import {
   parseXrayBudgetFlag,
   parseXrayCliOptions
-} from "./chunk-MT4HVDUZ.js";
+} from "./chunk-PM3QHTFT.js";
 import {
   parseStrictCliDate
 } from "./chunk-AJA46VX5.js";
-import "./chunk-W6AQJ2PY.js";
-import "./chunk-77H5NU3M.js";
+import "./chunk-YNXOKMJP.js";
+import "./chunk-6BR7L222.js";
 import "./chunk-HL4DB7TO.js";
-import "./chunk-ZPKBYX2F.js";
-import "./chunk-3SLRNYNG.js";
-import "./chunk-LIRZNNUP.js";
+import "./chunk-YNDLCWXS.js";
+import "./chunk-AUDJPF4N.js";
+import "./chunk-44442YCH.js";
 import "./chunk-Y4Z4I6WK.js";
-import "./chunk-5HRY2WRF.js";
+import "./chunk-LZ3VEOU5.js";
 import {
   reportBufferSurpriseDistribution
 } from "./chunk-YBPYIAA5.js";
@@ -152,88 +166,84 @@ import {
 import {
   getMemoryForActiveMemory,
   recallForActiveMemory
-} from "./chunk-2WWLHTZY.js";
+} from "./chunk-IC4GELZE.js";
 import "./chunk-6MKAMLQL.js";
 import {
   DEFAULT_TAXONOMY,
   Orchestrator,
-  branchNamespaceName,
   buildProcedureRecallSection,
   decideSemanticDedup,
   defaultWorkspaceDir,
-  describeCodingScope,
   generateResolverDocument,
   getTaxonomyDir,
   getTaxonomyFilePath,
   loadTaxonomy,
-  projectNamespaceName,
-  resolveCodingNamespaceOverlay,
   sanitizeSessionKeyForFilename,
   saveTaxonomy,
   validateSlug,
   validateTaxonomy
-} from "./chunk-QLLBRHAT.js";
-import "./chunk-WNARATI3.js";
+} from "./chunk-YDMVYYD2.js";
+import "./chunk-Y2SXZ5KZ.js";
+import "./chunk-BFBF3XEF.js";
 import {
   migrateFromEngram,
   rollbackFromEngramMigration
-} from "./chunk-KOSORCJG.js";
-import "./chunk-BFBF3XEF.js";
+} from "./chunk-S53PKKWK.js";
 import "./chunk-HHLLAQGZ.js";
 import "./chunk-UWK5OXUJ.js";
-import "./chunk-2PRLKQAH.js";
+import "./chunk-RLV3PQGH.js";
+import "./chunk-TPDBFYEG.js";
+import "./chunk-KCYE2MZM.js";
 import {
   applyLcmSchema,
   ensureLcmStateDir,
   openLcmDatabase
 } from "./chunk-7XYTQGCC.js";
-import "./chunk-34DQE4KF.js";
-import "./chunk-56K5QLHX.js";
+import "./chunk-CO7ZO4TU.js";
+import "./chunk-4HP7HIE3.js";
 import "./chunk-7N4KAIGN.js";
-import "./chunk-TPDBFYEG.js";
-import "./chunk-ZTFCYYEZ.js";
 import "./chunk-TECVW3JP.js";
-import "./chunk-RYED3SPJ.js";
-import "./chunk-A6KTB5R6.js";
-import "./chunk-U4SCL7B7.js";
+import "./chunk-T2PO5MUF.js";
+import "./chunk-IQ3OI2RR.js";
+import "./chunk-DRD2Q7HQ.js";
 import "./chunk-UHGBNIOS.js";
-import "./chunk-FSFEQI74.js";
-import "./chunk-OIGNEXKZ.js";
+import "./chunk-W7L6HXUC.js";
+import "./chunk-K5O2QY6T.js";
 import "./chunk-MDYG7VI7.js";
 import "./chunk-Z5AAYHUC.js";
 import {
   computeTierValueScore,
   decideTierTransition
 } from "./chunk-S75M5ZRK.js";
-import "./chunk-TPB3I2AC.js";
-import "./chunk-H3ME6L6D.js";
+import "./chunk-ECZU5BJH.js";
+import "./chunk-46GJIW5M.js";
 import "./chunk-XJNBEDFE.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
 } from "./chunk-VWT3F4IV.js";
-import "./chunk-JR4ZC3G4.js";
-import "./chunk-K4FLSOR5.js";
+import "./chunk-DLJ4IR6M.js";
+import "./chunk-USYGGIJZ.js";
 import "./chunk-V3RXWQIE.js";
 import "./chunk-5IZL4DCV.js";
 import "./chunk-X7XN6YU4.js";
-import "./chunk-5NPGSAVB.js";
-import "./chunk-C7VW7C3F.js";
+import "./chunk-XEKAG3FM.js";
+import "./chunk-TDKQGLJW.js";
 import {
   buildResponseGuidanceRecallSection,
   shouldRecallResponseGuidance
 } from "./chunk-OZKZ2TRP.js";
+import "./chunk-YDBIWGNI.js";
 import "./chunk-7DHTMOND.js";
-import "./chunk-WPGJYVUH.js";
+import "./chunk-MGVIEM2O.js";
+import "./chunk-YCN4BVDK.js";
 import {
   DEFAULT_REASONING_TRACE_BOOST,
   applyReasoningTraceBoost,
   isReasoningTracePath,
   looksLikeProblemSolvingQuery
 } from "./chunk-ZZTOURJI.js";
-import "./chunk-YDBIWGNI.js";
-import "./chunk-YCN4BVDK.js";
-import "./chunk-D654IBA6.js";
+import "./chunk-XKXKSQU7.js";
 import {
   applyMemoryWorthFilter,
   buildMemoryWorthCounterMap
@@ -245,7 +255,7 @@ import {
   builtInLiveConnectorDefinitions,
   hasEnabledLiveConnector,
   runLiveConnectorsOnce
-} from "./chunk-U3WSW6PZ.js";
+} from "./chunk-QMYXNM4P.js";
 import "./chunk-H63EDPFJ.js";
 import {
   hasBroadGraphIntent,
@@ -268,21 +278,21 @@ import {
 } from "./chunk-C4SQJZAF.js";
 import {
   ExtractionEngine
-} from "./chunk-W3LR522O.js";
+} from "./chunk-KM2A35EO.js";
 import "./chunk-4RA3C3EV.js";
-import "./chunk-WW3QQF4H.js";
+import "./chunk-ROZJACKP.js";
 import "./chunk-54V4BZWP.js";
 import {
   ModelRegistry
-} from "./chunk-QR3C7BKQ.js";
-import "./chunk-EDTHC6UD.js";
+} from "./chunk-XZ4WBBB5.js";
+import "./chunk-77NAFXUD.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
 } from "./chunk-DB5A3NHS.js";
 import {
   buildEntityRecallSection
-} from "./chunk-43PJZYGL.js";
+} from "./chunk-FPGE5NVO.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -305,7 +315,7 @@ import {
 import {
   buildExtensionsFooterForSummary,
   loadDaySummaryPrompt
-} from "./chunk-3IQ2TR4N.js";
+} from "./chunk-WLEB7WCG.js";
 import "./chunk-VEWZZM3H.js";
 import {
   resolveCategory
@@ -314,72 +324,77 @@ import {
   FILTER_LABELS,
   isDirectAnswerEligible
 } from "./chunk-Y4FHOFJ2.js";
-import "./chunk-NMZY542O.js";
+import "./chunk-6URPAY2D.js";
 import {
   CODEX_THREAD_KEY_PREFIX
 } from "./chunk-3PG3H5TD.js";
-import "./chunk-2NMMFZ5T.js";
+import "./chunk-OD4FM2U7.js";
 import {
   buildExtensionsBlockForConsolidation
-} from "./chunk-XSZEP4SF.js";
+} from "./chunk-6XSPNR6L.js";
 import {
   runCodexMaterialize,
   runPostConsolidationMaterialize
-} from "./chunk-4KGVTPGD.js";
+} from "./chunk-6F6BXB7A.js";
 import {
   MATERIALIZE_VERSION,
   SENTINEL_FILE,
   describeMemoriesDir,
   ensureSentinel,
   materializeForNamespace
-} from "./chunk-RHY3HH7P.js";
+} from "./chunk-JFEKNTX7.js";
 import {
   REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT,
   discoverMemoryExtensions,
   renderExtensionsBlock,
   renderExtensionsFooter,
   resolveExtensionsRoot
-} from "./chunk-EJI5XIBB.js";
+} from "./chunk-JLNBQWZ2.js";
+import "./chunk-HPWVAEET.js";
 import "./chunk-2PRQG7PV.js";
-import "./chunk-LUDTDZLK.js";
-import "./chunk-JA3AK3PT.js";
-import "./chunk-PYXS46O7.js";
-import "./chunk-3QKK7QOS.js";
+import "./chunk-XNLXAWHX.js";
+import "./chunk-3BP57I6J.js";
+import "./chunk-TERNBNJB.js";
 import "./chunk-W4RVMTHR.js";
-import "./chunk-SAZS2QZB.js";
-import "./chunk-CULXMQJH.js";
-import "./chunk-5375UYTQ.js";
+import "./chunk-23UORJ4S.js";
+import "./chunk-XPXEJRUB.js";
+import "./chunk-A6D7A2FW.js";
 import "./chunk-FF4KLI5W.js";
-import "./chunk-EABGC2TL.js";
-import "./chunk-RR2PKP3I.js";
-import "./chunk-575RMLWN.js";
-import "./chunk-I5GLV3VE.js";
-import "./chunk-NJ3MJQZX.js";
-import {
-  OramaBackend
-} from "./chunk-XVVIG67A.js";
-import "./chunk-PIRJPV5T.js";
-import "./chunk-RXDLTSWT.js";
+import "./chunk-4426WSWL.js";
+import "./chunk-A2Z6UCWT.js";
+import "./chunk-KXULCVOC.js";
+import "./chunk-SML26KED.js";
 import {
   LanceDbBackend
-} from "./chunk-3VAL7ZL2.js";
+} from "./chunk-FUC4LZMD.js";
 import {
   MeilisearchBackend
-} from "./chunk-TMQLARTH.js";
-import "./chunk-MJFNCJXV.js";
-import "./chunk-CYFQJMUV.js";
+} from "./chunk-FK556DDH.js";
+import "./chunk-2I5JGH3M.js";
+import {
+  OramaBackend
+} from "./chunk-QVJ4NWL2.js";
+import "./chunk-JNANKJLN.js";
+import "./chunk-Q4CAQGKQ.js";
+import "./chunk-ONPLNAPX.js";
+import "./chunk-CINZGPSJ.js";
+import {
+  ALL_CATEGORY_DIRS,
+  ALL_CATEGORY_KEYS,
+  getCategoryDir
+} from "./chunk-CHBI22MI.js";
+import "./chunk-ZFXCQPNO.js";
+import "./chunk-KIB7SDIJ.js";
+import "./chunk-ORFGK3XI.js";
+import "./chunk-HENLZHIT.js";
 import "./chunk-7DTASS5T.js";
-import "./chunk-FJ43PRLT.js";
-import "./chunk-LLQ2LLWF.js";
-import "./chunk-YRMVARQP.js";
+import "./chunk-KFY3SGN7.js";
 import {
   QmdClient
-} from "./chunk-3TNBOMQT.js";
+} from "./chunk-PCI747N2.js";
 import {
-  LEGACY_PLUGIN_ID,
-  PLUGIN_ID,
-  resolveRemnicPluginEntry
-} from "./chunk-U66YHYC7.js";
+  resolvePluginEntry
+} from "./chunk-CMTINOFS.js";
 import {
   DEFAULT_POLL_INTERVAL_MS,
   GOOGLE_DRIVE_CONNECTOR_ID,
@@ -394,21 +409,21 @@ import {
   defaultGoogleDriveClientFactory,
   validateGoogleDriveConfig,
   validateNotionConfig
-} from "./chunk-HXXBL2KD.js";
+} from "./chunk-BECQDWBA.js";
 import {
   CONNECTOR_ID_PATTERN,
   isValidConnectorId,
   listConnectorStates,
   readConnectorState,
   writeConnectorState
-} from "./chunk-LPMVBPA3.js";
+} from "./chunk-CWWMTTQE.js";
 import "./chunk-JXS5PDQ7.js";
-import "./chunk-HMDCOMYU.js";
-import "./chunk-7SEAZFFB.js";
-import "./chunk-D46YSIYX.js";
+import "./chunk-SKGV326D.js";
+import "./chunk-BEUDU7Y4.js";
+import "./chunk-G3Z3QEF5.js";
 import "./chunk-AJU4PJGY.js";
-import "./chunk-C6QPK5GG.js";
-import "./chunk-2KI4QFHU.js";
+import "./chunk-FZZ2QTJI.js";
+import "./chunk-LMDRGRJ2.js";
 import {
   CONNECTORS_OUTPUT_FORMATS,
   parseConnectorsFormat,
@@ -418,17 +433,17 @@ import {
   renderConnectorsList,
   renderConnectorsRunResult,
   runConnectorPollOnce
-} from "./chunk-OZHRDTDX.js";
+} from "./chunk-OKTXM5H4.js";
 import "./chunk-3UXOZBHV.js";
 import "./chunk-KVE7R4CG.js";
 import "./chunk-4WMCPJWX.js";
 import {
   SmartBuffer
-} from "./chunk-5RGLBDQF.js";
+} from "./chunk-EVZFIAPG.js";
 import {
   FallbackLlmClient
-} from "./chunk-DINWEURR.js";
-import "./chunk-FLTNHQK6.js";
+} from "./chunk-CSKLPDN6.js";
+import "./chunk-B5XMS73R.js";
 import "./chunk-7SI52C65.js";
 import "./chunk-L2EXJQJP.js";
 import "./chunk-UZB5KHKX.js";
@@ -439,33 +454,33 @@ import {
   isOpenaiApiKeyDisabled,
   parseConfig,
   resolveEnvVars
-} from "./chunk-MZH6EHNR.js";
+} from "./chunk-7H6CFEBJ.js";
 import {
   coerceInstallExtension
 } from "./chunk-PHK3HARR.js";
 import "./chunk-Z5LAYHGJ.js";
 import "./chunk-6HZ6AO2P.js";
-import "./chunk-JWPLJLDU.js";
+import "./chunk-KD3QD3A5.js";
 import {
   BootstrapEngine
-} from "./chunk-N53K2EXC.js";
-import "./chunk-XYIK4LF6.js";
-import "./chunk-NZL6GGQE.js";
+} from "./chunk-6VF75M3X.js";
+import "./chunk-H3FZVNRN.js";
+import "./chunk-HQ6NIBL6.js";
 import "./chunk-PVGDJXVK.js";
-import "./chunk-NGAVDO7E.js";
+import "./chunk-OADWQ5CR.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-YU5KIWYQ.js";
+} from "./chunk-HC6EKOID.js";
 import "./chunk-SEDEKFYQ.js";
-import "./chunk-6FC5EGNV.js";
-import "./chunk-3Y4P7RXM.js";
-import "./chunk-6LVVDPJ4.js";
-import "./chunk-7MNMYOFP.js";
-import "./chunk-FKFMOY3N.js";
-import "./chunk-FAJ7FZYM.js";
+import "./chunk-JBPKEARU.js";
+import "./chunk-TMSXWOBZ.js";
+import "./chunk-J64TK33U.js";
+import "./chunk-RSUYKGGZ.js";
+import "./chunk-42NQ7AVG.js";
+import "./chunk-7RXCMVFQ.js";
 import {
   EngramMcpServer
-} from "./chunk-3ZLVGM76.js";
+} from "./chunk-TTGZV5R3.js";
 import {
   REMNIC_CHATGPT_MEMORY_INSPECTOR_CANONICAL_TOOL,
   REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE,
@@ -474,24 +489,24 @@ import {
   REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI,
   buildChatGptMemoryInspectorActionRequest,
   buildChatGptMemoryInspectorResult
-} from "./chunk-C5BCH4ZS.js";
+} from "./chunk-EAZGEEG2.js";
 import {
   buildCitationGuidance,
   formatOaiMemCitation,
   parseOaiMemCitation,
   sanitizeNoteForCitation
-} from "./chunk-IQT3XTKW.js";
+} from "./chunk-D24OXEPB.js";
 import {
   EngramAccessInputError,
   EngramAccessService,
   computeProcedureStats,
   formatProcedureStatsText
-} from "./chunk-ZAVUCJ4H.js";
-import "./chunk-ZKSK55RC.js";
-import "./chunk-WELDCG6C.js";
+} from "./chunk-5V456VRV.js";
+import "./chunk-ETUPBUHB.js";
+import "./chunk-L227SKTB.js";
 import {
   importCapsule
-} from "./chunk-ZYVPLJ4T.js";
+} from "./chunk-DHGSZ3UD.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-H7XKCNR6.js";
 import {
@@ -501,18 +516,22 @@ import {
   renderXrayJson,
   renderXrayMarkdown,
   renderXrayText
-} from "./chunk-FBYESMQ2.js";
+} from "./chunk-3C5RPJAX.js";
 import "./chunk-SOBJ6NEY.js";
 import {
+  branchNamespaceName,
+  describeCodingScope,
   normalizeOriginUrl,
+  projectNamespaceName,
+  resolveCodingNamespaceOverlay,
   resolveGitContext,
   stableHash
-} from "./chunk-FDU6HUUL.js";
+} from "./chunk-EDQVAMQI.js";
 import {
   isTrustZoneName
-} from "./chunk-QDZ2RLEC.js";
-import "./chunk-MGKYQQYF.js";
-import "./chunk-GL6I6MEQ.js";
+} from "./chunk-472U7RDF.js";
+import "./chunk-7Q3RCKAQ.js";
+import "./chunk-WSGF57U2.js";
 import {
   isLcmMessagePartKind,
   normalizeExplicitParts,
@@ -522,30 +541,29 @@ import {
   parseOpenClawMessageParts,
   parsePiMessageParts,
   partsFromRenderedText
-} from "./chunk-3APJ5EVB.js";
-import "./chunk-5UM2VJ6D.js";
-import "./chunk-76FLAAUC.js";
+} from "./chunk-XKIQZXUB.js";
+import "./chunk-UEY3VB6W.js";
+import "./chunk-2AN2L4NL.js";
 import {
   memoryWorthOutcomeEligibleCategories,
   recordMemoryOutcome
 } from "./chunk-EIR5VLIH.js";
-import "./chunk-PCUKNJAZ.js";
-import "./chunk-RRF5UOBJ.js";
-import "./chunk-NBNN5GOB.js";
+import "./chunk-JKV57BTN.js";
+import "./chunk-EI6V5UXY.js";
+import "./chunk-QY7YA7OL.js";
 import "./chunk-NNVTUXEB.js";
 import {
   buildProcedureMarkdownBody,
   parseProcedureStepsFromBody
 } from "./chunk-QDW3E4RD.js";
-import "./chunk-25MQ7IHJ.js";
+import "./chunk-EUML3N6B.js";
 import {
   CrossNamespaceBudget,
   DEFAULT_CROSS_NAMESPACE_BUDGET
-} from "./chunk-GDFS42HT.js";
-import "./chunk-U3PN77QT.js";
-import "./chunk-RK2Y4XOM.js";
+} from "./chunk-CHCA44C3.js";
+import "./chunk-4JRRISLU.js";
 import "./chunk-2LSZVONP.js";
-import "./chunk-WIICJPET.js";
+import "./chunk-DEUNUKTD.js";
 import {
   BRIEFING_FORMAT_ALLOWED,
   FileCalendarSource,
@@ -558,12 +576,12 @@ import {
   renderBriefingMarkdown,
   resolveBriefingSaveDir,
   validateBriefingFormat
-} from "./chunk-SIC6U3GZ.js";
+} from "./chunk-YHV3KRKS.js";
 import {
   StorageManager,
   parseEntityFile,
   serializeEntityFile
-} from "./chunk-VBJ7V5SK.js";
+} from "./chunk-UIPDNLXA.js";
 import "./chunk-5UZXUTVO.js";
 import {
   CITATION_UNKNOWN,
@@ -575,19 +593,19 @@ import {
   parseAllCitations,
   parseCitation,
   stripCitation
-} from "./chunk-NN2DKE4T.js";
+} from "./chunk-4H5ZJHEN.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-Q7P4WJDP.js";
+} from "./chunk-M5T4Q2ZU.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
-import "./chunk-3KW65B36.js";
+import "./chunk-KILOTVIF.js";
 import "./chunk-3HPAPHUK.js";
-import "./chunk-PFV5C235.js";
+import "./chunk-CPPS65WS.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
@@ -599,27 +617,28 @@ import {
   getVersion,
   listVersions,
   revertToVersion
-} from "./chunk-FAAFWE4G.js";
-import {
-  expandTildePath
-} from "./chunk-QRNI5JBH.js";
+} from "./chunk-ALEPI75L.js";
 import "./chunk-ZY2MNJR6.js";
-import "./chunk-MY6TPVXW.js";
+import "./chunk-LMPHTYJC.js";
 import "./chunk-DT5TVLJE.js";
 import {
   resolvePrincipal
-} from "./chunk-UWVJF25J.js";
+} from "./chunk-HWVTS5NO.js";
+import "./chunk-U3PN77QT.js";
 import "./chunk-4DJQYKMN.js";
+import {
+  expandTildePath
+} from "./chunk-EYIEWJNI.js";
 import {
   readEnvVar,
   resolveHomeDir
-} from "./chunk-XIG5PDM7.js";
+} from "./chunk-JUC24CTX.js";
 import "./chunk-TBBDFYXW.js";
 import {
   initLogger,
   log
 } from "./chunk-2ODBA7MQ.js";
-import "./chunk-DGXUHMOV.js";
+import "./chunk-A2IYSXDQ.js";
 import "./chunk-LPSF4OQH.js";
 import {
   AccessAuditAdapter
@@ -630,7 +649,7 @@ import {
   normalizeQueryText
 } from "./chunk-RFYAYKTD.js";
 import "./chunk-LBLXEFWK.js";
-import "./chunk-XKECPATV.js";
+import "./chunk-VFUEZZBS.js";
 import {
   formatZodError,
   memoryStoreRequestSchema,
@@ -638,13 +657,13 @@ import {
   recallRequestSchema,
   suggestionSubmitRequestSchema,
   validateRequest
-} from "./chunk-YROHKYBY.js";
-import "./chunk-QA2ZAPBU.js";
+} from "./chunk-5UHVGNZD.js";
+import "./chunk-IPLYGWQF.js";
+import "./chunk-J4EB7DNW.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
-import "./chunk-KNKUID7G.js";
-import "./chunk-J4EB7DNW.js";
+import "./chunk-X7Y7WX73.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
@@ -677,13 +696,13 @@ import {
   summarizeOfflineSyncPendingChanges,
   summarizeOfflineSyncPendingFiles,
   writeOfflineSyncState
-} from "./chunk-U7EJOMFC.js";
-import "./chunk-I6K5FBRQ.js";
+} from "./chunk-ZEY4KYRQ.js";
+import "./chunk-UI3NYK34.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot
-} from "./chunk-AGZQD76C.js";
-import "./chunk-MXFBBHJU.js";
+} from "./chunk-GCGJW34D.js";
+import "./chunk-KJMYHC7K.js";
 import "./chunk-A6XUJE5D.js";
 import {
   parseFlexibleIsoTimestamp,
@@ -814,13 +833,80 @@ function splitDiffGitPaths(rest) {
 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");
+    const decoded = decodeGitCQuotedPath(s.slice(1, -1));
+    if (decoded === null) {
+      return raw;
+    }
+    s = decoded;
   }
   s = s.replace(/\\/g, "/");
   if (s.startsWith("a/") || s.startsWith("b/")) s = s.slice(2);
   return s;
 }
+function decodeGitCQuotedPath(value) {
+  const bytes = [];
+  const encoder = new TextEncoder();
+  const appendText = (text) => {
+    bytes.push(...encoder.encode(text));
+  };
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char !== "\\") {
+      appendText(char);
+      continue;
+    }
+    if (index + 1 >= value.length) {
+      appendText("\\");
+      continue;
+    }
+    const next = value[index + 1];
+    if (next >= "0" && next <= "7") {
+      let octal = next;
+      let cursor = index + 2;
+      while (cursor < value.length && octal.length < 3) {
+        const digit = value[cursor];
+        if (digit < "0" || digit > "7") break;
+        octal += digit;
+        cursor += 1;
+      }
+      bytes.push(Number.parseInt(octal, 8));
+      index = cursor - 1;
+      continue;
+    }
+    const escaped = cEscapeValue(next);
+    if (escaped !== null) {
+      appendText(escaped);
+      index += 1;
+      continue;
+    }
+    appendText(`\\${next}`);
+    index += 1;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(bytes));
+  } catch {
+    return null;
+  }
+}
+function cEscapeValue(value) {
+  switch (value) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    case "b":
+      return "\b";
+    case "f":
+      return "\f";
+    case "\\":
+    case '"':
+      return value;
+    default:
+      return null;
+  }
+}
 var BOOST_PER_MATCH = 0.5;
 var MAX_BOOST = 1;
 function countPathHits(entityRefs, touchedFiles) {
@@ -891,17 +977,28 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = basePath;
+    this.basePath = path.resolve(basePath);
+  }
+  resolveRemotePath(remotePath) {
+    if (path.isAbsolute(remotePath)) {
+      throw new Error(`FilesystemBackend remotePath must be relative: ${JSON.stringify(remotePath)}`);
+    }
+    const resolved = path.resolve(this.basePath, remotePath);
+    const relative = path.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+      throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
+    }
+    return resolved;
   }
   async upload(localPath, remotePath) {
-    const dest = path.join(this.basePath, remotePath);
+    const dest = this.resolveRemotePath(remotePath);
     const destDir = path.dirname(dest);
     await fsp.mkdir(destDir, { recursive: true });
     await fsp.copyFile(localPath, dest);
     return dest;
   }
   async exists(remotePath) {
-    const dest = path.join(this.basePath, remotePath);
+    const dest = this.resolveRemotePath(remotePath);
     try {
       await fsp.access(dest, fs.constants.F_OK);
       return true;
@@ -910,7 +1007,7 @@ var FilesystemBackend = class {
     }
   }
   async delete(remotePath) {
-    const dest = path.join(this.basePath, remotePath);
+    const dest = this.resolveRemotePath(remotePath);
     try {
       await fsp.unlink(dest);
     } catch (err) {
@@ -951,6 +1048,7 @@ function createBackend(cfg) {
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
 import path2 from "path";
+import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
   for (const pattern of patterns) {
@@ -964,7 +1062,7 @@ function matchesPatterns(filename, patterns) {
   return false;
 }
 async function scanForBinaries(memoryDir, config, manifest) {
-  const tracked = new Set(manifest.assets.map((a) => a.originalPath));
+  const tracked = new Map(manifest.assets.map((a) => [a.originalPath, a]));
   const results = [];
   async function walk(dir) {
     let entries;
@@ -983,11 +1081,22 @@ async function scanForBinaries(memoryDir, config, manifest) {
       }
       if (!entry.isFile()) continue;
       if (!matchesPatterns(entry.name, config.scanPatterns)) continue;
-      if (tracked.has(relativePath)) continue;
       try {
         const stat = await fsp2.stat(fullPath);
         if (stat.size > config.maxBinarySizeBytes) continue;
         if (stat.size === 0) continue;
+        const existing = tracked.get(relativePath);
+        if (existing) {
+          if (existing.sizeBytes !== stat.size) {
+            results.push(relativePath);
+            continue;
+          }
+          const contentHash = await hashFile(fullPath);
+          if (existing.contentHash !== contentHash) {
+            results.push(relativePath);
+          }
+          continue;
+        }
       } catch {
         continue;
       }
@@ -997,11 +1106,15 @@ async function scanForBinaries(memoryDir, config, manifest) {
   await walk(memoryDir);
   return results;
 }
+async function hashFile(filePath) {
+  const content = await fsp2.readFile(filePath);
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
 import path3 from "path";
-import crypto from "crypto";
+import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
@@ -1031,7 +1144,7 @@ async function writeManifest(memoryDir, manifest) {
   const dir = manifestDir(memoryDir);
   await fsp3.mkdir(dir, { recursive: true });
   const dest = manifestPath(memoryDir);
-  const tmpSuffix = crypto.randomBytes(8).toString("hex");
+  const tmpSuffix = crypto2.randomBytes(8).toString("hex");
   const tmpPath = `${dest}.${tmpSuffix}.tmp`;
   const content = JSON.stringify(manifest, null, 2) + "\n";
   await fsp3.writeFile(tmpPath, content, "utf-8");
@@ -1052,10 +1165,10 @@ function emptyManifest() {
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
 import path4 from "path";
-import crypto2 from "crypto";
-async function hashFile(filePath) {
+import crypto3 from "crypto";
+async function hashFile2(filePath) {
   const content = await fsp4.readFile(filePath);
-  return crypto2.createHash("sha256").update(content).digest("hex");
+  return crypto3.createHash("sha256").update(content).digest("hex");
 }
 function guessMimeType(ext) {
   const map = {
@@ -1073,6 +1186,11 @@ function guessMimeType(ext) {
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function validateBinaryLifecycleConfig(config) {
+  if (typeof config.gracePeriodDays !== "number" || !Number.isFinite(config.gracePeriodDays) || !Number.isInteger(config.gracePeriodDays) || config.gracePeriodDays < 0) {
+    throw new Error("binary lifecycle gracePeriodDays must be a finite non-negative integer");
+  }
+}
 async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
@@ -1080,7 +1198,7 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
     const fullPath = path4.join(memoryDir, relPath);
     try {
       const stat = await fsp4.stat(fullPath);
-      const contentHash = await hashFile(fullPath);
+      const contentHash = await hashFile2(fullPath);
       const ext = path4.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = relPath;
@@ -1097,7 +1215,13 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
         mirroredAt: (/* @__PURE__ */ new Date()).toISOString(),
         status: "mirrored"
       };
-      assets.push(record);
+      if (!dryRun) {
+        const existingIndex = assets.findIndex((asset) => asset.originalPath === relPath);
+        if (existingIndex >= 0) {
+          assets.splice(existingIndex, 1);
+        }
+        assets.push(record);
+      }
       mirrored++;
       log2.info(`[binary-lifecycle] mirrored: ${relPath} (${stat.size} bytes)${dryRun ? " [dry-run]" : ""}`);
     } catch (err) {
@@ -1146,14 +1270,18 @@ async function stageRedirect(memoryDir, assets, log2, dryRun) {
       }
     }
     if (matchCount > 0 && writeFailCount === 0) {
-      asset.status = "redirected";
-      asset.redirectedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (!dryRun) {
+        asset.status = "redirected";
+        asset.redirectedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
       redirected++;
       log2.info(`[binary-lifecycle] redirected: ${asset.originalPath}${dryRun ? " [dry-run]" : ""}`);
     } else if (matchCount > 0 && writeFailCount > 0) {
-      asset.status = "error";
+      if (!dryRun) {
+        asset.status = "error";
+      }
       log2.warn(
-        `[binary-lifecycle] redirect partial failure for ${asset.originalPath}: ${matchCount} match(es), ${writeFailCount} write failure(s) \u2014 status set to error`
+        `[binary-lifecycle] redirect partial failure for ${asset.originalPath}: ${matchCount} match(es), ${writeFailCount} write failure(s)${dryRun ? "" : " \u2014 status set to error"}`
       );
     }
   }
@@ -1175,11 +1303,18 @@ async function stageClean(memoryDir, assets, gracePeriodDays, log2, dryRun, forc
     }
     const fullPath = path4.join(memoryDir, asset.originalPath);
     try {
+      const currentHash = await hashFile2(fullPath);
+      if (currentHash !== asset.contentHash) {
+        const msg = `clean blocked for ${asset.originalPath}: local content hash does not match manifest`;
+        log2.warn(`[binary-lifecycle] ${msg}`);
+        errors.push(msg);
+        continue;
+      }
       if (!dryRun) {
         await fsp4.unlink(fullPath);
+        asset.status = "cleaned";
+        asset.cleanedAt = (/* @__PURE__ */ new Date()).toISOString();
       }
-      asset.status = "cleaned";
-      asset.cleanedAt = (/* @__PURE__ */ new Date()).toISOString();
       cleaned++;
       log2.info(`[binary-lifecycle] cleaned: ${asset.originalPath}${dryRun ? " [dry-run]" : ""}`);
     } catch (err) {
@@ -1219,8 +1354,19 @@ async function findMarkdownFiles(dir) {
   return results;
 }
 async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts) {
+  validateBinaryLifecycleConfig(config);
   const dryRun = opts?.dryRun ?? false;
   const forceClean = opts?.forceClean ?? false;
+  if (config.enabled === false) {
+    return {
+      scanned: 0,
+      mirrored: 0,
+      redirected: 0,
+      cleaned: 0,
+      errors: [],
+      dryRun
+    };
+  }
   const manifest = await readManifest(memoryDir);
   const newPaths = await scanForBinaries(memoryDir, config, manifest);
   const scanned = newPaths.length;
@@ -1262,38 +1408,8 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs2 from "fs";
-import path6 from "path";
-
-// src/utils/category-dir.ts
 import path5 from "path";
-var CATEGORY_DIR_MAP = {
-  correction: "corrections",
-  question: "questions",
-  preference: "preferences",
-  decision: "decisions",
-  moment: "moments",
-  commitment: "commitments",
-  principle: "principles",
-  rule: "rules",
-  skill: "skills",
-  relationship: "relationships",
-  procedure: "procedures",
-  reasoning_trace: "reasoning-traces"
-};
-var ALL_CATEGORY_DIRS = [
-  "facts",
-  ...Object.values(CATEGORY_DIR_MAP)
-];
-var ALL_CATEGORY_KEYS = [
-  "fact",
-  ...Object.keys(CATEGORY_DIR_MAP)
-];
-function getCategoryDir(memoryDir, category) {
-  const dir = CATEGORY_DIR_MAP[category];
-  return dir ? path5.join(memoryDir, dir) : path5.join(memoryDir, "facts");
-}
-
-// src/projection/index.ts
+var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
   const {
@@ -1307,13 +1423,20 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  fs2.mkdirSync(outputDir, { recursive: true });
-  const allCategories = filterCategories ?? ALL_CATEGORY_KEYS.filter((c) => c !== "question");
+  const resolvedMemoryDir = path5.resolve(memoryDir);
+  const resolvedOutputDir = path5.resolve(outputDir);
+  const requestedCategories = validateProjectionCategories(filterCategories);
+  const realMemoryDir = fs2.realpathSync(resolvedMemoryDir);
+  assertNotSymlink(resolvedOutputDir, "context tree outputDir");
+  fs2.mkdirSync(resolvedOutputDir, { recursive: true });
+  const realOutputDir = fs2.realpathSync(resolvedOutputDir);
+  const allCategories = (requestedCategories ?? ALL_CATEGORY_KEYS).filter((c) => c !== "question");
   for (const category of allCategories) {
     const categoryDir = getCategoryDir(memoryDir, category);
     if (!fs2.existsSync(categoryDir)) continue;
+    assertSafeInputRoot(realMemoryDir, categoryDir, `${category} memory category`);
     categoryCounts[category] = 0;
-    const files = walkR(categoryDir);
+    const files = walkR(categoryDir, realMemoryDir);
     let count = 0;
     for (const filePath of files) {
       if (count >= maxPerCategory) {
@@ -1331,19 +1454,19 @@ async function generateContextTree(options) {
         nodesSkipped++;
         continue;
       }
-      const outputPath = path6.join(outputDir, node.path);
-      fs2.mkdirSync(path6.dirname(outputPath), { recursive: true });
-      fs2.writeFileSync(outputPath, node.content);
+      const outputPath = resolveContainedOutputPath(realOutputDir, node.path);
+      writeProjectedContent(realOutputDir, outputPath, node.content);
       nodesGenerated++;
       categoryCounts[category] = (categoryCounts[category] ?? 0) + 1;
       count++;
     }
   }
   if (includeEntities) {
-    const entitiesDir = path6.join(memoryDir, "entities");
+    const entitiesDir = path5.join(memoryDir, "entities");
     if (fs2.existsSync(entitiesDir)) {
+      assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
-      const entityFiles = walkR(entitiesDir);
+      const entityFiles = walkR(entitiesDir, realMemoryDir);
       let count = 0;
       for (const filePath of entityFiles) {
         if (count >= maxPerCategory) {
@@ -1351,22 +1474,23 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs2.readFileSync(filePath, "utf8");
-        const fileName = path6.basename(filePath, ".md");
+        const fileName = path5.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
-        const outputPath = path6.join(outputDir, "entities", `${fileName}.md`);
-        fs2.mkdirSync(path6.dirname(outputPath), { recursive: true });
-        fs2.writeFileSync(outputPath, node.content);
+        const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
+        writeProjectedContent(realOutputDir, outputPath, node.content);
         nodesGenerated++;
         categoryCounts["entity"] = (categoryCounts["entity"] ?? 0) + 1;
         count++;
       }
     }
   }
-  if (includeQuestions) {
-    const questionsDir = path6.join(memoryDir, "questions");
+  const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
+  if (shouldIncludeQuestions) {
+    const questionsDir = path5.join(memoryDir, "questions");
     if (fs2.existsSync(questionsDir)) {
+      assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
-      const qFiles = walkR(questionsDir);
+      const qFiles = walkR(questionsDir, realMemoryDir);
       let count = 0;
       for (const filePath of qFiles) {
         if (count >= maxPerCategory) {
@@ -1384,17 +1508,16 @@ async function generateContextTree(options) {
           nodesSkipped++;
           continue;
         }
-        const outputPath = path6.join(outputDir, node.path);
-        fs2.mkdirSync(path6.dirname(outputPath), { recursive: true });
-        fs2.writeFileSync(outputPath, node.content);
+        const outputPath = resolveContainedOutputPath(realOutputDir, node.path);
+        writeProjectedContent(realOutputDir, outputPath, node.content);
         nodesGenerated++;
         categoryCounts["question"] = (categoryCounts["question"] ?? 0) + 1;
         count++;
       }
     }
   }
-  const index = generateIndex(categoryCounts, outputDir);
-  fs2.writeFileSync(path6.join(outputDir, "INDEX.md"), index);
+  const index = generateIndex(categoryCounts, resolvedOutputDir);
+  writeProjectedContent(realOutputDir, resolveContainedOutputPath(realOutputDir, "INDEX.md"), index);
   return {
     nodesGenerated,
     nodesSkipped,
@@ -1403,14 +1526,134 @@ async function generateContextTree(options) {
     outputDir
   };
 }
-function walkR(dir) {
+function isPathInside(root, candidate) {
+  const relative = path5.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function assertNotSymlink(targetPath, label) {
+  try {
+    if (fs2.lstatSync(targetPath).isSymbolicLink()) {
+      throw new Error(`${label} must not be a symlink: ${targetPath}`);
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+}
+function assertSafeInputRoot(realMemoryDir, targetPath, label) {
+  const stat = fs2.lstatSync(targetPath);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`${label} must not be a symlink: ${targetPath}`);
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(`${label} must be a directory: ${targetPath}`);
+  }
+  const realTarget = fs2.realpathSync(targetPath);
+  if (!isPathInside(realMemoryDir, realTarget)) {
+    throw new Error(`${label} escapes memoryDir: ${targetPath}`);
+  }
+}
+function assertSafeOutputTarget(realOutputDir, outputPath) {
+  let current = realOutputDir;
+  const relative = path5.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
+    throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
+  }
+  for (const segment of relative.split(path5.sep).filter(Boolean)) {
+    current = path5.join(current, segment);
+    try {
+      const stat = fs2.lstatSync(current);
+      if (stat.isSymbolicLink()) {
+        throw new Error(`context tree output path contains symlink: ${current}`);
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        break;
+      }
+      throw err;
+    }
+  }
+}
+function validateProjectionCategories(categories) {
+  if (categories === void 0) {
+    return void 0;
+  }
+  const validated = [];
+  for (const category of categories) {
+    if (typeof category !== "string" || !VALID_PROJECTION_CATEGORIES.has(category)) {
+      throw new Error(`invalid context tree category: ${String(category)}`);
+    }
+    if (!validated.includes(category)) {
+      validated.push(category);
+    }
+  }
+  return validated;
+}
+function resolveContainedOutputPath(outputRoot, ...segments) {
+  const resolved = path5.resolve(outputRoot, ...segments);
+  const relative = path5.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative)) {
+    return resolved;
+  }
+  throw new Error(`context tree output path escapes outputDir: ${segments.join("/")}`);
+}
+function writeProjectedContent(realOutputDir, outputPath, generatedContent) {
+  assertSafeOutputTarget(realOutputDir, outputPath);
+  fs2.mkdirSync(path5.dirname(outputPath), { recursive: true });
+  const realParent = fs2.realpathSync(path5.dirname(outputPath));
+  if (!isPathInside(realOutputDir, realParent)) {
+    throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
+  }
+  const existingContent = fs2.existsSync(outputPath) ? fs2.readFileSync(outputPath, "utf8") : "";
+  fs2.writeFileSync(
+    outputPath,
+    preserveManualFencedBlocks(generatedContent, existingContent)
+  );
+}
+function preserveManualFencedBlocks(generatedContent, existingContent) {
+  const manualBlocks = extractManualFencedBlocks(existingContent).filter((block) => !generatedContent.includes(block));
+  if (manualBlocks.length === 0) {
+    return generatedContent;
+  }
+  return `${generatedContent.trimEnd()}
+
+## Manual Edits
+
+${manualBlocks.join("\n\n")}
+`;
+}
+function extractManualFencedBlocks(content) {
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fencePattern = /(?:^|\n)([`~]{3,})[^\n]*\bmanual\b[^\n]*\n[\s\S]*?\n\1[ \t]*(?=\n|$)/gi;
+  for (const match of content.matchAll(fencePattern)) {
+    const block = match[0].trim();
+    if (!seen.has(block)) {
+      seen.add(block);
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs2.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path6.join(directory, entry.name);
+      const fullPath = path5.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        throw new Error(`context tree input path contains symlink: ${fullPath}`);
+      }
       if (entry.isDirectory()) {
+        const realDir = fs2.realpathSync(fullPath);
+        if (!isPathInside(realMemoryDir, realDir)) {
+          throw new Error(`context tree input path escapes memoryDir: ${fullPath}`);
+        }
         walk(fullPath);
       } else if (entry.name.endsWith(".md")) {
+        const realFile = fs2.realpathSync(fullPath);
+        if (!isPathInside(realMemoryDir, realFile)) {
+          throw new Error(`context tree input path escapes memoryDir: ${fullPath}`);
+        }
         results.push(fullPath);
       }
     }
@@ -1449,13 +1692,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path6.basename(filePath, ".md");
-  const dateDir = path6.basename(path6.dirname(filePath));
+  const fileName = path5.basename(filePath, ".md");
+  const dateDir = path5.basename(path5.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path6.join(category, dateDir, `${fileName}.md`);
+    relPath = path5.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path6.join(category, `${fileName}.md`);
+    relPath = path5.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -1501,7 +1744,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path6.join("entities", `${fileName}.md`),
+    path: path5.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -1554,18 +1797,18 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs3 from "fs";
-import path7 from "path";
+import path6 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
     extensions: [".ts", ".tsx"],
-    manifests: ["package.json"],
+    manifests: [],
     configFiles: ["tsconfig.json", "tsup.config.ts"]
   },
   {
     language: "JavaScript",
     extensions: [".js", ".jsx", ".mjs", ".cjs"],
-    manifests: ["package.json"],
+    manifests: [],
     configFiles: [".eslintrc", ".prettierrc"]
   },
   {
@@ -1653,10 +1896,19 @@ var DEFAULT_EXCLUDE = /* @__PURE__ */ new Set([
 function onboard(options) {
   const startTime = Date.now();
   const {
-    directory,
     maxDepth = 6,
     excludeDirs = []
   } = options;
+  const directory = path6.resolve(options.directory ?? process.cwd());
+  let rootStat;
+  try {
+    rootStat = fs3.statSync(directory);
+  } catch (err) {
+    throw new Error(`Cannot scan onboarding directory ${directory}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!rootStat.isDirectory()) {
+    throw new Error(`Cannot scan onboarding directory ${directory}: not a directory`);
+  }
   const exclude = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE, ...excludeDirs]);
   const files = walkDir(directory, exclude, maxDepth);
   const languages = detectLanguages(files, directory);
@@ -1681,12 +1933,15 @@ function walkDir(root, exclude, maxDepth) {
     let entries;
     try {
       entries = fs3.readdirSync(dir, { withFileTypes: true });
-    } catch {
+    } catch (err) {
+      if (depth === 0) {
+        throw new Error(`Cannot scan onboarding directory ${root}: ${err instanceof Error ? err.message : String(err)}`);
+      }
       return;
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path7.join(dir, entry.name);
+      const fullPath = path6.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -1701,11 +1956,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path7.extname(f).toLowerCase();
+    const ext = path6.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path7.dirname(f) === root).map((f) => path7.basename(f))
+    files.filter((f) => path6.dirname(f) === root).map((f) => path6.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -1749,7 +2004,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path7.dirname(f) === root).map((f) => path7.basename(f))
+    files.filter((f) => path6.dirname(f) === root).map((f) => path6.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -1760,7 +2015,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path7.join(root, "package.json"));
+    const pkg = readJsonSafe(path6.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -1774,13 +2029,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path7.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path6.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path7.join(root, "package.json"));
+    const pkg = readJsonSafe(path6.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -1814,8 +2069,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path7.basename(filePath).toLowerCase();
-    const relPath = path7.relative(root, filePath);
+    const basename = path6.basename(filePath).toLowerCase();
+    const relPath = path6.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -1827,7 +2082,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path7.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path6.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -1848,7 +2103,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path7.sep);
+  const parts = relPath.split(path6.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -1892,8 +2147,8 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs4 from "fs";
-import path8 from "path";
-import crypto3 from "crypto";
+import path7 from "path";
+import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
   const {
@@ -1915,6 +2170,7 @@ async function curate(options) {
   let filesProcessed = 0;
   let filesSkipped = 0;
   const targets = resolveTargets(targetPath);
+  const provenanceRoot = resolveProvenanceRoot(targetPath);
   const existingMemories = checkDuplicates || checkContradictions ? loadExistingMemories(memoryDir) : /* @__PURE__ */ new Map();
   for (const filePath of targets) {
     const content = readFileSafe(filePath);
@@ -1931,7 +2187,7 @@ async function curate(options) {
     const fileStatements = extractStatements(
       content,
       filePath,
-      targetPath,
+      provenanceRoot,
       source,
       sourceFileHash,
       categoryOverride,
@@ -1956,14 +2212,12 @@ async function curate(options) {
       statements.push(stmt);
       if (write) {
         const writtenPath = writeStatement(stmt, memoryDir);
-        if (writtenPath) {
-          written.push(writtenPath);
-          existingMemories.set(stmt.contentHash, {
-            id: stmt.id,
-            content: stmt.content,
-            category: stmt.category
-          });
-        }
+        written.push(writtenPath);
+        existingMemories.set(stmt.contentHash, {
+          id: stmt.id,
+          content: stmt.content,
+          category: stmt.category
+        });
       }
     }
   }
@@ -1984,12 +2238,12 @@ function resolveTargets(targetPath) {
   const extensions = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
   function walk(dir) {
     for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = path8.join(dir, entry.name);
+      const fullPath = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path8.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path7.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -1997,8 +2251,13 @@ function resolveTargets(targetPath) {
   walk(targetPath);
   return results;
 }
+function resolveProvenanceRoot(targetPath) {
+  const resolvedTarget = path7.resolve(targetPath);
+  const stat = fs4.statSync(resolvedTarget);
+  return stat.isFile() ? path7.dirname(resolvedTarget) : resolvedTarget;
+}
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path8.relative(projectRoot, filePath);
+  const relativePath = path7.relative(projectRoot, path7.resolve(filePath)) || path7.basename(filePath);
   const statements = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paragraphs = content.split(/\n{2,}/).map((p) => p.trim()).filter((p) => p.length > 20 && p.length < 2e3);
@@ -2092,7 +2351,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs4.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path8.join(memoryDir, dir);
+    const fullDir = path7.join(memoryDir, dir);
     if (!fs4.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -2114,10 +2373,10 @@ function writeStatement(stmt, memoryDir) {
   const now = /* @__PURE__ */ new Date();
   const dateDir = now.toISOString().split("T")[0];
   const categoryDir = getCategoryDir(memoryDir, stmt.category);
-  const dir = path8.join(categoryDir, dateDir);
+  const dir = path7.join(categoryDir, dateDir);
   fs4.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path8.join(dir, fileName);
+  const filePath = path7.join(dir, fileName);
   const frontmatter = [
     "---",
     `id: ${stmt.id}`,
@@ -2137,18 +2396,14 @@ function writeStatement(stmt, memoryDir) {
 
 ${stmt.content}
 `;
-  try {
-    fs4.writeFileSync(filePath, body);
-    return filePath;
-  } catch {
-    return null;
-  }
+  fs4.writeFileSync(filePath, body);
+  return filePath;
 }
 function generateId() {
-  return crypto3.randomUUID();
+  return crypto4.randomUUID();
 }
 function hashContent(content) {
-  return crypto3.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return crypto4.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 function tierFromConfidence(confidence) {
   if (confidence >= 0.95) return "explicit";
@@ -2188,7 +2443,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path8.join(dir, entry.name);
+    const fullPath = path7.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -2199,11 +2454,21 @@ function walkFiles(dir, callback) {
 
 // src/dedup/index.ts
 import fs5 from "fs";
-import path9 from "path";
-import crypto4 from "crypto";
+import path8 from "path";
+import crypto5 from "crypto";
+var DEFAULT_DEDUP_THRESHOLD = 0.85;
+var DEFAULT_MAX_LOAD = 1e4;
+function normalizeThreshold(value, defaultValue) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : defaultValue;
+}
+function normalizeMaxLoad(value, defaultValue) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : defaultValue;
+}
 function findDuplicates(options) {
   const startTime = Date.now();
-  const { memoryDir, threshold = 0.85, maxLoad = 1e4 } = options;
+  const { memoryDir } = options;
+  const threshold = normalizeThreshold(options.threshold, DEFAULT_DEDUP_THRESHOLD);
+  const maxLoad = normalizeMaxLoad(options.maxLoad, DEFAULT_MAX_LOAD);
   const memories = loadMemories(memoryDir, options.categories, maxLoad);
   const duplicates = [];
   for (let i = 0; i < memories.length; i++) {
@@ -2227,7 +2492,8 @@ function findDuplicates(options) {
 }
 function findContradictions(options) {
   const startTime = Date.now();
-  const { memoryDir, maxLoad = 1e4 } = options;
+  const { memoryDir } = options;
+  const maxLoad = normalizeMaxLoad(options.maxLoad, DEFAULT_MAX_LOAD);
   const memories = loadMemories(memoryDir, options.categories, maxLoad);
   const contradictions = [];
   for (let i = 0; i < memories.length; i++) {
@@ -2272,6 +2538,7 @@ var NEGATION_WORDS = /* @__PURE__ */ new Set([
   "aren't",
   "won't",
   "can't",
+  "cannot",
   "never",
   "no",
   "none",
@@ -2320,18 +2587,27 @@ function containsNegation(text) {
   return words.some((w) => NEGATION_WORDS.has(w));
 }
 function stripNegation(text) {
-  return text.replace(/\b(not|don't|doesn't|isn't|aren't|won't|can't|never|no|none|neither|nor|nothing|nowhere)\b/gi, "").replace(/\s+/g, " ").trim();
+  return text.replace(/\b(not|don't|doesn't|isn't|aren't|won't|can't|cannot|never|no|none|neither|nor|nothing|nowhere)\b/gi, "").replace(/\s+/g, " ").trim();
 }
 function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   const result = [];
   const allCategories = categories ?? ALL_CATEGORY_DIRS;
+  if (!fs5.existsSync(memoryDir)) return result;
+  const memoryRootReal = fs5.realpathSync(memoryDir);
   for (const category of allCategories) {
     if (result.length >= maxLoad) break;
-    const dir = path9.join(memoryDir, category);
+    const dir = path8.join(memoryDir, category);
     if (!fs5.existsSync(dir)) continue;
-    walkMdFiles(dir, (filePath) => {
+    const categoryStat = fs5.lstatSync(dir);
+    if (categoryStat.isSymbolicLink()) {
+      throw new Error(`Refusing to scan symlinked memory category directory: ${dir}`);
+    }
+    if (!categoryStat.isDirectory()) continue;
+    const categoryRootReal = fs5.realpathSync(dir);
+    assertPathInsideRoot(memoryRootReal, categoryRootReal, dir);
+    walkMdFiles(dir, memoryRootReal, categoryRootReal, (filePath) => {
       if (result.length >= maxLoad) return;
-      const content = readFileSafe2(filePath);
+      const content = readFileSafe2(filePath, memoryRootReal, categoryRootReal);
       if (!content) return;
       const fm = parseFrontmatter3(content);
       const body = extractBody3(content);
@@ -2347,10 +2623,17 @@ function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   return result;
 }
 function hashContent2(content) {
-  return crypto4.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return crypto5.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
-function readFileSafe2(filePath) {
+function readFileSafe2(filePath, memoryRootReal, categoryRootReal) {
   try {
+    const fileStat = fs5.lstatSync(filePath);
+    if (fileStat.isSymbolicLink()) {
+      throw new Error(`Refusing to read symlinked memory file: ${filePath}`);
+    }
+    const fileReal = fs5.realpathSync(filePath);
+    assertPathInsideRoot(memoryRootReal, fileReal, filePath);
+    assertPathInsideRoot(categoryRootReal, fileReal, filePath);
     return fs5.readFileSync(filePath, "utf8");
   } catch {
     return null;
@@ -2373,11 +2656,25 @@ function extractBody3(content) {
   const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
   return match ? match[1].trim() : content.trim();
 }
-function walkMdFiles(dir, callback) {
+function assertPathInsideRoot(rootReal, targetReal, sourcePath) {
+  const rel = path8.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path8.isAbsolute(rel)) {
+    return;
+  }
+  throw new Error(`Refusing to scan memory path outside root: ${sourcePath}`);
+}
+function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path9.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkMdFiles(fullPath, callback);
+    const fullPath = path8.join(dir, entry.name);
+    const entryStat = fs5.lstatSync(fullPath);
+    if (entryStat.isSymbolicLink()) {
+      throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
+    }
+    const entryReal = fs5.realpathSync(fullPath);
+    assertPathInsideRoot(memoryRootReal, entryReal, fullPath);
+    assertPathInsideRoot(categoryRootReal, entryReal, fullPath);
+    if (entryStat.isDirectory()) {
+      walkMdFiles(fullPath, memoryRootReal, categoryRootReal, callback);
     } else if (entry.name.endsWith(".md")) {
       callback(fullPath);
     }
@@ -2386,8 +2683,42 @@ function walkMdFiles(dir, callback) {
 
 // src/review/index.ts
 import fs6 from "fs";
-import path10 from "path";
+import path9 from "path";
 var DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
+function realMemoryRoot(memoryDir) {
+  try {
+    const stat = fs6.lstatSync(memoryDir);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) return null;
+    return fs6.realpathSync(memoryDir);
+  } catch {
+    return null;
+  }
+}
+function isPathInside2(rootReal, candidateReal) {
+  const relative = path9.relative(rootReal, candidateReal);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path9.isAbsolute(relative);
+}
+function isSafeDirectory(rootReal, dir) {
+  try {
+    const stat = fs6.lstatSync(dir);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) return false;
+    return isPathInside2(rootReal, fs6.realpathSync(dir));
+  } catch {
+    return false;
+  }
+}
+function ensureSafeDirectory(rootReal, dir) {
+  if (fs6.existsSync(dir)) {
+    if (!isSafeDirectory(rootReal, dir)) {
+      throw new Error(`Refusing to write through unsafe review path: ${dir}`);
+    }
+    return;
+  }
+  fs6.mkdirSync(dir, { recursive: true });
+  if (!isSafeDirectory(rootReal, dir)) {
+    throw new Error(`Refusing to write through unsafe review path: ${dir}`);
+  }
+}
 function listReviewItems(options) {
   const startTime = Date.now();
   const {
@@ -2396,19 +2727,25 @@ function listReviewItems(options) {
     limit = 50,
     confidenceThreshold = DEFAULT_CONFIDENCE_THRESHOLD
   } = options;
+  const maxItems = Math.max(0, limit);
+  const rootReal = realMemoryRoot(memoryDir);
+  if (!rootReal || maxItems === 0) {
+    return { items: [], total: 0, durationMs: Date.now() - startTime };
+  }
   const items = [];
+  const isLimitReached = () => items.length >= maxItems;
   const addItem = (item) => {
-    if (items.length >= limit) return;
+    if (isLimitReached()) return;
     if (filterReason && item.reviewReason !== filterReason) return;
     items.push(item);
   };
-  const suggestionsDir = path10.join(memoryDir, "suggestions");
-  if (fs6.existsSync(suggestionsDir)) {
-    walkMd(suggestionsDir, (filePath, content) => {
-      if (items.length >= limit) return;
+  const suggestionsDir = path9.join(memoryDir, "suggestions");
+  if (!isLimitReached() && fs6.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
+    walkMd(rootReal, suggestionsDir, (filePath, content) => {
+      if (isLimitReached()) return true;
       const fm = parseFrontmatter4(content);
       const body = extractBody4(content);
-      if (!fm?.id) return;
+      if (!fm?.id) return false;
       addItem({
         id: fm.id,
         content: body,
@@ -2420,15 +2757,16 @@ function listReviewItems(options) {
         created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
         reviewReason: "suggestion"
       });
+      return isLimitReached();
     });
   }
-  const reviewDir = path10.join(memoryDir, "review");
-  if (fs6.existsSync(reviewDir)) {
-    walkMd(reviewDir, (filePath, content) => {
-      if (items.length >= limit) return;
+  const reviewDir = path9.join(memoryDir, "review");
+  if (!isLimitReached() && fs6.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
+    walkMd(rootReal, reviewDir, (filePath, content) => {
+      if (isLimitReached()) return true;
       const fm = parseFrontmatter4(content);
       const body = extractBody4(content);
-      if (!fm?.id) return;
+      if (!fm?.id) return false;
       addItem({
         id: fm.id,
         content: body,
@@ -2441,22 +2779,23 @@ function listReviewItems(options) {
         reviewReason: fm.reviewReason ?? "low_confidence",
         context: fm.context
       });
+      return isLimitReached();
     });
   }
   const categories = ALL_CATEGORY_DIRS;
   for (const category of categories) {
-    if (items.length >= limit) break;
-    const dir = path10.join(memoryDir, category);
-    if (!fs6.existsSync(dir)) continue;
-    walkMd(dir, (filePath, content) => {
-      if (items.length >= limit) return;
+    if (isLimitReached()) break;
+    const dir = path9.join(memoryDir, category);
+    if (!fs6.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
+    walkMd(rootReal, dir, (filePath, content) => {
+      if (isLimitReached()) return true;
       const fm = parseFrontmatter4(content);
       const body = extractBody4(content);
-      if (!fm?.id) return;
+      if (!fm?.id) return false;
       const confidence = parseConfidence(fm.confidence, 1);
-      if (confidence >= confidenceThreshold) return;
-      if (parseBoolean(fm.reviewDismissed)) return;
-      if (items.some((i) => i.id === fm.id)) return;
+      if (confidence >= confidenceThreshold) return false;
+      if (parseBoolean(fm.reviewDismissed)) return false;
+      if (items.some((i) => i.id === fm.id)) return false;
       addItem({
         id: fm.id,
         content: body,
@@ -2468,6 +2807,7 @@ function listReviewItems(options) {
         created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
         reviewReason: "low_confidence"
       });
+      return isLimitReached();
     });
   }
   return {
@@ -2487,6 +2827,8 @@ function performReview(memoryDir, itemId, action, options = {}) {
   }
 }
 function approveItem(memoryDir, itemId, options) {
+  const rootReal = realMemoryRoot(memoryDir);
+  if (!rootReal) return { itemId, action: "approve", message: "Item not found" };
   const found = findReviewFileById(memoryDir, itemId, options);
   if (!found) {
     return { itemId, action: "approve", message: "Item not found" };
@@ -2511,8 +2853,9 @@ function approveItem(memoryDir, itemId, options) {
   const category = fm.category ?? "fact";
   const targetDir = getCategoryDir(memoryDir, category);
   const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const outputPath = path10.join(targetDir, dateDir, path10.basename(found.filePath));
-  fs6.mkdirSync(path10.dirname(outputPath), { recursive: true });
+  ensureSafeDirectory(rootReal, targetDir);
+  const outputPath = path9.join(targetDir, dateDir, path9.basename(found.filePath));
+  ensureSafeDirectory(rootReal, path9.dirname(outputPath));
   const promotedPath = writeFileWithoutClobber(outputPath, updatedContent, itemId);
   fs6.unlinkSync(found.filePath);
   return {
@@ -2566,22 +2909,24 @@ function flagItem(memoryDir, itemId, options) {
   };
 }
 function findReviewFileById(memoryDir, id, options = {}) {
+  const rootReal = realMemoryRoot(memoryDir);
+  if (!rootReal) return null;
   for (const loc of ["suggestions", "review"]) {
-    const dir = path10.join(memoryDir, loc);
-    if (!fs6.existsSync(dir)) continue;
-    const found = findFileById(dir, id);
+    const dir = path9.join(memoryDir, loc);
+    if (!fs6.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
+    const found = findFileById(rootReal, dir, id);
     if (found) return { filePath: found, location: "queue" };
   }
   for (const category of ALL_CATEGORY_DIRS) {
-    const dir = path10.join(memoryDir, category);
-    if (!fs6.existsSync(dir)) continue;
-    const found = findFileById(dir, id, (fm) => isLowConfidenceReviewCandidate(fm, options));
+    const dir = path9.join(memoryDir, category);
+    if (!fs6.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
+    const found = findFileById(rootReal, dir, id, (fm) => isLowConfidenceReviewCandidate(fm, options));
     if (found) return { filePath: found, location: "category" };
   }
   return null;
 }
-function findFileById(dir, id, include) {
-  const files = walkMdPaths(dir);
+function findFileById(rootReal, dir, id, include) {
+  const files = walkMdPaths(rootReal, dir);
   for (const filePath of files) {
     const content = readFileSafe3(filePath);
     if (!content) continue;
@@ -2646,10 +2991,10 @@ function readFileSafe3(filePath) {
   }
 }
 function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path10.parse(basePath);
+  const parsed = path9.parse(basePath);
   const safeDiscriminator = sanitizeFilePart(discriminator);
   for (let attempt = 0; attempt < 1e3; attempt++) {
-    const candidate = attempt === 0 ? basePath : path10.join(
+    const candidate = attempt === 0 ? basePath : path9.join(
       parsed.dir,
       `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
     );
@@ -2702,24 +3047,29 @@ function extractBody4(content) {
   const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
   return match ? match[1].trim() : content.trim();
 }
-function walkMd(dir, callback) {
+function walkMd(rootReal, dir, callback) {
+  if (!isSafeDirectory(rootReal, dir)) return false;
   for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path10.join(dir, entry.name);
+    const fullPath = path9.join(dir, entry.name);
+    if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
-      walkMd(fullPath, callback);
-    } else if (entry.name.endsWith(".md")) {
+      if (walkMd(rootReal, fullPath, callback)) return true;
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
       const content = readFileSafe3(fullPath);
-      if (content) callback(fullPath, content);
+      if (content && callback(fullPath, content) === true) return true;
     }
   }
+  return false;
 }
-function walkMdPaths(dir) {
+function walkMdPaths(rootReal, dir) {
   const results = [];
+  if (!isSafeDirectory(rootReal, dir)) return results;
   for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path10.join(dir, entry.name);
+    const fullPath = path9.join(dir, entry.name);
+    if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
-      results.push(...walkMdPaths(fullPath));
-    } else if (entry.name.endsWith(".md")) {
+      results.push(...walkMdPaths(rootReal, fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
       results.push(fullPath);
     }
   }
@@ -2728,8 +3078,8 @@ function walkMdPaths(dir) {
 
 // src/sync/index.ts
 import fs7 from "fs";
-import path11 from "path";
-import crypto5 from "crypto";
+import path10 from "path";
+import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
   "node_modules",
@@ -2750,7 +3100,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path11.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path10.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -2766,7 +3116,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs7.mkdirSync(path11.dirname(stateFilePath), { recursive: true });
+    fs7.mkdirSync(path10.dirname(stateFilePath), { recursive: true });
     fs7.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -2783,45 +3133,62 @@ function watchForChanges(options, onChange) {
   const { sourceDir, extensions, excludeDirs } = options;
   const extSet = new Set(extensions ?? DEFAULT_EXTENSIONS);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs ?? []]);
+  const pollIntervalMs = typeof options.pollIntervalMs === "number" && Number.isFinite(options.pollIntervalMs) && options.pollIntervalMs > 0 ? options.pollIntervalMs : 5e3;
   let lastHashes = {};
+  let pollInFlight = false;
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   lastHashes = { ...currentFiles };
-  const interval = setInterval(() => {
-    const nowFiles = scanFiles(sourceDir, extSet, excludeSet);
-    const changes = computeDiff(nowFiles, lastHashes, sourceDir);
-    if (changes.length > 0) {
-      for (const change of changes) {
-        if (change.type === "deleted") {
-          delete lastHashes[change.relativePath];
-        } else {
-          lastHashes[change.relativePath] = change.currentHash;
+  const poll = async () => {
+    if (pollInFlight) return;
+    pollInFlight = true;
+    try {
+      const nowFiles = scanFiles(sourceDir, extSet, excludeSet);
+      const changes = computeDiff(nowFiles, lastHashes, sourceDir);
+      if (changes.length > 0) {
+        await onChange(changes);
+        for (const change of changes) {
+          if (change.type === "deleted") {
+            delete lastHashes[change.relativePath];
+          } else {
+            lastHashes[change.relativePath] = change.currentHash;
+          }
         }
       }
-      onChange(changes);
+    } catch {
+    } finally {
+      pollInFlight = false;
     }
-  }, 5e3);
+  };
+  const interval = setInterval(() => {
+    void poll();
+  }, pollIntervalMs);
   return {
     stop: () => clearInterval(interval)
   };
 }
 function scanFiles(root, extensions, exclude) {
   const result = {};
-  function walk(dir) {
+  function walk(dir, isRoot = false) {
     let entries;
     try {
       entries = fs7.readdirSync(dir, { withFileTypes: true });
-    } catch {
+    } catch (err) {
+      if (isRoot) {
+        throw new Error(
+          `sync scan failed for ${dir}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
       return;
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path11.join(dir, entry.name);
+      const fullPath = path10.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path11.extname(entry.name).toLowerCase();
+        const ext = path10.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path11.relative(root, fullPath);
+        const relPath = path10.relative(root, fullPath);
         try {
           const content = fs7.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -2830,13 +3197,13 @@ function scanFiles(root, extensions, exclude) {
       }
     }
   }
-  walk(root);
+  walk(root, true);
   return result;
 }
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path11.join(sourceDir, relPath);
+    const fullPath = path10.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -2869,7 +3236,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path11.join(sourceDir, relPath),
+        filePath: path10.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -2892,20 +3259,23 @@ function loadState(stateFilePath) {
   }
 }
 function hashContent3(content) {
-  return crypto5.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return crypto6.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 
 // src/spaces/index.ts
 import fs8 from "fs";
-import path12 from "path";
-import crypto6 from "crypto";
+import path11 from "path";
+import crypto7 from "crypto";
 var MANIFEST_VERSION = 1;
+function normalizeSpaceMemoryDir(memoryDir) {
+  return path11.resolve(memoryDir);
+}
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path12.join(homeDir, ".config", "engram", "spaces");
+  return path11.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path12.join(getSpacesDir(baseDir), "manifest.json");
+  return path11.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   const manifestPath2 = getManifestPath(baseDir);
@@ -2924,21 +3294,22 @@ function loadManifest(baseDir, memoryDirOverride) {
 }
 function saveManifest(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  fs8.mkdirSync(path12.dirname(manifestPath2), { recursive: true });
+  fs8.mkdirSync(path11.dirname(manifestPath2), { recursive: true });
   fs8.writeFileSync(manifestPath2, JSON.stringify(manifest, null, 2) + "\n");
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path12.join(homeDir, ".engram", "memory");
-  const openclawPath = path12.join(homeDir, ".openclaw", "workspace", "memory", "local");
-  const memoryDir = memoryDirOverride ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs8.existsSync(standalonePath) ? standalonePath : fs8.existsSync(openclawPath) ? openclawPath : standalonePath);
+  const standalonePath = path11.join(homeDir, ".engram", "memory");
+  const openclawPath = path11.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs8.existsSync(standalonePath) ? standalonePath : fs8.existsSync(openclawPath) ? openclawPath : standalonePath);
+  const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     id: "personal",
     name: "Personal",
     kind: "personal",
     description: "Default personal memory space",
-    memoryDir,
+    memoryDir: normalizedMemoryDir,
     createdAt: now,
     updatedAt: now,
     owner: readEnvVar("USER")
@@ -2964,10 +3335,12 @@ function createSpace(options) {
     throw new Error(`Parent space "${options.parentSpaceId}" not found`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const memoryDir = options.memoryDir ?? path12.join(
-    getSpacesDir(options.baseDir),
-    id,
-    "memory"
+  const memoryDir = normalizeSpaceMemoryDir(
+    options.memoryDir ?? path11.join(
+      getSpacesDir(options.baseDir),
+      id,
+      "memory"
+    )
   );
   const space = {
     id,
@@ -3154,16 +3527,16 @@ function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path12.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path11.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs8.existsSync(auditPath)) return [];
   const lines = fs8.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path12.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs8.mkdirSync(path12.dirname(auditPath), { recursive: true });
+  const auditPath = path11.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs8.mkdirSync(path11.dirname(auditPath), { recursive: true });
   const full = {
-    id: crypto6.randomUUID(),
+    id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     ...entry
   };
@@ -3176,12 +3549,28 @@ function copyMemories(sourceDir, targetDir, options) {
   if (!fs8.existsSync(sourceDir)) {
     return { merged: 0, conflicts: [], skipped: 0 };
   }
+  const sourceRoot = fs8.realpathSync(sourceDir);
   fs8.mkdirSync(targetDir, { recursive: true });
-  const sourceFiles = walkMd2(sourceDir);
+  const targetRoot = fs8.realpathSync(targetDir);
+  const sourceFiles = walkMd2(sourceRoot);
   for (const sourcePath of sourceFiles) {
+    const sourceRealPath = safeRealpath(sourcePath);
+    if (!sourceRealPath || !isPathInsideRoot(sourceRealPath, sourceRoot)) {
+      skipped++;
+      continue;
+    }
+    const sourceStat = safeLstat(sourcePath);
+    if (!sourceStat?.isFile()) {
+      skipped++;
+      continue;
+    }
     const content = fs8.readFileSync(sourcePath, "utf8");
-    const relativePath = path12.relative(sourceDir, sourcePath);
-    const targetPath = path12.join(targetDir, relativePath);
+    const relativePath = path11.relative(sourceRoot, sourceRealPath);
+    const targetPath = path11.resolve(targetRoot, relativePath);
+    if (!isPathInsideRoot(targetPath, targetRoot)) {
+      skipped++;
+      continue;
+    }
     const sourceHash = hashContent4(content);
     if (options?.filterIds?.length) {
       const fm = parseSimpleFrontmatter(content);
@@ -3190,6 +3579,18 @@ function copyMemories(sourceDir, targetDir, options) {
         continue;
       }
     }
+    if (fs8.existsSync(targetPath)) {
+      const targetStat = safeLstat(targetPath);
+      if (!targetStat?.isFile() || targetStat.isSymbolicLink()) {
+        skipped++;
+        continue;
+      }
+      const targetRealPath = safeRealpath(targetPath);
+      if (!targetRealPath || !isPathInsideRoot(targetRealPath, targetRoot)) {
+        skipped++;
+        continue;
+      }
+    }
     if (fs8.existsSync(targetPath) && !options?.force) {
       const targetContent = fs8.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
@@ -3207,20 +3608,28 @@ function copyMemories(sourceDir, targetDir, options) {
       skipped++;
       continue;
     }
-    fs8.mkdirSync(path12.dirname(targetPath), { recursive: true });
+    fs8.mkdirSync(path11.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path11.dirname(targetPath));
+    if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
+      skipped++;
+      continue;
+    }
     fs8.writeFileSync(targetPath, content);
     merged++;
   }
   return { merged, conflicts, skipped };
 }
 function hashContent4(content) {
-  return crypto6.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return crypto7.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 function walkMd2(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs8.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path12.join(d, entry.name);
+      const fullPath = path11.join(d, entry.name);
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.name.endsWith(".md")) {
@@ -3231,6 +3640,24 @@ function walkMd2(dir) {
   walk(dir);
   return results;
 }
+function safeLstat(filePath) {
+  try {
+    return fs8.lstatSync(filePath);
+  } catch {
+    return null;
+  }
+}
+function safeRealpath(filePath) {
+  try {
+    return fs8.realpathSync(filePath);
+  } catch {
+    return null;
+  }
+}
+function isPathInsideRoot(candidatePath, rootPath) {
+  const relative = path11.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path11.isAbsolute(relative);
+}
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -3350,23 +3777,39 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs9 from "fs";
 import os from "os";
-import path13 from "path";
+import path12 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
+function resolveEnvHome(env) {
+  if (env === void 0) return resolveHomeDir();
+  return env.HOME?.trim() || env.USERPROFILE?.trim() || os.homedir();
+}
+function expandTildeWithHome(input, homeDir) {
+  if (input === "~") return homeDir;
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return path12.join(homeDir, input.slice(2));
+  }
+  return input;
+}
+function normalizeHostRoot(input, homeDir) {
+  return path12.resolve(expandTildeWithHome(input.trim(), homeDir));
+}
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
   static capabilities = {
     instructionsMd: true,
-    skillsFolder: true,
+    skillsFolder: false,
     citationFormat: true,
     readPathTemplate: true
   };
   async resolveExtensionRoot(env) {
-    const codexHome = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() || path13.join(resolveHomeDir(), ".codex") : env.CODEX_HOME?.trim() || path13.join(env.HOME ?? env.USERPROFILE ?? os.homedir(), ".codex");
-    return path13.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const homeDir = resolveEnvHome(env);
+    const codexHomeInput = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() : env.CODEX_HOME?.trim();
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path12.resolve(homeDir, ".codex");
+    return path12.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path13.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path12.join(resolveHomeDir(), ".codex");
       return fs9.existsSync(home);
     } catch {
       return false;
@@ -3417,7 +3860,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path13.join(extensionRoot, "instructions.md");
+    const instructionsPath = path12.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -3532,141 +3975,21 @@ function publisherForConnector(connectorId) {
   return publisherFor(hostIdForConnector(connectorId));
 }
 
-// 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 };
-}
-
 // src/transfer/capsule-fork.ts
 import { lstat, mkdir, readFile, realpath, writeFile } from "fs/promises";
-import path14 from "path";
+import path13 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path14.resolve(opts.targetRoot);
+  const rootAbs = path13.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path14.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path13.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path14.resolve(opts.sourceArchive);
+  const archiveAbs = path13.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -3688,10 +4011,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path14.join(forkDirAbs, "lineage.json");
+  const lineagePath = path13.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir(path14.dirname(lineagePath), { recursive: true });
+  await mkdir(path13.dirname(lineagePath), { recursive: true });
   await writeFile(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -3705,11 +4028,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path14.resolve(targetRoot);
+  const rootAbs = path13.resolve(targetRoot);
   const rootReal = await realpath(rootAbs).catch(() => rootAbs);
-  const lineagePath = path14.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path14.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path14.isAbsolute(rel)) {
+  const lineagePath = path13.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path13.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path13.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -3750,19 +4073,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path14.dirname(existing)) {
+  while (existing !== path13.dirname(existing)) {
     const st = await lstat(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path14.basename(existing));
-    existing = path14.dirname(existing);
+    suffix.unshift(path13.basename(existing));
+    existing = path13.dirname(existing);
   }
   const existingReal = await realpath(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path14.join(existingReal, ...suffix) : existingReal;
-  const rel = path14.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path13.join(existingReal, ...suffix) : existingReal;
+  const rel = path13.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path14.sep}`)) return false;
-  if (path14.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path13.sep}`)) return false;
+  if (path13.isAbsolute(rel)) return false;
   return true;
 }
 export {
@@ -3809,7 +4132,6 @@ export {
   GOOGLE_DRIVE_CURSOR_KIND,
   DEFAULT_POLL_INTERVAL_MS as GOOGLE_DRIVE_DEFAULT_POLL_INTERVAL_MS,
   HermesMemoryExtensionPublisher,
-  LEGACY_PLUGIN_ID,
   LanceDbBackend,
   LiveConnectorRegistry,
   LiveConnectorRegistryError,
@@ -3834,7 +4156,6 @@ export {
   PEERS_DIR_NAME,
   PEER_ID_MAX_LENGTH,
   PEER_ID_PATTERN,
-  PLUGIN_ID,
   PUBLISHERS,
   QmdClient,
   RECALL_DISCLOSURE_LEVELS,
@@ -4115,6 +4436,7 @@ export {
   reportBufferSurpriseDistribution,
   resolveAgentAccessAuthToken,
   resolveBriefingSaveDir,
+  resolveBulkImportContext,
   resolveCategory,
   resolveCodingNamespaceOverlay,
   resolveConnectorFromToken,
@@ -4122,8 +4444,8 @@ export {
   resolveExtensionsRoot,
   resolveGitContext,
   resolvePair,
+  resolvePluginEntry,
   resolvePrincipal,
-  resolveRemnicPluginEntry,
   revertToVersion,
   revokeToken,
   rollbackFromEngramMigration,
@@ -4163,6 +4485,7 @@ export {
   summarizeUserModelCoverage,
   switchSpace,
   syncChanges,
+  validateBatchSize,
   validateBriefingFormat,
   validateGoogleDriveConfig,
   validateImportBatchSize,