rag-memory-epf-mcp 5.0.0 → 5.2.0

package/README.md

@@ -64,7 +64,7 @@ Place this `.mcp.json` in each project folder with its own `DB_FILE_PATH`. Each
 ### Document Pipeline (9)
 | Tool | Description | Annotation |
 |------|------------|------------|
-| `storeDocument` | Store documents with metadata | idempotent |
+| `storeDocument` | Store documents with metadata. Replacing an existing document reports what it destroyed: `{ replaced, deletedChunks }` | idempotent |
 | `chunkDocument` | Create text chunks with configurable parameters | — |
 | `embedChunks` | Generate 1024-dim embeddings + auto-link entities | idempotent |
 | `embedAllEntities` | Batch embed all entities (32 parallel) | idempotent |
@@ -72,7 +72,7 @@ Place this `.mcp.json` in each project folder with its own `DB_FILE_PATH`. Each
 | `linkEntitiesToDocument` | Link entities to chunks where they actually appear (text-matched) | idempotent |
 | `deleteDocuments` | Remove documents and associated data | destructive |
 | `listDocuments` | View all stored documents | readOnly |
-| `syncDocumentFromFile` | One-call server-side sync: reads file + delete/store/chunk/embed/link, content stays off model context. Atomic (embed-first transaction swap) + `content_hash` dedup (skips unchanged files) | idempotent |
+| `syncDocumentFromFile` | One-call server-side sync: reads file + delete/store/chunk/embed/link, content stays off model context. Atomic (embed-first transaction swap) + `content_hash` dedup (skips unchanged files). `excludePattern` strips regions before indexing, and the hash follows the stripped text so changing the pattern re-indexes | idempotent |
 
 ### Search & Retrieval (9)
 | Tool | Description | Annotation |

package/dist/index.d.ts

@@ -70,6 +70,7 @@ export declare class RAGKnowledgeGraphManager {
     currentProfileId: number;
     grandfatherAllowed: boolean;
     coordinator: BackfillCoordinator | null;
+    readonly calendarTimeZone: string;
     private embeddingCache;
     private readonly EMBEDDING_CACHE_MAX;
     private dictionaryCache;
@@ -227,6 +228,7 @@ export declare class RAGKnowledgeGraphManager {
     syncDocumentFromFile(filePath: string, documentId: string, options?: {
         metadata?: Record<string, any>;
         content?: string;
+        excludePattern?: string | string[];
         entityNames?: string[];
         chunkParams?: {
             maxTokens?: number;
@@ -252,6 +254,8 @@ export declare class RAGKnowledgeGraphManager {
     storeDocument(id: string, content: string, metadata?: Record<string, any>): Promise<{
         id: string;
         stored: boolean;
+        replaced: boolean;
+        deletedChunks: number;
     }>;
     chunkDocument(documentId: string, options?: {
         maxTokens?: number;

package/dist/index.js

@@ -32,6 +32,7 @@ import { migrations } from './src/migrations/migrations.js';
 import { EmbeddingGate, GateNotReadyError, GateDisabledError, TerminalConfigError } from './src/embeddingGate.js';
 import { resolveModelCacheDir, preflightCacheDir, artifactKey, ModelDownloadLock, handleLoaderFailure } from './src/modelCache.js';
 import { BackfillCoordinator } from './src/backfillCoordinator.js';
+import { calendarDate, resolveCalendarTimeZone, stampDatePrefix, stripDatePrefix } from './src/observations/date-prefix.js';
 import os from 'node:os';
 import { createHash } from 'crypto';
 import { createRequire } from 'module';
@@ -146,6 +147,28 @@ function safeRowid(value) {
     }
     return n;
 }
+// Remove regions the caller does not want indexed. Compiled with `s` because the intended use is
+// spanning a marked block (`<!-- SECRET -->…<!-- /SECRET -->`) and JS has no inline (?s) flag —
+// without it every such pattern would silently match nothing.
+// A malformed pattern throws rather than degrading to "no exclusion": indexing is a disclosure
+// path, so believing you excluded something you did not is worse than a failed sync.
+function applyExcludePatterns(text, pattern) {
+    if (pattern === undefined)
+        return text;
+    const patterns = Array.isArray(pattern) ? pattern : [pattern];
+    let out = text;
+    for (const p of patterns) {
+        let re;
+        try {
+            re = new RegExp(p, 'gs');
+        }
+        catch (e) {
+            throw new Error(`excludePattern is not a valid regular expression: ${JSON.stringify(p)} (${e.message})`);
+        }
+        out = out.replace(re, '');
+    }
+    return out;
+}
 // Enhanced RAG-enabled Knowledge Graph Manager
 export class RAGKnowledgeGraphManager {
     db = null;
@@ -157,6 +180,9 @@ export class RAGKnowledgeGraphManager {
     // default model config, or with the explicit trust opt-in (spec §6b guard).
     grandfatherAllowed = IS_DEFAULT_MODEL_CONFIG || process.env.RAG_MEMORY_TRUST_LEGACY_VECTORS === '1';
     coordinator = null;
+    // The calendar that date-only human labels are written in. Resolved once, here, so an invalid
+    // zone fails at construction instead of quietly writing wrong days for weeks.
+    calendarTimeZone = resolveCalendarTimeZone(process.env.RAG_MEMORY_CALENDAR_TZ);
     embeddingCache = new Map();
     EMBEDDING_CACHE_MAX = 500;
     dictionaryCache = null;
@@ -552,11 +578,12 @@ export class RAGKnowledgeGraphManager {
     }
     // === ORIGINAL MCP FUNCTIONALITY ===
     _timestampObservation(obs) {
-        // If observation already has a date prefix like [2026-03-21], skip
-        if (/^\[\d{4}-\d{2}-\d{2}\]/.test(obs))
-            return obs;
-        const today = new Date().toISOString().slice(0, 10);
-        return `[${today}] ${obs}`;
+        // Stamp and dedup share one parser (src/observations/date-prefix.ts). They used to carry
+        // separate regexes and disagreed about "[2026-08-11 session16] ...": stamping treated it as
+        // undated and prepended a second date, while dedup could not strip it — so the same sentence
+        // written in two sessions became two observations. Measured on a live database: 82 rows with
+        // two dates, 29 with a day earlier than the day they were written.
+        return stampDatePrefix(obs, this.calendarTimeZone);
     }
     async createEntities(entities) {
         if (!this.db)
@@ -568,7 +595,7 @@ export class RAGKnowledgeGraphManager {
       INSERT OR IGNORE INTO entities (id, name, entityType, observations, metadata)
       VALUES (?, ?, ?, '[]', ?)
     `);
-        const stripDate = (s2) => s2.replace(/^\[\d{4}-\d{2}-\d{2}\]\s*/, '');
+        const stripDate = stripDatePrefix; // shared with the stamp path — see date-prefix.ts
         for (const entity of entities) {
             const entityId = `entity_${entity.name.toLowerCase().replace(/[^\p{L}\p{N}]/gu, '_')}`;
             const ts = new Date().toISOString();
@@ -678,7 +705,7 @@ export class RAGKnowledgeGraphManager {
             // dedup 기준은 v3.6 과 같다: 날짜 prefix 를 뗀 본문이 active 에 이미 있으면
             // 새 revision 을 만들지 않는다. 다만 v13 에서는 같은 사실이 다른 출처에서 다시
             // 온 것이므로 그 revision 에 source link 를 더한다(spec §8.3 T13).
-            const stripDate = (s2) => s2.replace(/^\[\d{4}-\d{2}-\d{2}\]\s*/, '');
+            const stripDate = stripDatePrefix; // shared with the stamp path — see date-prefix.ts
             const activeRows = this.db.prepare(`SELECT observation_id, content FROM entity_observations
          WHERE entity_id = ? AND status = 'active'`).all(entityId);
             const activeByBare = new Map(activeRows.map(r => [stripDate(r.content), r.observation_id]));
@@ -1935,9 +1962,16 @@ export class RAGKnowledgeGraphManager {
         const zero = { reusedChunks: 0, newlyEmbeddedChunks: 0, queuedChunks: 0, deletedChunks: 0, chunkerTransitioned: false };
         for (let attempt = 1; attempt <= 3; attempt++) {
             // r6-3: CAS 재시작 = 처음부터 — 파일 읽기·hash·metadata 도 attempt 안에서 재계산한다.
-            const content = options.content !== undefined ? options.content : fsSync.readFileSync(filePath, 'utf-8');
+            // Strip excluded regions before anything else looks at the text. Everything downstream —
+            // content_hash, bytes, chunking — then describes what was actually indexed, so changing the
+            // pattern alone still invalidates the dedup gate below. Hashing the raw file instead would
+            // report `unchanged` for a different exclusion, which is the silent-wrong case.
+            const content = applyExcludePatterns(options.content !== undefined ? options.content : fsSync.readFileSync(filePath, 'utf-8'), options.excludePattern);
             const bytes = Buffer.byteLength(content, 'utf-8');
-            const today = new Date().toISOString().slice(0, 10);
+            // Same calendar as the observation prefix. Deciding this explicitly rather than leaving it
+            // on UTC: both are date-only labels a person reads, and "observations in Seoul days but
+            // documents in UTC days" is not a distinction anyone could explain later.
+            const today = calendarDate(new Date(), this.calendarTimeZone);
             const contentHash = shaHex(content);
             // spec §5.1: content_hash 는 system-owned — user metadata 뒤에 쓴다 (r1: spread 가 덮어쓸 수 있었다).
             const metadata = { source: filePath, updated: today, ...(options.metadata || {}), content_hash: contentHash };
@@ -2104,15 +2138,18 @@ export class RAGKnowledgeGraphManager {
         if (!this.db)
             throw new Error('Database not initialized');
         console.error(`📄 Storing document: ${id}`);
+        // Decide `replaced` from the document row, not from the chunk count: a document stored but
+        // never chunked still gets overwritten here, and reporting that as a fresh write would be a lie.
+        const existed = this.db.prepare(`SELECT 1 FROM documents WHERE id = ?`).get(id) !== undefined;
         // Clean up existing document
-        await this.cleanupDocument(id);
+        const cleaned = await this.cleanupDocument(id);
         // Store document
         this.db.prepare(`
       INSERT OR REPLACE INTO documents (id, content, metadata)
       VALUES (?, ?, ?)
     `).run(id, content, JSON.stringify(metadata));
         console.error(`✅ Document stored: ${id}`);
-        return { id, stored: true };
+        return { id, stored: true, replaced: existed, deletedChunks: cleaned.deletedChunks };
     }
     async chunkDocument(documentId, options = {}) {
         if (!this.db)
@@ -2430,9 +2467,13 @@ export class RAGKnowledgeGraphManager {
         console.error(`✅ Entities linked: ${linkedCount} entities linked to document`);
         return { documentId, linkedEntities: linkedCount };
     }
+    // Report what was destroyed. The counts were already computed here and thrown away, so a caller
+    // that replaces a document could not tell from the return value that anything was deleted
+    // (2026-08-05 field report from a deployed project: "{stored:true} came back and I did not know
+    // what I had just wiped"). Silent destruction is the defect; the numbers are free.
     async cleanupDocument(documentId) {
         if (!this.db)
-            return;
+            return { deletedChunks: 0, deletedAssociations: 0, deletedVectors: 0 };
         console.error(`🧹 Cleaning up document: ${documentId}`);
         // Get existing chunks
         const existingChunks = this.db.prepare(`
@@ -2460,6 +2501,7 @@ export class RAGKnowledgeGraphManager {
             console.error(`  ├─ Deleted ${deletedVectors} vector embeddings`);
             console.error(`  └─ Deleted ${metadata.changes} chunk metadata records`);
         }
+        return { deletedChunks: existingChunks.length, deletedAssociations, deletedVectors };
     }
     async deleteDocument(documentId) {
         if (!this.db)
@@ -3418,6 +3460,9 @@ export class RAGKnowledgeGraphManager {
             server: {
                 version: PKG_VERSION,
                 node: process.versions.node,
+                // Which calendar produced the date-only labels in this database. Surfaced because a
+                // wrong value is otherwise invisible: the labels look plausible either way.
+                calendar_timezone: this.calendarTimeZone,
                 embeddings_mode: this.embeddingsMode,
                 model: `${EMBEDDING_MODEL}@${MODEL_REVISION}`,
                 model_state: gs.state,
@@ -3839,6 +3884,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: JSON.stringify(await ragKgManager.syncDocumentFromFile(validatedArgs.path, validatedArgs.documentId, {
                                 metadata: validatedArgs.metadata,
                                 content: validatedArgs.content,
+                                excludePattern: validatedArgs.excludePattern,
                                 entityNames: validatedArgs.entityNames,
                                 chunkParams: validatedArgs.chunkParams,
                             }), null, 2) }] };

package/dist/src/observations/date-prefix.d.ts

@@ -0,0 +1,26 @@
+/** The calendar day of `instant` in `timeZone`, as YYYY-MM-DD. */
+export declare function calendarDate(instant: Date, timeZone: string): string;
+/**
+ * Resolve RAG_MEMORY_CALENDAR_TZ. Unset or blank means UTC. An unrecognised zone throws at
+ * boot rather than silently falling back — a wrong-but-quiet calendar writes wrong labels for
+ * as long as nobody looks, which is the failure this whole module exists to end.
+ */
+export declare function resolveCalendarTimeZone(raw: string | undefined | null): string;
+export interface DatePrefix {
+    /** YYYY-MM-DD, already validated as a real calendar day. */
+    date: string;
+    /** Text between the date and the closing bracket, e.g. a session marker. */
+    annotation: string | null;
+    /** The matched prefix including the brackets, without trailing whitespace. */
+    matched: string;
+}
+/** Parse a leading date prefix, or null when the text does not start with one. */
+export declare function parseDatePrefix(content: string): DatePrefix | null;
+/**
+ * The dedup key: the text with its date prefix removed. The annotation comes off with the date
+ * because it records *when and in which session the line was written*, not what the line claims
+ * — the same sentence written in two sessions is one fact, and dedup has to see that.
+ */
+export declare function stripDatePrefix(content: string): string;
+/** Prepend today's calendar day unless the text already carries a valid date prefix. */
+export declare function stampDatePrefix(content: string, timeZone: string, now?: Date): string;

package/dist/src/observations/date-prefix.js

@@ -0,0 +1,89 @@
+// One place that decides what a leading "[date]" on an observation means.
+//
+// Why this is a module and not two regexes inline: the stamp path and the dedup path each had
+// their own copy of the pattern, and they disagreed. Stamping asked "does this already start
+// with a date?" while dedup asked "what is this text without its date?", so widening one without
+// the other let the same sentence be stored twice under two session markers. Both now call in
+// here.
+//
+// Why an explicit timezone instead of the process one: a date-only label has no meaning until
+// you say which calendar produced it. The same database is reached from a laptop, from CI and
+// from another country; deriving the day from the ambient TZ makes the stored string mean
+// something different on each. The default stays UTC so the product does not inherit whichever
+// zone its first author happened to sit in — a deployment that wants local days says so.
+/** The calendar day of `instant` in `timeZone`, as YYYY-MM-DD. */
+export function calendarDate(instant, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    }).formatToParts(instant);
+    const part = (type) => {
+        const found = parts.find(p => p.type === type);
+        if (!found)
+            throw new Error(`calendarDate: missing ${type} for timeZone ${timeZone}`);
+        return found.value;
+    };
+    return `${part('year')}-${part('month')}-${part('day')}`;
+}
+/**
+ * Resolve RAG_MEMORY_CALENDAR_TZ. Unset or blank means UTC. An unrecognised zone throws at
+ * boot rather than silently falling back — a wrong-but-quiet calendar writes wrong labels for
+ * as long as nobody looks, which is the failure this whole module exists to end.
+ */
+export function resolveCalendarTimeZone(raw) {
+    const value = (raw ?? '').trim();
+    if (!value)
+        return 'UTC';
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: value });
+    }
+    catch {
+        throw new Error(`RAG_MEMORY_CALENDAR_TZ is not a recognised IANA time zone: ${JSON.stringify(value)}. ` +
+            `Use a name like "Asia/Seoul", or leave it unset for UTC.`);
+    }
+    return value;
+}
+// The annotation may not contain a newline or a bracket: an unclosed or multi-line "[2026-…"
+// is prose that happens to start with a digit, not a prefix. Requiring the closing bracket is
+// what keeps "[2026-08-11 unclosed" and "[2026-08-111]" out.
+const PREFIX_RE = /^\[(\d{4})-(\d{2})-(\d{2})(?:[ \t]([^\]\n]*))?\]/;
+function isRealCalendarDay(year, month, day) {
+    const asUtc = new Date(Date.UTC(year, month - 1, day));
+    return asUtc.getUTCFullYear() === year
+        && asUtc.getUTCMonth() === month - 1
+        && asUtc.getUTCDate() === day;
+}
+/** Parse a leading date prefix, or null when the text does not start with one. */
+export function parseDatePrefix(content) {
+    const m = PREFIX_RE.exec(content);
+    if (!m)
+        return null;
+    const [matched, year, month, day, annotation] = m;
+    if (!isRealCalendarDay(Number(year), Number(month), Number(day)))
+        return null;
+    const trimmed = annotation === undefined ? null : annotation.trim();
+    return {
+        date: `${year}-${month}-${day}`,
+        annotation: trimmed === '' ? null : trimmed,
+        matched,
+    };
+}
+/**
+ * The dedup key: the text with its date prefix removed. The annotation comes off with the date
+ * because it records *when and in which session the line was written*, not what the line claims
+ * — the same sentence written in two sessions is one fact, and dedup has to see that.
+ */
+export function stripDatePrefix(content) {
+    const prefix = parseDatePrefix(content);
+    if (!prefix)
+        return content;
+    return content.slice(prefix.matched.length).replace(/^\s+/, '');
+}
+/** Prepend today's calendar day unless the text already carries a valid date prefix. */
+export function stampDatePrefix(content, timeZone, now = new Date()) {
+    if (parseDatePrefix(content))
+        return content;
+    return `[${calendarDate(now, timeZone)}] ${content}`;
+}

package/dist/src/tools/knowledge-graph-tools.js

@@ -200,6 +200,11 @@ Observations provide the factual foundation that supports entity existence and p
 - (!important!) **Entity must exist** - this tool only adds to existing entities
 - (!important!) Duplicates are filtered - repeating existing text with a **new** sources entry
   adds evidence to the existing revision and returns null for that position
+- (!important!) A \`[YYYY-MM-DD]\` prefix is prepended unless the text already starts with a valid
+  one. The day comes from \`RAG_MEMORY_CALENDAR_TZ\` (default UTC) - see \`calendar_timezone\` in
+  getKnowledgeGraphStats. Text may open with \`[YYYY-MM-DD note]\`; the note is treated as recording
+  metadata and is ignored when deduplicating, so the same sentence filed under two session markers
+  stays one observation
 - (!important!) Observations are cumulative. **This tool never replaces anything** - use
   correctObservation to supersede and retractObservation to withdraw
 - (!important!) **Be specific and factual** - observations should be verifiable statements

package/dist/src/tools/rag-tools.js

@@ -594,6 +594,7 @@ const syncDocumentFromFileSchema = {
     documentId: z.string().describe('RAG document ID to (re)create from the file'),
     metadata: z.record(z.any()).optional().describe('Metadata merged into the stored document'),
     content: z.string().optional().describe('Optional content override; stored instead of reading the file'),
+    excludePattern: z.union([z.string(), z.array(z.string())]).optional().describe('Regular expression(s) whose matches are stripped before indexing. Applied to the file (or to `content`) first, so hash, byte count and chunking all describe what was actually indexed. Compiled with the dotAll flag, so a pattern may span lines to drop a marked block. An invalid expression fails the call rather than indexing the whole file.'),
     entityNames: z.array(z.string()).optional().describe('Optional entities to explicitly link'),
     chunkParams: z.record(z.any()).optional().describe('Optional chunking parameters { maxTokens }. overlap: omit or 0 only (rejected otherwise since v5.0.0)'),
 };

package/docs/UPDATING.md

@@ -108,6 +108,41 @@ path and holder pid (e.g. `.download-<key>.lock`). Verify the holder process
 is genuinely gone or hung (`ps -p <pid>`), then remove the lock file manually;
 the next start becomes a clean download owner.
 
+## v5.1.0 (schema v14, unchanged): destructive-replace reporting + `excludePattern`
+
+**What changes on upgrade**: nothing you have to do. No migration, no schema
+change, no re-embedding. Both changes are additive — existing calls keep their
+arguments and keep working, and the new response fields are extra keys.
+
+**`storeDocument` now says what it destroyed.** It has always deleted the
+previous document's chunks, vectors and entity links before writing, but the
+response was `{ id, stored: true }`, so a caller replacing a document could not
+tell from the return value that anything was removed. It now returns
+`{ id, stored, replaced, deletedChunks }`, matching what `syncDocumentFromFile`
+already reported. `replaced` is decided by the document row, not the chunk
+count — a document that was stored but never chunked still gets overwritten,
+and reporting that as a fresh write would be wrong.
+
+**`syncDocumentFromFile` accepts `excludePattern`** (string or array of
+strings): regions matching these regular expressions are stripped before
+indexing. Previously the only way to leave part of a file out was to read it
+yourself and pass the whole edited text through `content`, which defeats the
+point of a tool that reads server-side to keep content off the model context.
+
+Three properties worth knowing:
+
+1. **The exclusion happens first**, before hashing and chunking, so
+   `content_hash`, the reported `bytes` and the chunk boundaries all describe
+   what was actually indexed. Changing only the pattern therefore invalidates
+   the dedup gate and re-indexes; it does not silently return `unchanged`.
+2. **Patterns are compiled with the dotAll flag**, so one pattern can span
+   lines to drop a marked block (`<!-- SECRET -->[\s\S]*?<!-- /SECRET -->`).
+   JavaScript has no inline `(?s)`, so without this every such pattern would
+   quietly match nothing.
+3. **An invalid expression fails the call.** Degrading to "no exclusion" would
+   index the whole file while the caller believes it was filtered, and an index
+   is a disclosure path — a failed sync is the safer error.
+
 ## v5.0.0 (schema v14): chunker c1 + vector reuse
 
 **Breaking**: `chunkParams.overlap` is rejected on BOTH public paths

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "rag-memory-epf-mcp",
-  "version": "5.0.0",
+  "version": "5.2.0",
   "engines": {
     "node": ">=24"
   },
-  "description": "Project-local RAG memory MCP server \u2014 knowledge graph + multilingual vector + FTS5 in a single SQLite file. Per-project isolation, 38 MCP tools, codepoint-safe chunking (Korean/CJK/emoji).",
+  "description": "Project-local RAG memory MCP server — knowledge graph + multilingual vector + FTS5 in a single SQLite file. Per-project isolation, 38 MCP tools, codepoint-safe chunking (Korean/CJK/emoji).",
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -45,7 +45,7 @@
     "prepare": "npm run build",
     "watch": "tsc --watch",
     "verify:invariants": "node test/chunk-invariants.test.mjs",
-    "verify:engine": "node test/engine-smoke.test.mjs && node test/launch-smoke.test.mjs && node test/sync-atomicity.test.mjs && node test/dedup.test.mjs && node test/search-degradation.test.mjs && node test/entity-embed-cap.test.mjs && node test/migration12.test.mjs && node test/model-cache.test.mjs && node test/embedding-gate.test.mjs && node test/lazy-boot.test.mjs && node test/reconciliation.test.mjs && node test/backfill.test.mjs && node test/fts-query.test.mjs && node test/search-contracts.test.mjs && node test/tool-contracts.test.mjs && node test/bounded-exit.test.mjs && node test/observation-schema.test.mjs && node test/observation-migration.test.mjs && node test/observation-lifecycle.test.mjs && node test/observation-contracts.test.mjs && node test/observation-search.test.mjs && node test/observation-cascade.test.mjs && node test/observation-realdata.test.mjs && node test/chunker-c.test.mjs && node test/migration14.test.mjs && node test/chunk-params-validation.test.mjs && node test/vector-reuse.test.mjs && node test/entity-range-linking.test.mjs && node test/stats-chunking.test.mjs && node test/migration14-realdata.test.mjs && node test/migration14-realdata-sync.test.mjs && node test/search-summaries-off.test.mjs",
+    "verify:engine": "node test/engine-smoke.test.mjs && node test/launch-smoke.test.mjs && node test/sync-atomicity.test.mjs && node test/dedup.test.mjs && node test/search-degradation.test.mjs && node test/entity-embed-cap.test.mjs && node test/migration12.test.mjs && node test/model-cache.test.mjs && node test/embedding-gate.test.mjs && node test/lazy-boot.test.mjs && node test/reconciliation.test.mjs && node test/backfill.test.mjs && node test/fts-query.test.mjs && node test/search-contracts.test.mjs && node test/tool-contracts.test.mjs && node test/bounded-exit.test.mjs && node test/observation-schema.test.mjs && node test/observation-migration.test.mjs && node test/observation-lifecycle.test.mjs && node test/observation-contracts.test.mjs && node test/observation-search.test.mjs && node test/observation-cascade.test.mjs && node test/observation-realdata.test.mjs && node test/chunker-c.test.mjs && node test/migration14.test.mjs && node test/chunk-params-validation.test.mjs && node test/vector-reuse.test.mjs && node test/entity-range-linking.test.mjs && node test/stats-chunking.test.mjs && node test/migration14-realdata.test.mjs && node test/migration14-realdata-sync.test.mjs && node test/search-summaries-off.test.mjs && node test/document-return-contracts.test.mjs && node test/observation-date-prefix.test.mjs",
     "test": "npm run build && npm run verify:invariants && npm run verify:engine",
     "prepublishOnly": "npm run build && npm run verify:invariants && npm run verify:engine"
   },