@remnic/core 9.7.14 → 9.8.0

package/dist/storage-guards.js

@@ -1,8 +1,8 @@
 import {
   assertMemoryFrontmatterId,
   warnProjectionFallback
-} from "./chunk-4KJLYTLS.js";
-import "./chunk-37CTGERM.js";
+} from "./chunk-V57NLO5P.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   assertMemoryFrontmatterId,

package/dist/storage.d.ts

@@ -1,10 +1,13 @@
-import './types-Bl4BWDM8.js';
+import './types-D_fG2ix8.js';
+export { C as ContentHashIndex, v as ContentHashIndexLockOptions, w as FactHashIndexNotAuthoritativeError, x as MemoryLifecycleEventWriteOptions, M as MemoryWriteResult, R as ReextractJobRequest, y as SealedWriteExtras, S as StorageManager, W as WriteMemoryOptions, z as buildEntitySchemaCacheKey, A as compareEntityTimestamps, B as compileEntityFacts, E as countEntityStructuredFacts, G as fingerprintEntityStructuredFacts, H as isEntitySynthesisStale, I as isValidBufferSurpriseEvent, J as normalizeEntityName, K as normalizeFrontmatterForPath, L as normalizeStructuredSectionFacts, r as parseEntityFile, N as parseFrontmatter, O as parseFrontmatterStringValue, t as serializeEntityFile } from './storage-NIyKYD8g.js';
 import './page-versioning.js';
-export { C as ContentHashIndex, w as MemoryLifecycleEventWriteOptions, M as MemoryWriteResult, R as ReextractJobRequest, S as StorageManager, x as buildEntitySchemaCacheKey, y as compareEntityTimestamps, z as compileEntityFacts, A as countEntityStructuredFacts, B as fingerprintEntityStructuredFacts, E as isEntitySynthesisStale, G as isValidBufferSurpriseEvent, r as normalizeAttributePairs, H as normalizeEntityName, I as normalizeFrontmatterForPath, J as normalizeStructuredSectionFacts, s as parseEntityFile, K as parseFrontmatter, L as parseFrontmatterStringValue, u as serializeEntityFile } from './storage-CrvzaM9C.js';
 import './consolidation-operator.js';
 import './memory-projection-store.js';
-export { stripAttributesSuffix } from './structured-attributes.js';
+import './write-envelope.js';
+export { normalizeAttributePairs, stripAttributesSuffix } from './structured-attributes.js';
+import './types-continuity.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
 import './maintenance/memory-governance.js';
 import './runtime/better-sqlite.js';
 import 'better-sqlite3';

package/dist/storage.js

@@ -1,5 +1,6 @@
 import {
   ContentHashIndex,
+  FactHashIndexNotAuthoritativeError,
   StorageManager,
   buildEntitySchemaCacheKey,
   compareEntityTimestamps,
@@ -8,7 +9,6 @@ import {
   fingerprintEntityStructuredFacts,
   isEntitySynthesisStale,
   isValidBufferSurpriseEvent,
-  normalizeAttributePairs,
   normalizeEntityName,
   normalizeFrontmatterForPath,
   normalizeStructuredSectionFacts,
@@ -16,57 +16,69 @@ import {
   parseFrontmatter,
   parseFrontmatterStringValue,
   serializeEntityFile
-} from "./chunk-7ICYQUOL.js";
-import "./chunk-L2B3EE7B.js";
+} from "./chunk-4BJQODZF.js";
 import "./chunk-B3ABVQ36.js";
-import "./chunk-5UZXUTVO.js";
-import "./chunk-VSMRDBFT.js";
-import "./chunk-LTJAMRGI.js";
-import "./chunk-EHK6KZHK.js";
+import "./chunk-2QMKMVHH.js";
+import "./chunk-DEBHXHJR.js";
+import "./chunk-DNHVPZOD.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-4KJLYTLS.js";
-import {
-  stripAttributesSuffix
-} from "./chunk-SVOZFLIQ.js";
-import "./chunk-B3F4CWQR.js";
-import "./chunk-RULE4VG5.js";
-import "./chunk-SCU65EZI.js";
-import "./chunk-RHOZ5LLO.js";
+import "./chunk-V57NLO5P.js";
+import "./chunk-FF4KLI5W.js";
+import "./chunk-YVKF3HEW.js";
+import "./chunk-AVPXXV6J.js";
+import "./chunk-EGGE52UU.js";
+import "./chunk-GCASGYIO.js";
+import "./chunk-WL5EBRDH.js";
+import "./chunk-347WD2LE.js";
 import "./chunk-RL6NEVXT.js";
+import "./chunk-ILGC6JH6.js";
+import "./chunk-SCU65EZI.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
-import "./chunk-VA4WSW54.js";
+import "./chunk-CGASUJVP.js";
+import {
+  normalizeAttributePairs,
+  stripAttributesSuffix
+} from "./chunk-R3DJVOSM.js";
+import "./chunk-BT7NVCML.js";
+import "./chunk-JYIJNNN3.js";
 import "./chunk-AAD2ZS6P.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-VZ5OJE4X.js";
-import "./chunk-OKUEZOGW.js";
-import "./chunk-X47LWMKA.js";
+import "./chunk-5VQJBH2G.js";
+import "./chunk-AITCS2RC.js";
+import "./chunk-XMMESCPD.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-PDJTHRAW.js";
 import "./chunk-W5H6ZRPT.js";
-import "./chunk-UXKMMNJD.js";
-import "./chunk-K2ZLHESQ.js";
-import "./chunk-VFSP73LP.js";
+import "./chunk-C23BYTJV.js";
+import "./chunk-QIEUU4UK.js";
 import "./chunk-L2EXJQJP.js";
+import "./chunk-45GF7Y3V.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-N7RWREIQ.js";
-import "./chunk-OEHCMALU.js";
-import "./chunk-PHK3HARR.js";
-import "./chunk-4DJQYKMN.js";
+import "./chunk-5I4M26Q7.js";
 import "./chunk-5GKPFL3S.js";
+import "./chunk-4DJQYKMN.js";
+import "./chunk-PQVCH2AE.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";
-import "./chunk-37CTGERM.js";
-import "./chunk-J2HSAU72.js";
+import "./chunk-6MKAMLQL.js";
+import "./chunk-JAKIDQB2.js";
+import "./chunk-BJMBJZ2Y.js";
+import "./chunk-UKJAGEXH.js";
+import "./chunk-FP2373TW.js";
+import "./chunk-AIK5W3IW.js";
 import "./chunk-A6XUJE5D.js";
+import "./chunk-5UZXUTVO.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VS2IYZRU.js";
-import "./chunk-6MKAMLQL.js";
-import "./chunk-JAKIDQB2.js";
+import "./chunk-SCCO46KZ.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   ContentHashIndex,
+  FactHashIndexNotAuthoritativeError,
   StorageManager,
   buildEntitySchemaCacheKey,
   compareEntityTimestamps,

package/dist/structured-attributes.d.ts

@@ -25,5 +25,27 @@
  * returns the trimmed input unchanged — never truncates legitimate content.
  */
 declare function stripAttributesSuffix(content: string): string;
+/**
+ * Canonical `key: value; …` rendering of structured attributes. Keys are
+ * trimmed + lowercased, values trimmed, pairs sorted by normalized key.
+ * Moved verbatim from `storage.ts` (which re-exports it for API stability);
+ * used at the write path, the dedup-lookup path, and envelope assembly.
+ */
+declare function normalizeAttributePairs(pairs: Record<string, string>): string;
+interface AssembledPersistBody {
+    /** The exact body persistence writes: enriched then sanitized. */
+    text: string;
+    /** False when sanitization redacted injection-bearing text. */
+    clean: boolean;
+    /** Matched injection pattern sources (for the storage warn log). */
+    violations: string[];
+}
+/**
+ * Assemble the persisted body exactly as `writeMemory` does: append the
+ * normalized attribute suffix when attributes are present, then sanitize the
+ * combined result. ONE definition — byte-identity between the legacy write
+ * path and the sealed-envelope path is structural, not tested-by-hope.
+ */
+declare function assemblePersistedBody(content: string, structuredAttributes?: Record<string, string>): AssembledPersistBody;
 
-export { stripAttributesSuffix };
+export { type AssembledPersistBody, assemblePersistedBody, normalizeAttributePairs, stripAttributesSuffix };

package/dist/structured-attributes.js

@@ -1,8 +1,14 @@
 import {
+  assemblePersistedBody,
+  normalizeAttributePairs,
   stripAttributesSuffix
-} from "./chunk-SVOZFLIQ.js";
+} from "./chunk-R3DJVOSM.js";
+import "./chunk-5GKPFL3S.js";
+import "./chunk-JAKIDQB2.js";
 import "./chunk-PZ5AY32C.js";
 export {
+  assemblePersistedBody,
+  normalizeAttributePairs,
   stripAttributesSuffix
 };
 //# sourceMappingURL=structured-attributes.js.map

package/dist/summarizer.d.ts

@@ -1,7 +1,9 @@
 import { ModelRegistry } from './model-registry.js';
-import { P as PluginConfig, G as GatewayConfig, T as TranscriptEntry, H as HourlySummary } from './types-Bl4BWDM8.js';
+import { P as PluginConfig, G as GatewayConfig, T as TranscriptEntry, H as HourlySummary } from './types-D_fG2ix8.js';
 import { TranscriptManager } from './transcript.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 import './session-integrity.js';
 
 declare class HourlySummarizer {

package/dist/summarizer.js

@@ -1,23 +1,23 @@
 import {
   HourlySummarizer
-} from "./chunk-3D6AFGQR.js";
-import "./chunk-3FAMU5TX.js";
-import "./chunk-KAWTOYAW.js";
-import "./chunk-NWTGD4AN.js";
+} from "./chunk-QVT3E4CE.js";
+import "./chunk-A6USBZTO.js";
+import "./chunk-WLZYGLJ4.js";
+import "./chunk-6KIQT7RG.js";
 import "./chunk-S4DDLTPX.js";
-import "./chunk-FF4KLI5W.js";
 import "./chunk-O75CRYGF.js";
-import "./chunk-LTJAMRGI.js";
-import "./chunk-UXKMMNJD.js";
-import "./chunk-K2ZLHESQ.js";
-import "./chunk-VFSP73LP.js";
+import "./chunk-FF4KLI5W.js";
+import "./chunk-WL5EBRDH.js";
+import "./chunk-C23BYTJV.js";
+import "./chunk-QIEUU4UK.js";
 import "./chunk-L2EXJQJP.js";
+import "./chunk-45GF7Y3V.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-N7RWREIQ.js";
-import "./chunk-BFPETA3S.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";
-import "./chunk-37CTGERM.js";
+import "./chunk-SCCO46KZ.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   HourlySummarizer

package/dist/summary-snapshot.d.ts

@@ -1,5 +1,7 @@
-import { H as HourlySummary } from './types-Bl4BWDM8.js';
+import { H as HourlySummary } from './types-D_fG2ix8.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 
 declare function summarySnapshotPath(memoryDir: string, sessionKey: string): string;
 declare function readSummarySnapshot(memoryDir: string, sessionKey: string): Promise<HourlySummary[] | null>;

package/dist/summary-snapshot.js

@@ -3,9 +3,9 @@ import {
   summarySnapshotPath,
   upsertSummarySnapshot,
   writeSummarySnapshot
-} from "./chunk-3FAMU5TX.js";
+} from "./chunk-A6USBZTO.js";
 import "./chunk-FF4KLI5W.js";
-import "./chunk-LTJAMRGI.js";
+import "./chunk-WL5EBRDH.js";
 import "./chunk-PZ5AY32C.js";
 export {
   readSummarySnapshot,

package/dist/temporal-index-batch.d.ts

@@ -0,0 +1 @@
+export { k as deindexMemoriesBatchAsync, p as indexMemoriesBatchAsync } from './temporal-index-compat.js';

package/dist/temporal-index-batch.js

@@ -0,0 +1,10 @@
+import {
+  deindexMemoriesBatchAsync,
+  indexMemoriesBatchAsync
+} from "./chunk-ZOKZIR5K.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  deindexMemoriesBatchAsync,
+  indexMemoriesBatchAsync
+};
+//# sourceMappingURL=temporal-index-batch.js.map

package/dist/temporal-index-batch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/temporal-index-compat.d.ts

@@ -1 +1,279 @@
-export { clearIndexes, deindexMemory, indexMemoriesBatch, indexMemory, indexesExist } from './temporal-index.js';
+/**
+ * Synchronous compatibility surface for the historical temporal-index API.
+ *
+ * New runtime code must use the explicit `*Async` exports from temporal-index.
+ * These wrappers preserve return timing and boolean truthiness for published
+ * JavaScript consumers that predate the async index implementation.
+ */
+
+/** @deprecated Use `indexMemoryAsync` in new code. */
+declare function indexMemory(memoryDir: string, memoryPath: string, createdAt: string, tags: string[], temporal?: Omit<Partial<TemporalIndexEntry>, "path" | "createdAt" | "tags">): void;
+/** @deprecated Use `deindexMemoryAsync` in new code. */
+declare function deindexMemory(memoryDir: string, memoryPath: string, createdAt: string, tags: string[]): void;
+/** @deprecated Use `clearIndexesAsync` in new code. */
+declare function clearIndexes(memoryDir: string): void;
+/** @deprecated Use `indexesExistAsync` in new code. */
+declare function indexesExist(memoryDir: string): boolean;
+/** @deprecated Use `indexMemoriesBatchAsync` in new code. */
+declare function indexMemoriesBatch(memoryDir: string, entries: TemporalIndexEntry[]): void;
+
+/**
+ * Temporal and Tag Indexes (v8.1 — SwiftMem-inspired)
+ *
+ * Maintains two fast on-disk lookup structures in `state/`:
+ *   index_time.json — maps YYYY-MM-DD date buckets to memory file paths
+ *   index_tags.json — maps tag strings to memory file paths
+ *
+ * Used as an optional prefilter in the retrieval pipeline:
+ * given a time range or a set of tags, narrow the candidate set
+ * before the QMD hybrid search so we can pass a smaller pool to scoring.
+ *
+ * Design constraints:
+ * - Must be fail-open (any error returns empty / unfiltered)
+ * - Reads/writes are batched per extraction run
+ * - Both indexes are plain JSON; no external dependencies
+ */
+
+interface TemporalIndex {
+    /** version bumped when schema changes */
+    version: number;
+    /** Last full rebuild timestamp (ISO string) */
+    lastRebuildAt?: string;
+    /** Map from YYYY-MM-DD → array of memory paths */
+    dates: Record<string, string[]>;
+    /**
+     * Per-memory event-time rows used to reconstruct one chronology across
+     * source sessions. Keyed by path so an update replaces the prior row.
+     */
+    events: Record<string, TemporalIndexEvent>;
+}
+interface TemporalIndexEvent {
+    path: string;
+    /** Event/valid time used for chronology. */
+    eventAt: string;
+    /** Ingest/source-observation time, when known. */
+    observedAt?: string;
+    /** Source session provenance, when the extractor recorded it. */
+    sessionKey?: string;
+    /** Exclusive validity end, when the event is bounded. */
+    validUntil?: string;
+    /** SHA-256 lexical fingerprints for bounded query-aware candidate selection. */
+    searchTokenHashes?: string[];
+}
+interface TemporalIndexEntry {
+    path: string;
+    createdAt: string;
+    tags: string[];
+    validAt?: string;
+    observedAt?: string;
+    sessionKey?: string;
+    validUntil?: string;
+    /** Used only to derive token hashes; raw text is never persisted in the index. */
+    searchText?: string;
+}
+interface TagIndex {
+    version: number;
+    lastRebuildAt?: string;
+    /** Map from canonical tag string → node metadata */
+    tags: Record<string, TagNode | string[]>;
+    /** Map from alias string → canonical tags */
+    aliases?: Record<string, string[]>;
+}
+interface TagNode {
+    paths: string[];
+    aliases?: string[];
+    parents?: string[];
+}
+declare const INDEX_VERSION = 2;
+/** Test-only observer for asserting cache read/parse behavior. */
+declare function setIndexReadObserverForTest(observer?: () => void): void;
+/** Test-only observer fired once per committed atomic index write. */
+declare function setIndexWriteObserverForTest(observer?: (filePath: string) => void): void;
+/**
+ * Test-only hook to deterministically fail an atomic index write for matching
+ * paths. Return true to fail the write for a given path. Lets partial-failure
+ * branches be exercised without relying on filesystem permissions, which no-op
+ * for privileged users (common in containerized CI) and differ on Windows.
+ */
+declare function setIndexWriteFailureForTest(shouldFail?: (filePath: string) => boolean): void;
+declare function ensureStateDir(memoryDir: string): Promise<void>;
+/**
+ * Operation-level mutex keyed by memoryDir (issue #1911, Codex Medium). Wraps a
+ * whole logical index mutation (which writes BOTH the temporal and tag index
+ * files) so overlapping mutators on the same memoryDir cannot interleave their
+ * per-file writes and commit mismatched halves. The inner per-file writeChains
+ * still protect each file; this outer chain just orders complete operations.
+ */
+declare function withMemoryDirMutex<T>(memoryDir: string, op: () => Promise<T>): Promise<T>;
+declare function updateTemporalIndex(memoryDir: string, update: (index: TemporalIndex) => void): Promise<boolean>;
+declare function updateTagIndex(memoryDir: string, update: (index: TagIndex) => void): Promise<void>;
+declare function isoDateFromTimestamp(isoString: string): string;
+declare function temporalEventFromEntry(entry: TemporalIndexEntry): TemporalIndexEvent;
+declare function addPathToSet(record: Record<string, string[]>, key: string, p: string): void;
+declare function removePathFromSet(record: Record<string, string[]>, key: string, p: string): void;
+declare function removePathFromAllSets(record: Record<string, string[]>, p: string): void;
+declare function addTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string): void;
+declare function removeTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string): void;
+declare function removePathFromAllTagEntries(index: TagIndex, memoryPath: string): void;
+type TemporalIndexCompatibilityMutation = {
+    kind: "index";
+    entries: TemporalIndexEntry[];
+} | {
+    kind: "deindex";
+    entries: TemporalIndexEntry[];
+} | {
+    kind: "clear";
+};
+/** @internal Pure model shared by the deprecated synchronous compatibility surface. */
+declare function applyTemporalIndexCompatibilityMutation(raw: unknown, mutation: TemporalIndexCompatibilityMutation): TemporalIndex;
+/** @internal Pure model shared by the deprecated synchronous compatibility surface. */
+declare function applyTagIndexCompatibilityMutation(raw: unknown, mutation: TemporalIndexCompatibilityMutation): TagIndex;
+/** @internal Schema check shared by the deprecated synchronous compatibility surface. */
+declare function hasCurrentTemporalIndexSchemaForCompatibility(raw: unknown): boolean;
+/**
+ * Add (or update) a memory file in both indexes.
+ *
+ * @param memoryDir Root memory directory
+ * @param memoryPath Absolute path to the memory file
+ * @param createdAt ISO timestamp of the memory's creation date
+ * @param tags Array of tag strings from the memory's frontmatter
+ */
+declare function indexMemoryAsync(memoryDir: string, memoryPath: string, createdAt: string, tags: string[], temporal?: Omit<Partial<TemporalIndexEntry>, "path" | "createdAt" | "tags">): Promise<void>;
+/**
+ * Remove a memory file from both indexes (called on deletion/archival).
+ */
+declare function deindexMemoryAsync(memoryDir: string, memoryPath: string, createdAt: string, tags: string[]): Promise<void>;
+/**
+ * Reset both index files to empty state.
+ * Called before a full-corpus rebuild so stale paths in any surviving index
+ * file do not persist after the rebuild completes.
+ */
+declare function clearIndexesAsync(memoryDir: string): Promise<void>;
+/**
+ * Returns true when both index files exist on disk.
+ * Used to detect first-time enablement so callers can trigger a full rebuild.
+ */
+declare function indexesExistAsync(memoryDir: string): Promise<boolean>;
+/**
+ * Return the set of memory paths whose index date falls in [fromDate, toDate).
+ *
+ * Boundary semantics (exclusive upper bound):
+ * - `fromDate` is INCLUSIVE — entries on this date ARE returned.
+ * - `toDate`   is EXCLUSIVE — entries on this date are NOT returned.
+ *   Pass `recencyWindowBoundsFromPrompt(query).toDate` to get the correct
+ *   exclusive boundary; do NOT add +1 day yourself.
+ * - Default `toDate` = tomorrow, so omitting it includes all of today.
+ *
+ * @param memoryDir - root memory directory (contains state/index_time.json)
+ * @param fromDate  - inclusive start date, YYYY-MM-DD
+ * @param toDate    - exclusive end date, YYYY-MM-DD (default: tomorrow)
+ * @returns Set of matching file paths, or null if the index is unavailable.
+ */
+declare function queryByDateRangeAsync(memoryDir: string, fromDate: string, toDate?: string): Promise<Set<string> | null>;
+/**
+ * Return the persisted event-time rows as one deterministic cross-session
+ * chronology. Equal event times are ordered by observation time, then path.
+ * Returns `null` when the index is missing, corrupt, or from an older schema;
+ * callers can then fail open to the pre-index recall path.
+ */
+declare function queryTemporalTimelineAsync(memoryDir: string, options?: {
+    query?: string;
+    limit?: number;
+}): Promise<TemporalIndexEvent[] | null>;
+/**
+ * Async version of queryByTags — uses non-blocking fs.promises.readFile
+ * to avoid blocking the Node.js event loop.
+ */
+declare function queryByTagsAsync(memoryDir: string, tags: string[]): Promise<Set<string> | null>;
+/**
+ * Extract tags from a prompt for tag-based prefiltering.
+ * Looks for hashtag-style tokens (#foo).
+ * Returns lowercase, deduplicated list.
+ */
+declare function extractTagsFromPrompt(prompt: string): string[];
+declare function resolvePromptTagPrefilterAsync(memoryDir: string, prompt: string): Promise<{
+    matchedTags: string[];
+    expandedTags: string[];
+    paths: Set<string> | null;
+}>;
+/**
+ * Run a group of index reads as ONE consistent snapshot (issue #1911, Codex
+ * Medium). The `read` callback executes inside a single withMemoryDirMutex
+ * acquisition — the same in-memory op-lock every async mutator holds across its
+ * paired temporal+tag writes — so no mutation can land between the reads inside
+ * it. A recall that reads the temporal and tag indexes together therefore never
+ * observes a half-updated state (e.g. a new temporal row with a not-yet-written
+ * tag membership) that would let prefiltering drop the current memory. The
+ * genuine-tag-miss contract is preserved: a truly absent tag still yields an
+ * empty set, only now never as a transient artifact of an in-flight write.
+ * Index reads are cache-backed (microseconds), so ordering them on the op-chain
+ * is negligible beside the multi-second QMD phase.
+ */
+declare function readIndexSnapshotAsync<T>(memoryDir: string, read: () => Promise<T>): Promise<T>;
+/**
+ * Detect if a prompt is time-sensitive (mentions specific time references).
+ * Used to decide whether to activate the temporal prefilter.
+ */
+declare function isTemporalQuery(prompt: string): boolean;
+/**
+ * Compute a "from date" string (YYYY-MM-DD) for a recency-based temporal query.
+ * For "recent" / "lately" returns 7 days ago; for today/yesterday the obvious window.
+ */
+declare function recencyWindowFromPrompt(prompt: string, nowMs?: number): string;
+/**
+ * Returns both the start and end of the temporal window implied by the prompt.
+ *
+ * `fromDate` is computed by delegating to `recencyWindowFromPrompt`, so the two
+ * functions cannot diverge on the lower bound.  `toDate` is computed independently
+ * here using the same pattern-priority ordering, because the upper-bound arithmetic
+ * differs (exclusive end vs. inclusive start) and would not be expressible as a
+ * simple wrapper.
+ *
+ * Known divergence to be aware of: for "N hours ago", `recencyWindowFromPrompt`
+ * uses `Math.max(1, Math.ceil(hours/24))` days back, so `fromDate` = yesterday for
+ * sub-24h values.  `toDate` here is always `tomorrow` when no explicit date is
+ * specified (see the `toDaysBack === 0` branch), giving a 2-day window.  This is
+ * intentional — the window must cover both yesterday and today for recent hour-level
+ * queries.  Any fix to the hours formula in `recencyWindowFromPrompt` must be
+ * manually reflected here.
+ *
+ * - `fromDate`: first day of the implied window (same as `recencyWindowFromPrompt`)
+ * - `toDate`: first day NOT in the window (exclusive upper bound), so callers
+ *   should filter with `date >= fromDate && date < toDate`.
+ */
+declare function recencyWindowBoundsFromPrompt(prompt: string, nowMs?: number): {
+    fromDate: string;
+    toDate: string;
+};
+
+/**
+ * Batch temporal/tag index mutations.
+ *
+ * Split from temporal-index.ts (issue #1911B / #1995): maintenance loops that
+ * add or invalidate N memories at once collect their entries and call these once
+ * instead of paying the per-memory read-parse-stringify-write amplification.
+ * Both operations reuse the low-level primitives exported from temporal-index.ts;
+ * per-entry semantics are byte-identical to indexMemoryAsync / deindexMemoryAsync.
+ */
+
+/**
+ * Batch-add multiple memories to both indexes in a single read-modify-write cycle.
+ * More efficient than calling indexMemoryAsync() per file when adding many at once.
+ */
+declare function indexMemoriesBatchAsync(memoryDir: string, entries: TemporalIndexEntry[]): Promise<void>;
+/**
+ * Batch-remove multiple memories from both indexes in a single read-modify-write
+ * cycle per index. Mirrors {@link indexMemoriesBatchAsync}: maintenance loops that
+ * invalidate/archive N memories collect their entries and call this once, replacing
+ * the O(N) full read-parse-stringify-write amplification of per-memory
+ * deindexMemoryAsync with O(1) temporal + O(1) tag write cycles.
+ *
+ * Per-entry semantics are byte-identical to deindexMemoryAsync: the date
+ * set for each entry's `createdAt` drops the path, the temporal event is deleted,
+ * and each tag graph entry is removed. The temporal half commits first; the tag
+ * half only runs if it succeeds, so a partial failure never leaves tags orphaned
+ * from a temporal entry that still exists.
+ */
+declare function deindexMemoriesBatchAsync(memoryDir: string, entries: ReadonlyArray<Pick<TemporalIndexEntry, "path" | "createdAt" | "tags">>): Promise<void>;
+
+export { removePathFromAllSets as A, removePathFromAllTagEntries as B, removePathFromSet as C, removeTagGraphEntry as D, resolvePromptTagPrefilterAsync as E, setIndexReadObserverForTest as F, setIndexWriteFailureForTest as G, setIndexWriteObserverForTest as H, INDEX_VERSION as I, temporalEventFromEntry as J, updateTagIndex as K, updateTemporalIndex as L, withMemoryDirMutex as M, type TagIndex as T, type TagNode as a, type TemporalIndex as b, type TemporalIndexCompatibilityMutation as c, clearIndexes, type TemporalIndexEntry as d, deindexMemory, type TemporalIndexEvent as e, addPathToSet as f, addTagGraphEntry as g, applyTagIndexCompatibilityMutation as h, applyTemporalIndexCompatibilityMutation as i, indexMemoriesBatch, indexMemory, indexesExist, clearIndexesAsync as j, deindexMemoriesBatchAsync as k, deindexMemoryAsync as l, ensureStateDir as m, extractTagsFromPrompt as n, hasCurrentTemporalIndexSchemaForCompatibility as o, indexMemoriesBatchAsync as p, indexMemoryAsync as q, indexesExistAsync as r, isTemporalQuery as s, isoDateFromTimestamp as t, queryByDateRangeAsync as u, queryByTagsAsync as v, queryTemporalTimelineAsync as w, readIndexSnapshotAsync as x, recencyWindowBoundsFromPrompt as y, recencyWindowFromPrompt as z };

package/dist/temporal-index-compat.js

@@ -4,7 +4,7 @@ import {
   indexMemoriesBatch,
   indexMemory,
   indexesExist
-} from "./chunk-2VN4JAX7.js";
+} from "./chunk-ZOKZIR5K.js";
 import "./chunk-PZ5AY32C.js";
 export {
   clearIndexes,