@fgv/ts-agent-memory 5.1.0-37 → 5.1.0-39

package/lib/packlets/retrieve/temporalRetrievers.d.ts

@@ -0,0 +1,78 @@
+import { Result } from '@fgv/ts-utils';
+import { IMemoryRecord } from '../types';
+import { IMemoryIndex } from '../index';
+import { IMemoryQuery, IMemoryRetriever, IMemoryRetrieverCapabilities } from './retriever';
+/**
+ * The capabilities every temporal retriever exposes: temporal "as-of" queries
+ * are operational (semantic recall and link traversal are not this retriever's
+ * concern).
+ * @public
+ */
+export declare const TEMPORAL_CAPABILITIES: IMemoryRetrieverCapabilities;
+/**
+ * Temporal retriever returning the **current** version of each temporal entity
+ * matching the query (the newest version whose `invalid_at` is null/absent),
+ * recency-ordered and limited. A fully-invalidated (soft-deleted) entity
+ * contributes nothing. Non-temporal records are not this retriever's concern.
+ * @public
+ */
+export declare class CurrentValidRetriever implements IMemoryRetriever {
+    private readonly _index;
+    private constructor();
+    /** {@inheritDoc IMemoryRetriever.capabilities} */
+    get capabilities(): IMemoryRetrieverCapabilities;
+    /** Family-convention factory. */
+    static create(index: IMemoryIndex): Result<CurrentValidRetriever>;
+    /** {@inheritDoc IMemoryRetriever.retrieve} */
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+/**
+ * Temporal retriever returning, for each temporal entity matching the query, the
+ * version valid at `query.asOf` (epoch ms). `asOf` is this retriever's axis: a
+ * query without it yields an empty success (a no-op contribution to a
+ * {@link HybridRetriever}, not a failure). Results are recency-ordered and
+ * limited.
+ * @public
+ */
+export declare class AsOfRetriever implements IMemoryRetriever {
+    private readonly _index;
+    private constructor();
+    /** {@inheritDoc IMemoryRetriever.capabilities} */
+    get capabilities(): IMemoryRetrieverCapabilities;
+    /** Family-convention factory. */
+    static create(index: IMemoryIndex): Result<AsOfRetriever>;
+    /** {@inheritDoc IMemoryRetriever.retrieve} */
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+/**
+ * Temporal retriever returning **every** version of each temporal entity matching
+ * the query, ordered ascending by `valid_at` (then `seq` as a stable tiebreak) —
+ * the entity's full history. Limited after ordering.
+ *
+ * @remarks
+ * When the query matches more than one entity, the result is a single
+ * CROSS-entity list globally sorted by `valid_at` — versions of different
+ * entities interleave, NOT grouped per entity — so `limit` truncates that
+ * globally-sorted list. Constrain to one entity (e.g. via `query.scope`) for a
+ * single entity's contiguous history.
+ * @public
+ */
+export declare class HistoryRetriever implements IMemoryRetriever {
+    private readonly _index;
+    private constructor();
+    /** {@inheritDoc IMemoryRetriever.capabilities} */
+    get capabilities(): IMemoryRetrieverCapabilities;
+    /** Family-convention factory. */
+    static create(index: IMemoryIndex): Result<HistoryRetriever>;
+    /** {@inheritDoc IMemoryRetriever.retrieve} */
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+    /** A version's world-truth start: its `valid_at`, defaulting to `created` when absent. */
+    private static _startOf;
+    /**
+     * Ascending-by-`valid_at` comparator (a version's `valid_at` defaults to its
+     * `created` when absent), with `seq` as a stable ascending tiebreak so
+     * same-instant versions order by write sequence.
+     */
+    private static _byValidAtAscending;
+}
+//# sourceMappingURL=temporalRetrievers.d.ts.map

package/lib/packlets/retrieve/temporalRetrievers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalRetrievers.d.ts","sourceRoot":"","sources":["../../../src/packlets/retrieve/temporalRetrievers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAW,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAA6D,MAAM,UAAU,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,4BAA4B,EAK7B,MAAM,aAAa,CAAC;AAErB;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,4BAInC,CAAC;AA4BF;;;;;;GAMG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC,OAAO;IAIP,kDAAkD;IAClD,IAAW,YAAY,IAAI,4BAA4B,CAEtD;IAED,iCAAiC;WACnB,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAAC,qBAAqB,CAAC;IAIxE,8CAA8C;IACvC,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CAe7F;AAED;;;;;;;GAOG;AACH,qBAAa,aAAc,YAAW,gBAAgB;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC,OAAO;IAIP,kDAAkD;IAClD,IAAW,YAAY,IAAI,4BAA4B,CAEtD;IAED,iCAAiC;WACnB,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAAC,aAAa,CAAC;IAIhE,8CAA8C;IACvC,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CAmB7F;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAiB,YAAW,gBAAgB;IACvD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC,OAAO;IAIP,kDAAkD;IAClD,IAAW,YAAY,IAAI,4BAA4B,CAEtD;IAED,iCAAiC;WACnB,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAAC,gBAAgB,CAAC;IAInE,8CAA8C;IACvC,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAa5F,0FAA0F;IAC1F,OAAO,CAAC,MAAM,CAAC,QAAQ;IASvB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;CAKnC"}

package/lib/packlets/retrieve/temporalRetrievers.js

@@ -0,0 +1,178 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryRetriever = exports.AsOfRetriever = exports.CurrentValidRetriever = exports.TEMPORAL_CAPABILITIES = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const types_1 = require("../types");
+const retriever_1 = require("./retriever");
+/**
+ * The capabilities every temporal retriever exposes: temporal "as-of" queries
+ * are operational (semantic recall and link traversal are not this retriever's
+ * concern).
+ * @public
+ */
+exports.TEMPORAL_CAPABILITIES = {
+    supportsSemanticRecall: false,
+    supportsTemporalQuery: true,
+    supportsLinkTraversal: false
+};
+/**
+ * Group the temporal records surviving a query's scope / kind / tag / predicate
+ * pre-filter by entity (`kind` + `entityId`). Non-temporal records are excluded —
+ * the temporal retrievers operate only over versioned entities. The map values
+ * are each entity's versions (unordered).
+ */
+function groupTemporalVersionsByEntity(index, query) {
+    const groups = new Map();
+    for (const entry of index.entries()) {
+        if (!(0, types_1.isTemporalRecord)(entry.record) || !(0, retriever_1.indexedRecordMatchesQuery)(entry, query)) {
+            continue;
+        }
+        const key = `${entry.record.envelope.kind}\0${entry.record.envelope.entityId}`;
+        const existing = groups.get(key);
+        if (existing === undefined) {
+            groups.set(key, [entry.record]);
+        }
+        else {
+            existing.push(entry.record);
+        }
+    }
+    return groups;
+}
+/**
+ * Temporal retriever returning the **current** version of each temporal entity
+ * matching the query (the newest version whose `invalid_at` is null/absent),
+ * recency-ordered and limited. A fully-invalidated (soft-deleted) entity
+ * contributes nothing. Non-temporal records are not this retriever's concern.
+ * @public
+ */
+class CurrentValidRetriever {
+    constructor(index) {
+        this._index = index;
+    }
+    /** {@inheritDoc IMemoryRetriever.capabilities} */
+    get capabilities() {
+        return exports.TEMPORAL_CAPABILITIES;
+    }
+    /** Family-convention factory. */
+    static create(index) {
+        return (0, ts_utils_1.succeed)(new CurrentValidRetriever(index));
+    }
+    /** {@inheritDoc IMemoryRetriever.retrieve} */
+    retrieve(query) {
+        return Promise.resolve((0, retriever_1.guardRetrieverCapabilities)(query, this.capabilities).onSuccess(() => {
+            const selected = [];
+            for (const versions of groupTemporalVersionsByEntity(this._index, query).values()) {
+                const current = (0, types_1.selectCurrentVersion)(versions);
+                if (current !== undefined) {
+                    selected.push(current);
+                }
+            }
+            selected.sort(retriever_1.recencyCompare);
+            return (0, ts_utils_1.succeed)((0, retriever_1.limitRecords)(selected, query.limit));
+        }));
+    }
+}
+exports.CurrentValidRetriever = CurrentValidRetriever;
+/**
+ * Temporal retriever returning, for each temporal entity matching the query, the
+ * version valid at `query.asOf` (epoch ms). `asOf` is this retriever's axis: a
+ * query without it yields an empty success (a no-op contribution to a
+ * {@link HybridRetriever}, not a failure). Results are recency-ordered and
+ * limited.
+ * @public
+ */
+class AsOfRetriever {
+    constructor(index) {
+        this._index = index;
+    }
+    /** {@inheritDoc IMemoryRetriever.capabilities} */
+    get capabilities() {
+        return exports.TEMPORAL_CAPABILITIES;
+    }
+    /** Family-convention factory. */
+    static create(index) {
+        return (0, ts_utils_1.succeed)(new AsOfRetriever(index));
+    }
+    /** {@inheritDoc IMemoryRetriever.retrieve} */
+    retrieve(query) {
+        return Promise.resolve((0, retriever_1.guardRetrieverCapabilities)(query, this.capabilities).onSuccess(() => {
+            if (query.asOf === undefined) {
+                return (0, ts_utils_1.succeed)([]);
+            }
+            const asOf = query.asOf;
+            const selected = [];
+            for (const versions of groupTemporalVersionsByEntity(this._index, query).values()) {
+                const valid = (0, types_1.selectVersionAsOf)(versions, asOf);
+                if (valid !== undefined) {
+                    selected.push(valid);
+                }
+            }
+            selected.sort(retriever_1.recencyCompare);
+            return (0, ts_utils_1.succeed)((0, retriever_1.limitRecords)(selected, query.limit));
+        }));
+    }
+}
+exports.AsOfRetriever = AsOfRetriever;
+/**
+ * Temporal retriever returning **every** version of each temporal entity matching
+ * the query, ordered ascending by `valid_at` (then `seq` as a stable tiebreak) —
+ * the entity's full history. Limited after ordering.
+ *
+ * @remarks
+ * When the query matches more than one entity, the result is a single
+ * CROSS-entity list globally sorted by `valid_at` — versions of different
+ * entities interleave, NOT grouped per entity — so `limit` truncates that
+ * globally-sorted list. Constrain to one entity (e.g. via `query.scope`) for a
+ * single entity's contiguous history.
+ * @public
+ */
+class HistoryRetriever {
+    constructor(index) {
+        this._index = index;
+    }
+    /** {@inheritDoc IMemoryRetriever.capabilities} */
+    get capabilities() {
+        return exports.TEMPORAL_CAPABILITIES;
+    }
+    /** Family-convention factory. */
+    static create(index) {
+        return (0, ts_utils_1.succeed)(new HistoryRetriever(index));
+    }
+    /** {@inheritDoc IMemoryRetriever.retrieve} */
+    retrieve(query) {
+        return Promise.resolve((0, retriever_1.guardRetrieverCapabilities)(query, this.capabilities).onSuccess(() => {
+            const history = [];
+            for (const versions of groupTemporalVersionsByEntity(this._index, query).values()) {
+                history.push(...versions);
+            }
+            history.sort(HistoryRetriever._byValidAtAscending);
+            return (0, ts_utils_1.succeed)((0, retriever_1.limitRecords)(history, query.limit));
+        }));
+    }
+    /** A version's world-truth start: its `valid_at`, defaulting to `created` when absent. */
+    static _startOf(record) {
+        var _a;
+        const temporal = record.envelope.temporal;
+        /* c8 ignore next 3 -- unreachable: HistoryRetriever orders only temporal records (pre-filtered by isTemporalRecord), so `temporal` is always present; the guard keeps the type honest */
+        if (temporal === undefined) {
+            return record.envelope.created;
+        }
+        return (_a = temporal.valid_at) !== null && _a !== void 0 ? _a : record.envelope.created;
+    }
+    /**
+     * Ascending-by-`valid_at` comparator (a version's `valid_at` defaults to its
+     * `created` when absent), with `seq` as a stable ascending tiebreak so
+     * same-instant versions order by write sequence.
+     */
+    static _byValidAtAscending(a, b) {
+        const aStart = HistoryRetriever._startOf(a);
+        const bStart = HistoryRetriever._startOf(b);
+        return aStart !== bStart ? aStart - bStart : a.envelope.seq - b.envelope.seq;
+    }
+}
+exports.HistoryRetriever = HistoryRetriever;
+//# sourceMappingURL=temporalRetrievers.js.map

package/lib/packlets/retrieve/temporalRetrievers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalRetrievers.js","sourceRoot":"","sources":["../../../src/packlets/retrieve/temporalRetrievers.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result, succeed } from '@fgv/ts-utils';\nimport { IMemoryRecord, isTemporalRecord, selectCurrentVersion, selectVersionAsOf } from '../types';\nimport { IMemoryIndex } from '../index';\nimport {\n  IMemoryQuery,\n  IMemoryRetriever,\n  IMemoryRetrieverCapabilities,\n  guardRetrieverCapabilities,\n  indexedRecordMatchesQuery,\n  limitRecords,\n  recencyCompare\n} from './retriever';\n\n/**\n * The capabilities every temporal retriever exposes: temporal \"as-of\" queries\n * are operational (semantic recall and link traversal are not this retriever's\n * concern).\n * @public\n */\nexport const TEMPORAL_CAPABILITIES: IMemoryRetrieverCapabilities = {\n  supportsSemanticRecall: false,\n  supportsTemporalQuery: true,\n  supportsLinkTraversal: false\n};\n\n/**\n * Group the temporal records surviving a query's scope / kind / tag / predicate\n * pre-filter by entity (`kind` + `entityId`). Non-temporal records are excluded —\n * the temporal retrievers operate only over versioned entities. The map values\n * are each entity's versions (unordered).\n */\nfunction groupTemporalVersionsByEntity(\n  index: IMemoryIndex,\n  query: IMemoryQuery\n): Map<string, IMemoryRecord<unknown>[]> {\n  const groups: Map<string, IMemoryRecord<unknown>[]> = new Map<string, IMemoryRecord<unknown>[]>();\n  for (const entry of index.entries()) {\n    if (!isTemporalRecord(entry.record) || !indexedRecordMatchesQuery(entry, query)) {\n      continue;\n    }\n    const key: string = `${entry.record.envelope.kind}\\0${entry.record.envelope.entityId}`;\n    const existing: IMemoryRecord<unknown>[] | undefined = groups.get(key);\n    if (existing === undefined) {\n      groups.set(key, [entry.record]);\n    } else {\n      existing.push(entry.record);\n    }\n  }\n  return groups;\n}\n\n/**\n * Temporal retriever returning the **current** version of each temporal entity\n * matching the query (the newest version whose `invalid_at` is null/absent),\n * recency-ordered and limited. A fully-invalidated (soft-deleted) entity\n * contributes nothing. Non-temporal records are not this retriever's concern.\n * @public\n */\nexport class CurrentValidRetriever implements IMemoryRetriever {\n  private readonly _index: IMemoryIndex;\n\n  private constructor(index: IMemoryIndex) {\n    this._index = index;\n  }\n\n  /** {@inheritDoc IMemoryRetriever.capabilities} */\n  public get capabilities(): IMemoryRetrieverCapabilities {\n    return TEMPORAL_CAPABILITIES;\n  }\n\n  /** Family-convention factory. */\n  public static create(index: IMemoryIndex): Result<CurrentValidRetriever> {\n    return succeed(new CurrentValidRetriever(index));\n  }\n\n  /** {@inheritDoc IMemoryRetriever.retrieve} */\n  public retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>> {\n    return Promise.resolve(\n      guardRetrieverCapabilities(query, this.capabilities).onSuccess(() => {\n        const selected: IMemoryRecord<unknown>[] = [];\n        for (const versions of groupTemporalVersionsByEntity(this._index, query).values()) {\n          const current: IMemoryRecord<unknown> | undefined = selectCurrentVersion(versions);\n          if (current !== undefined) {\n            selected.push(current);\n          }\n        }\n        selected.sort(recencyCompare);\n        return succeed(limitRecords(selected, query.limit));\n      })\n    );\n  }\n}\n\n/**\n * Temporal retriever returning, for each temporal entity matching the query, the\n * version valid at `query.asOf` (epoch ms). `asOf` is this retriever's axis: a\n * query without it yields an empty success (a no-op contribution to a\n * {@link HybridRetriever}, not a failure). Results are recency-ordered and\n * limited.\n * @public\n */\nexport class AsOfRetriever implements IMemoryRetriever {\n  private readonly _index: IMemoryIndex;\n\n  private constructor(index: IMemoryIndex) {\n    this._index = index;\n  }\n\n  /** {@inheritDoc IMemoryRetriever.capabilities} */\n  public get capabilities(): IMemoryRetrieverCapabilities {\n    return TEMPORAL_CAPABILITIES;\n  }\n\n  /** Family-convention factory. */\n  public static create(index: IMemoryIndex): Result<AsOfRetriever> {\n    return succeed(new AsOfRetriever(index));\n  }\n\n  /** {@inheritDoc IMemoryRetriever.retrieve} */\n  public retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>> {\n    return Promise.resolve(\n      guardRetrieverCapabilities(query, this.capabilities).onSuccess(() => {\n        if (query.asOf === undefined) {\n          return succeed([]);\n        }\n        const asOf: number = query.asOf;\n        const selected: IMemoryRecord<unknown>[] = [];\n        for (const versions of groupTemporalVersionsByEntity(this._index, query).values()) {\n          const valid: IMemoryRecord<unknown> | undefined = selectVersionAsOf(versions, asOf);\n          if (valid !== undefined) {\n            selected.push(valid);\n          }\n        }\n        selected.sort(recencyCompare);\n        return succeed(limitRecords(selected, query.limit));\n      })\n    );\n  }\n}\n\n/**\n * Temporal retriever returning **every** version of each temporal entity matching\n * the query, ordered ascending by `valid_at` (then `seq` as a stable tiebreak) —\n * the entity's full history. Limited after ordering.\n *\n * @remarks\n * When the query matches more than one entity, the result is a single\n * CROSS-entity list globally sorted by `valid_at` — versions of different\n * entities interleave, NOT grouped per entity — so `limit` truncates that\n * globally-sorted list. Constrain to one entity (e.g. via `query.scope`) for a\n * single entity's contiguous history.\n * @public\n */\nexport class HistoryRetriever implements IMemoryRetriever {\n  private readonly _index: IMemoryIndex;\n\n  private constructor(index: IMemoryIndex) {\n    this._index = index;\n  }\n\n  /** {@inheritDoc IMemoryRetriever.capabilities} */\n  public get capabilities(): IMemoryRetrieverCapabilities {\n    return TEMPORAL_CAPABILITIES;\n  }\n\n  /** Family-convention factory. */\n  public static create(index: IMemoryIndex): Result<HistoryRetriever> {\n    return succeed(new HistoryRetriever(index));\n  }\n\n  /** {@inheritDoc IMemoryRetriever.retrieve} */\n  public retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>> {\n    return Promise.resolve(\n      guardRetrieverCapabilities(query, this.capabilities).onSuccess(() => {\n        const history: IMemoryRecord<unknown>[] = [];\n        for (const versions of groupTemporalVersionsByEntity(this._index, query).values()) {\n          history.push(...versions);\n        }\n        history.sort(HistoryRetriever._byValidAtAscending);\n        return succeed(limitRecords(history, query.limit));\n      })\n    );\n  }\n\n  /** A version's world-truth start: its `valid_at`, defaulting to `created` when absent. */\n  private static _startOf(record: IMemoryRecord<unknown>): number {\n    const temporal: IMemoryRecord<unknown>['envelope']['temporal'] = record.envelope.temporal;\n    /* c8 ignore next 3 -- unreachable: HistoryRetriever orders only temporal records (pre-filtered by isTemporalRecord), so `temporal` is always present; the guard keeps the type honest */\n    if (temporal === undefined) {\n      return record.envelope.created;\n    }\n    return temporal.valid_at ?? record.envelope.created;\n  }\n\n  /**\n   * Ascending-by-`valid_at` comparator (a version's `valid_at` defaults to its\n   * `created` when absent), with `seq` as a stable ascending tiebreak so\n   * same-instant versions order by write sequence.\n   */\n  private static _byValidAtAscending(a: IMemoryRecord<unknown>, b: IMemoryRecord<unknown>): number {\n    const aStart: number = HistoryRetriever._startOf(a);\n    const bStart: number = HistoryRetriever._startOf(b);\n    return aStart !== bStart ? aStart - bStart : a.envelope.seq - b.envelope.seq;\n  }\n}\n"]}

package/lib/packlets/store/fileTreeMemoryStore.d.ts

@@ -16,8 +16,9 @@ export interface IMemoryStoreListFilter {
     /** Restrict to records carrying this tag (exact match). */
     readonly tag?: Tag;
     /**
-     * For temporal kinds: return only records valid at this epoch ms. No-op in
-     * B1 (no temporal kinds wired).
+     * For temporal (versioned) kinds: collapse each entity to the single version
+     * valid at this epoch ms. Non-temporal records are timeless and pass through
+     * unchanged. Absent = no temporal projection (every version is returned).
      */
     readonly asOf?: number;
 }
@@ -29,7 +30,9 @@ export interface IMemoryStore {
     /**
      * Keyed read by entity id. Resolves `entityId` to a storage address via the
      * registered {@link IIdentityCodec} for `kind`. Returns `undefined` when no
-     * record exists.
+     * record exists. For a versioned (temporal) kind this returns the current
+     * version, resolved from the derived in-memory index (not re-read/re-verified
+     * from disk per call — the index is kept in sync with every write).
      */
     get(kind: Kind, entityId: EntityId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
     /**
@@ -50,7 +53,10 @@ export interface IMemoryStore {
     put(record: IMemoryRecord<unknown>): Promise<Result<IMemoryRecord<unknown>>>;
     /**
      * Delete a record by `(kind, entityId)`. Non-temporal kinds physically delete
-     * the file. Returns the {@link MemoryId} of the deleted record.
+     * the file and return the deleted record's {@link MemoryId}. Temporal
+     * (versioned) kinds SOFT-delete: the current version is invalidated
+     * (`invalid_at` set), history is retained, and the invalidated version's
+     * {@link MemoryId} is returned.
      */
     delete(kind: Kind, entityId: EntityId): Promise<Result<MemoryId>>;
 }
@@ -120,9 +126,11 @@ export interface IFileTreeMemoryStoreCreateParams {
  * write-lock so the index and the on-disk files never interleave.
  *
  * @remarks
- * B1 supports flat (non-versioned) layout only and string (markdown) bodies.
- * A codec reporting `isVersioned: true`, or a non-string body, fails loudly —
- * the versioned/temporal write path is a fast-follow.
+ * Bodies are string (markdown). Both layouts are supported: flat
+ * (one-file-per-entity, non-versioned) and versioned (subtree-per-entity,
+ * invalidate-don't-delete), dispatched per kind by the codec's `isVersioned`
+ * flag. A kind is flat with zero behavioral impact unless it opts into a
+ * {@link ITemporalIdentityCodec}.
  * @public
  */
 export declare class FileTreeMemoryStore implements IMemoryStore {
@@ -172,6 +180,14 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
     getById(scope: MemoryScopeKey, id: MemoryId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
     /** {@inheritDoc IMemoryStore.list} */
     list(filter?: IMemoryStoreListFilter): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+    /**
+     * Collapse temporal records to the single version valid at `asOf` per entity;
+     * non-temporal records are timeless and pass through unchanged (valid-time
+     * `asOf` applies only to versioned kinds; transaction-time / full bi-temporal
+     * filtering is deferred — OQ-9). An entity with no version valid at `asOf`
+     * contributes nothing.
+     */
+    private static _projectAsOf;
     /** {@inheritDoc IMemoryStore.put} */
     put(record: IMemoryRecord<unknown>): Promise<Result<IMemoryRecord<unknown>>>;
     /** {@inheritDoc IMemoryStore.delete} */
@@ -273,6 +289,73 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
     /** Serialize and write a fully-stamped record, then patch the index. */
     private _persist;
     private _deleteLocked;
+    /**
+     * Flat (non-versioned) delete: physically remove the record file + index
+     * entry, then prune the vector best-effort. Structurally unchanged from the
+     * pre-temporal delete path.
+     */
+    private _deleteFlat;
+    /**
+     * Resolve the current version of a temporal entity from the derived index: the
+     * highest-`seq` version under the entity subtree `scope` whose `invalid_at` is
+     * null/absent. `undefined` when the entity has no current version (never
+     * written, or fully invalidated / soft-deleted).
+     */
+    private _readVersionedCurrent;
+    /**
+     * Every persisted version of the entity whose subtree is `scope`. All version
+     * files for one entity live under exactly that scope (which encodes the
+     * entityId), so a scope filter over the index isolates one entity's versions.
+     */
+    private _versionsForEntity;
+    /**
+     * Versioned write (invalidate-don't-delete). Builds the new version's content
+     * (a first version from the incoming record, or a merge of the incoming patch
+     * over the current version), persists it as a NEW version file, then sets
+     * `invalid_at` on the prior current version.
+     *
+     * Durability order: the new version is persisted FIRST. It carries the highest
+     * `seq`, so a crash before the prior-version invalidation completes still
+     * resolves the new version as current (`selectCurrentVersion` breaks a
+     * two-current tie by highest `seq`), and `asOf` reads stay correct because each
+     * version's `valid_at` lower-bounds its interval.
+     */
+    private _putVersioned;
+    /**
+     * Invalidate a set of still-current versions (close each world-truth interval at
+     * `invalidAt`; stamp transaction-time `updated` = `now`). Chained so a mid-list
+     * failure propagates. Invalidating every prior current — not just the
+     * highest-`seq` pick — self-heals a state where a previous write's invalidation
+     * only partially completed (P2-7).
+     */
+    private _invalidateCurrents;
+    /**
+     * Build the new version to persist. A first version takes the incoming
+     * content verbatim (its dedup `hash` is reused); a subsequent version projects
+     * the incoming record's mutable fields into a merge-patch and lets the policy
+     * merge them over the CURRENT version (the merge-patch-under-versioning
+     * contract), recomputing the content hash from the policy's output. Each
+     * version is its own record with its own transaction time (`created` = `now`)
+     * and a store-minted `id` = the version stem, so `id === filename stem` holds.
+     */
+    private _buildVersionedRecord;
+    /**
+     * Set `invalid_at` on a prior current version (invalidate-don't-delete) and
+     * rewrite its file + index entry. The content hash is unchanged — `invalid_at`
+     * is temporal metadata, not part of `{ kind, body, links }` — so the version's
+     * identity is stable.
+     */
+    private _invalidateVersion;
+    /**
+     * Versioned delete: SOFT delete (invalidate-don't-delete). Sets `invalid_at` on
+     * the current version, leaving the entity's history intact and the entity with
+     * no current version. Returns the invalidated version's {@link MemoryId}. Fails
+     * with "no record found" when there is no current version — matching the flat
+     * delete's not-found semantics. History is retained deliberately: temporal
+     * kinds exist to preserve the audit trail (and the L3 `contradicts` interlock
+     * builds on it), so a hard delete would defeat the purpose.
+     */
+    private _deleteVersioned;
     /** Evict (physically delete) a single record file by id, patching the index. */
     private _evict;
     /** Project the incoming record's mutable fields into a merge-patch. */
@@ -286,8 +369,26 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
      * across first-writes and updates.
      */
     private _admissionCohort;
-    /** Find a record in `scope` whose `contentHash` equals `hash`, if any. */
+    /**
+     * Find a record in `scope` whose `contentHash` equals `hash`, if any,
+     * optionally excluding a specific id. `excludeId` lets the content-scoped
+     * dedup skip the same-id record so it does not shadow the LWW update path.
+     */
     private _findByContentHash;
+    /**
+     * True when `incoming`'s caller-authored mutable metadata (`tags` / `provenance`)
+     * canonically equals `existing`'s. `body` and `links` are covered by the content
+     * hash; `embeddingRef` is store-derived (not caller metadata) and is deliberately
+     * excluded so a same-content re-put is not treated as changed merely because the
+     * store already stamped an embedding. Used to keep an identical re-put a no-op
+     * without swallowing a genuine metadata revision.
+     *
+     * Canonicalization never fails for a validated record (`tags`/`provenance` are
+     * always plain JSON); a failure is defaulted to a non-matching sentinel so the
+     * write flows to `applyUpdate` (which re-validates) rather than silently
+     * no-op-ing on an un-canonicalizable value.
+     */
+    private _isMutableMetadataUnchanged;
     private _contentHash;
     private _codecFor;
     private _policyFor;
@@ -297,7 +398,15 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
      * filename round-trip on every load.
      */
     private _readRecord;
-    /** Enforce `envelope.id === filename stem` and the codec round-trip on load. */
+    /**
+     * Enforce `envelope.id === filename stem`, the codec round-trip, AND that the
+     * envelope's own `entityId` agrees with the id decoded from the subtree scope.
+     * The round-trip only validates (scope, stem) consistency; the codec derives
+     * `entityId` from the scope path and never reads the envelope's `entityId`
+     * field, so a tampered/corrupt file whose frontmatter declares a foreign
+     * `entityId` would otherwise load undetected — and `entityId` is trusted
+     * verbatim downstream (e.g. merge-into re-addressing). Cross-check it here.
+     */
     private _verifyLoaded;
     /**
      * Resolve the directory for a scope, returning `undefined` when it does not

package/lib/packlets/store/fileTreeMemoryStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fileTreeMemoryStore.d.ts","sourceRoot":"","sources":["../../../src/packlets/store/fileTreeMemoryStore.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fileTreeMemoryStore.d.ts","sourceRoot":"","sources":["../../../src/packlets/store/fileTreeMemoryStore.ts"],"names":[],"mappings":"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"}