@effect-agent/storage-memory 0.1.0-beta.12 → 0.1.0-beta.120

package/src/MemoryScheduleStore.ts

@@ -0,0 +1,328 @@
+import { Effect, Layer, Ref, Result, Schema } from "effect";
+import {
+  ScheduleCapacityError,
+  ScheduleDueCursor,
+  defaultSchedulingLimits,
+  ScheduleChange,
+  ScheduleConflict,
+  ScheduleFailpoint,
+  ScheduleKey,
+  ScheduleNotFound,
+  ScheduleOwner,
+  SchedulePageRequest,
+  ScheduleRecord,
+  ScheduleStorageError,
+  ScheduleStore,
+} from "effect-agent/schedule";
+import {
+  scheduleUsesCapacity,
+  applyScheduleChange,
+  compareScheduleKeys,
+  compareScheduleNames,
+  scheduleDeadline,
+  scheduleKeyString,
+  scheduleKeyOf,
+  scheduleOwnerKey,
+} from "effect-agent/schedule-transition";
+
+interface MemoryScheduleState {
+  readonly records: ReadonlyMap<string, string>;
+}
+
+const storageError = (operation: string, reason: "unavailable" | "corrupt") =>
+  ScheduleStorageError.make({ operation, reason });
+
+const encodeRecord = (operation: string, record: ScheduleRecord) =>
+  Effect.try({
+    try: () => Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(record),
+    catch: () => storageError(operation, "corrupt"),
+  });
+
+const decodeRecord = (operation: string, encoded: string) =>
+  Effect.try({
+    try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(encoded),
+    catch: () => storageError(operation, "corrupt"),
+  });
+
+const decodeInput = <A, I>(operation: string, schema: Schema.Codec<A, I>, value: unknown) =>
+  Effect.try({
+    try: () => Schema.decodeUnknownSync(schema)(value),
+    catch: () => storageError(operation, "corrupt"),
+  });
+
+const sameOwner = (record: ScheduleRecord, owner: ScheduleOwner): boolean =>
+  scheduleOwnerKey(record.owner) === scheduleOwnerKey(owner);
+
+const makeScheduleStore = Effect.gen(function* () {
+  const state = yield* Ref.make<MemoryScheduleState>({ records: new Map() });
+  const failpoint = yield* ScheduleFailpoint;
+
+  const insert: ScheduleStore["Service"]["insert"] = Effect.fn("MemoryScheduleStore.insert")(
+    (record, ownerLimit) =>
+      Effect.gen(function* () {
+        const encoded = yield* encodeRecord("insert", record);
+
+        yield* failpoint.hit("schedule:insert:before");
+
+        const decision = yield* Effect.uninterruptible(
+          Ref.modify(
+            state,
+            (
+              current,
+            ): readonly [
+              Result.Result<
+                ScheduleRecord,
+                ScheduleConflict | ScheduleCapacityError | ScheduleStorageError
+              >,
+              MemoryScheduleState,
+            ] => {
+              const key = scheduleKeyString(record);
+              const existingText = current.records.get(key);
+
+              if (existingText !== undefined) {
+                const decoded = Result.try({
+                  try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(existingText),
+                  catch: () => storageError("insert", "corrupt"),
+                });
+
+                if (Result.isFailure(decoded)) {
+                  return [Result.fail(decoded.failure), current];
+                }
+                if (decoded.success.creationFingerprint === record.creationFingerprint) {
+                  return [Result.succeed(decoded.success), current];
+                }
+
+                return [
+                  Result.fail(
+                    ScheduleConflict.make({ reason: "creation", key: scheduleKeyOf(record) }),
+                  ),
+                  current,
+                ];
+              }
+
+              let ownerCount = 0;
+
+              for (const text of current.records.values()) {
+                const decoded = Result.try({
+                  try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
+                  catch: () => storageError("insert", "corrupt"),
+                });
+
+                if (Result.isFailure(decoded)) {
+                  return [Result.fail(decoded.failure), current];
+                }
+                if (
+                  sameOwner(decoded.success, record.owner) &&
+                  scheduleUsesCapacity(decoded.success)
+                )
+                  ownerCount += 1;
+              }
+              if (ownerCount >= ownerLimit) {
+                return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
+              }
+              const records = new Map(current.records);
+
+              records.set(key, encoded);
+              const next = { records };
+
+              return [Result.succeed(record), next];
+            },
+          ),
+        );
+
+        const inserted = yield* Effect.fromResult(decision);
+
+        yield* failpoint.hit("schedule:insert:after");
+
+        return yield* decodeRecord("insert", yield* encodeRecord("insert", inserted));
+      }),
+  );
+
+  const get: ScheduleStore["Service"]["get"] = Effect.fn("MemoryScheduleStore.get")(
+    function* (key) {
+      const decodedKey = yield* decodeInput("get", ScheduleKey, key);
+      const text = (yield* Ref.get(state)).records.get(scheduleKeyString(decodedKey));
+
+      return text === undefined ? null : yield* decodeRecord("get", text);
+    },
+  );
+
+  const list: ScheduleStore["Service"]["list"] = Effect.fn("MemoryScheduleStore.list")(
+    function* (request) {
+      const decodedRequest = yield* decodeInput("list", SchedulePageRequest, request);
+      const records: Array<ScheduleRecord> = [];
+
+      for (const text of (yield* Ref.get(state)).records.values()) {
+        const record = yield* decodeRecord("list", text);
+
+        if (
+          sameOwner(record, decodedRequest.owner) &&
+          (decodedRequest.after === undefined ||
+            compareScheduleNames(record.scheduleId, decodedRequest.after) > 0)
+        ) {
+          records.push(record);
+        }
+      }
+      records.sort((left, right) => compareScheduleNames(left.scheduleId, right.scheduleId));
+      const hasNext = records.length > decodedRequest.limit;
+      const items = records.slice(0, decodedRequest.limit);
+
+      return {
+        items,
+        next: hasNext ? (items.at(-1)?.scheduleId ?? null) : null,
+      };
+    },
+  );
+
+  const change: ScheduleStore["Service"]["change"] = Effect.fn("MemoryScheduleStore.change")(
+    (key, command, ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner) =>
+      Effect.gen(function* () {
+        const decodedKey = yield* decodeInput("change", ScheduleKey, key);
+        const decodedCommand = yield* decodeInput("change", ScheduleChange, command);
+
+        yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:before`);
+
+        const decision = yield* Effect.uninterruptible(
+          Ref.modify(
+            state,
+            (
+              current,
+            ): readonly [
+              Result.Result<
+                ScheduleRecord,
+                ScheduleConflict | ScheduleStorageError | ScheduleNotFound | ScheduleCapacityError
+              >,
+              MemoryScheduleState,
+            ] => {
+              const storageKey = scheduleKeyString(decodedKey);
+              const text = current.records.get(storageKey);
+
+              if (text === undefined) {
+                return [Result.fail(ScheduleNotFound.make({ key: decodedKey })), current];
+              }
+
+              const decoded = Result.try({
+                try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
+                catch: () => storageError("change", "corrupt"),
+              });
+
+              if (Result.isFailure(decoded)) {
+                return [Result.fail(decoded.failure), current];
+              }
+              const applied = applyScheduleChange(decoded.success, decodedCommand);
+
+              if (Result.isFailure(applied)) {
+                return [Result.fail(applied.failure), current];
+              }
+              if (applied.success === decoded.success) {
+                return [Result.succeed(decoded.success), current];
+              }
+              if (!scheduleUsesCapacity(decoded.success) && scheduleUsesCapacity(applied.success)) {
+                let count = 0;
+
+                for (const text of current.records.values()) {
+                  const candidate = Schema.decodeResult(Schema.fromJsonString(ScheduleRecord))(
+                    text,
+                  );
+
+                  if (Result.isFailure(candidate))
+                    return [Result.fail(storageError("change", "corrupt")), current];
+                  if (
+                    sameOwner(candidate.success, decodedKey.owner) &&
+                    scheduleUsesCapacity(candidate.success)
+                  )
+                    count += 1;
+                }
+                if (count >= ownerLimit)
+                  return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
+              }
+
+              const encoded = Result.try({
+                try: () =>
+                  Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(applied.success),
+                catch: () => storageError("change", "corrupt"),
+              });
+
+              if (Result.isFailure(encoded)) {
+                return [Result.fail(encoded.failure), current];
+              }
+              const records = new Map(current.records);
+
+              records.set(storageKey, encoded.success);
+              const next = { records };
+
+              return [Result.succeed(applied.success), next];
+            },
+          ),
+        );
+
+        const changed = yield* Effect.fromResult(decision);
+
+        yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:after`);
+
+        return yield* decodeRecord("change", yield* encodeRecord("change", changed));
+      }),
+  );
+
+  const due: ScheduleStore["Service"]["due"] = Effect.fn("MemoryScheduleStore.due")(
+    function* (nowMillis, limit, owner, after) {
+      const decodedOwner =
+        owner === undefined ? undefined : yield* decodeInput("due", ScheduleOwner, owner);
+
+      const cursor =
+        after === undefined ? undefined : yield* decodeInput("due", ScheduleDueCursor, after);
+
+      const records: Array<ScheduleDueCursor> = [];
+
+      for (const text of (yield* Ref.get(state)).records.values()) {
+        const record = yield* decodeRecord("due", text);
+        const deadline = scheduleDeadline(record);
+
+        if (
+          deadline !== null &&
+          deadline <= nowMillis &&
+          (decodedOwner === undefined || sameOwner(record, decodedOwner)) &&
+          (cursor === undefined ||
+            deadline > cursor.deadlineAtMillis ||
+            (deadline === cursor.deadlineAtMillis && compareScheduleKeys(record, cursor) > 0))
+        ) {
+          records.push({ ...scheduleKeyOf(record), deadlineAtMillis: deadline });
+        }
+      }
+      records.sort((left, right) => {
+        const byDeadline = left.deadlineAtMillis - right.deadlineAtMillis;
+
+        return byDeadline !== 0 ? byDeadline : compareScheduleKeys(left, right);
+      });
+
+      return records.slice(0, limit);
+    },
+  );
+
+  const nextDeadline: ScheduleStore["Service"]["nextDeadline"] = Effect.fn(
+    "MemoryScheduleStore.nextDeadline",
+  )(function* (owner) {
+    const decodedOwner =
+      owner === undefined ? undefined : yield* decodeInput("nextDeadline", ScheduleOwner, owner);
+
+    let earliest: number | null = null;
+
+    for (const text of (yield* Ref.get(state)).records.values()) {
+      const record = yield* decodeRecord("nextDeadline", text);
+
+      if (decodedOwner !== undefined && !sameOwner(record, decodedOwner)) continue;
+      const deadline = scheduleDeadline(record);
+
+      if (deadline !== null && (earliest === null || deadline < earliest)) earliest = deadline;
+    }
+
+    return earliest;
+  });
+
+  return ScheduleStore.of({ insert, get, list, change, due, nextDeadline });
+});
+
+export const memoryScheduleStoreLayer = (): Layer.Layer<ScheduleStore> =>
+  Layer.effect(ScheduleStore, makeScheduleStore);
+
+export const MemoryScheduleStoreLive: Layer.Layer<ScheduleStore> = memoryScheduleStoreLayer();

package/src/MemorySemanticIndex.ts

@@ -0,0 +1,357 @@
+import { Clock, Effect, Encoding, Layer, Ref, Schema } from "effect";
+import { MemoryKey } from "effect-agent/memory-store";
+import {
+  MemoryIndexCandidate,
+  MemoryIndexError,
+  MemoryIndexQuery,
+  MemoryIndexReplacement,
+  MemoryIndexSearch,
+  MemoryIndexSource,
+  SemanticMemoryChunk,
+  SemanticMemoryIndex,
+  SemanticMemoryProfile,
+} from "effect-agent/semantic-memory-index";
+
+const PositiveCapacity = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65_536 }));
+const MaxStoredVectorComponents = 16_777_216;
+
+/**
+ * Hard per-Layer bounds for disposable semantic index state. maxChunks times profile dimensions
+ * must not exceed 16,777,216 vector components. maxSourceBytes bounds the aggregate UTF-8 JSON
+ * of retained source identities and defaults to 16 MiB; it is not a general heap limit.
+ */
+export class InMemorySemanticIndexCapacity extends Schema.Class<InMemorySemanticIndexCapacity>(
+  "@effect-agent/storage-memory/InMemorySemanticIndexCapacity",
+)({
+  maxSources: PositiveCapacity,
+  maxChunks: PositiveCapacity,
+  maxSourceBytes: Schema.optionalKey(
+    Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 67_108_864 })),
+  ),
+}) {}
+
+type StoredEntry = {
+  readonly source: MemoryIndexSource;
+  readonly sourceBytes: number;
+} & (
+  | {
+      readonly _tag: "Indexed";
+      readonly chunks: ReadonlyArray<SemanticMemoryChunk>;
+      readonly indexedAt: number;
+    }
+  | { readonly _tag: "Withdrawn" }
+);
+
+interface IndexData {
+  readonly closed: boolean;
+  readonly entries: ReadonlyMap<string, StoredEntry>;
+  readonly sourceBytes: number;
+}
+
+const sameProfile = Schema.toEquivalence(SemanticMemoryProfile);
+const sameSource = Schema.toEquivalence(MemoryIndexSource.Wire);
+
+const error = (operation: string, reason: MemoryIndexError["reason"]): MemoryIndexError =>
+  MemoryIndexError.make({ operation, reason });
+
+const keyString = (key: MemoryKey): string => JSON.stringify([key.namespace.address, key.id]);
+
+const sourceIdentityBytes = (source: MemoryIndexSource): number =>
+  Encoding.encodeHex(JSON.stringify(source)).length / 2;
+
+const decodeBoundary = Effect.fn("InMemorySemanticIndex.decodeBoundary")(function* <A, I>(
+  schema: Schema.Codec<A, I, never>,
+  value: unknown,
+  operation: string,
+): Effect.fn.Return<A, MemoryIndexError> {
+  return yield* Schema.decodeUnknownEffect(schema)(value).pipe(
+    Effect.flatMap((decoded) => Schema.encodeEffect(schema)(decoded).pipe(Effect.as(decoded))),
+    Effect.mapError(() => error(operation, "invalid-input")),
+  );
+});
+
+const freezeSource = (source: MemoryIndexSource): MemoryIndexSource =>
+  Object.freeze(
+    MemoryIndexSource.make({
+      key: Object.freeze(
+        MemoryKey.make({
+          ...source.key,
+          namespace: Object.freeze({ address: source.key.namespace.address }),
+        }),
+      ),
+      source: Object.freeze({ ...source.source }),
+      sourceGeneration: source.sourceGeneration,
+    }),
+  );
+
+const freezeChunk = (chunk: SemanticMemoryChunk): SemanticMemoryChunk =>
+  Object.freeze(SemanticMemoryChunk.make({ ...chunk, vector: Object.freeze([...chunk.vector]) }));
+
+const sourceIsFenced = (source: MemoryIndexSource, existing: StoredEntry): boolean =>
+  source.sourceGeneration < existing.source.sourceGeneration ||
+  (source.sourceGeneration === existing.source.sourceGeneration &&
+    !sameSource(source, existing.source));
+
+const squaredNorm = (vector: ReadonlyArray<number>): number | null => {
+  let sum = 0;
+
+  for (const value of vector) {
+    sum += value * value;
+    if (!Number.isFinite(sum)) return null;
+  }
+
+  return sum > 0 ? sum : null;
+};
+
+const validVector = (vector: ReadonlyArray<number>, profile: SemanticMemoryProfile): boolean =>
+  vector.length === profile.dimensions && squaredNorm(vector) !== null;
+
+const validateChunks = Effect.fn("InMemorySemanticIndex.validateChunks")(function* (
+  chunks: ReadonlyArray<SemanticMemoryChunk>,
+  profile: SemanticMemoryProfile,
+  operation: string,
+): Effect.fn.Return<void, MemoryIndexError> {
+  let nextByte = 0;
+  const passageIds = new Set<string>();
+
+  for (let index = 0; index < chunks.length; index++) {
+    const chunk = chunks[index];
+    const byteLength = Encoding.encodeHex(chunk.text).length / 2;
+
+    if (
+      chunk.ordinal !== index ||
+      chunk.startByte !== nextByte ||
+      chunk.endByte <= chunk.startByte ||
+      chunk.endByte - chunk.startByte !== byteLength ||
+      byteLength > profile.maxChunkBytes ||
+      passageIds.has(chunk.passageId) ||
+      !validVector(chunk.vector, profile)
+    ) {
+      return yield* error(operation, "invalid-input");
+    }
+    passageIds.add(chunk.passageId);
+    nextByte = chunk.endByte;
+  }
+});
+
+const cosine = (left: ReadonlyArray<number>, right: ReadonlyArray<number>): number => {
+  const leftNorm = Math.sqrt(squaredNorm(left) ?? 1);
+  const rightNorm = Math.sqrt(squaredNorm(right) ?? 1);
+  let score = 0;
+
+  for (let index = 0; index < left.length; index++) {
+    score += (left[index] / leftNorm) * (right[index] / rightNorm);
+  }
+  const bounded = Math.max(-1, Math.min(1, score));
+
+  return bounded === 0 ? 0 : bounded;
+};
+
+const compareText = (left: string, right: string): number =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
+  rawProfile: SemanticMemoryProfile,
+  rawCapacity: InMemorySemanticIndexCapacity,
+) {
+  const profile = Object.freeze(
+    SemanticMemoryProfile.make({
+      ...(yield* decodeBoundary(
+        SemanticMemoryProfile,
+        rawProfile,
+        "configure semantic memory index",
+      )),
+    }),
+  );
+
+  const capacity = yield* decodeBoundary(
+    InMemorySemanticIndexCapacity,
+    rawCapacity,
+    "configure semantic memory index",
+  );
+
+  if (capacity.maxChunks * profile.dimensions > MaxStoredVectorComponents) {
+    return yield* error("configure semantic memory index", "invalid-input");
+  }
+  const maxSourceBytes = capacity.maxSourceBytes ?? 16_777_216;
+  const data = yield* Ref.make<IndexData>({ closed: false, entries: new Map(), sourceBytes: 0 });
+
+  yield* Effect.addFinalizer(() =>
+    Ref.set(data, { closed: true, entries: new Map(), sourceBytes: 0 }),
+  );
+
+  const ensureOpen = Effect.fn("InMemorySemanticIndex.ensureOpen")(function* (operation: string) {
+    if ((yield* Ref.get(data)).closed) return yield* error(operation, "unavailable");
+  });
+
+  const replace: SemanticMemoryIndex["Service"]["replace"] = Effect.fn(
+    "InMemorySemanticIndex.replace",
+  )(function* (rawRequest) {
+    const operation = "replace semantic memory source";
+
+    yield* ensureOpen(operation);
+    const request = yield* decodeBoundary(MemoryIndexReplacement.Wire, rawRequest, operation);
+    const source = freezeSource(request.source);
+    const sourceBytes = sourceIdentityBytes(source);
+    const chunks = Object.freeze(request.chunks.map(freezeChunk));
+
+    if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
+    if (!sameProfile(request.profile, profile)) return yield* error(operation, "incompatible");
+    yield* validateChunks(chunks, profile, operation);
+    const indexedAt = yield* Clock.currentTimeMillis;
+
+    const failure = yield* Ref.modify(
+      data,
+      (current): readonly [MemoryIndexError | undefined, IndexData] => {
+        if (current.closed) return [error(operation, "unavailable"), current];
+        const id = keyString(source.key);
+        const existing = current.entries.get(id);
+
+        if (
+          existing !== undefined &&
+          (existing._tag === "Withdrawn" || sourceIsFenced(source, existing))
+        ) {
+          return [error(operation, "fenced"), current];
+        }
+        if (existing === undefined && current.entries.size >= capacity.maxSources) {
+          return [error(operation, "budget"), current];
+        }
+        const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
+
+        if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
+        let count = chunks.length;
+
+        for (const [entryId, entry] of current.entries) {
+          if (entryId !== id && entry._tag === "Indexed") count += entry.chunks.length;
+        }
+        if (count > capacity.maxChunks) return [error(operation, "budget"), current];
+        const entries = new Map(current.entries);
+
+        entries.set(id, { _tag: "Indexed", source, sourceBytes, chunks, indexedAt });
+
+        return [undefined, { ...current, entries, sourceBytes: nextSourceBytes }];
+      },
+    );
+
+    if (failure !== undefined) return yield* failure;
+  });
+
+  const withdraw: SemanticMemoryIndex["Service"]["withdraw"] = Effect.fn(
+    "InMemorySemanticIndex.withdraw",
+  )(function* (rawSource) {
+    const operation = "withdraw semantic memory source";
+
+    yield* ensureOpen(operation);
+
+    const source = freezeSource(
+      yield* decodeBoundary(MemoryIndexSource.Wire, rawSource, operation),
+    );
+
+    const sourceBytes = sourceIdentityBytes(source);
+
+    if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
+
+    const failure = yield* Ref.modify(
+      data,
+      (current): readonly [MemoryIndexError | undefined, IndexData] => {
+        if (current.closed) return [error(operation, "unavailable"), current];
+        const id = keyString(source.key);
+        const existing = current.entries.get(id);
+
+        if (existing !== undefined) {
+          if (existing._tag === "Withdrawn") {
+            return [
+              sameSource(source, existing.source) ? undefined : error(operation, "fenced"),
+              current,
+            ];
+          }
+          if (sourceIsFenced(source, existing)) return [error(operation, "fenced"), current];
+        } else if (current.entries.size >= capacity.maxSources) {
+          return [error(operation, "budget"), current];
+        }
+        const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
+
+        if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
+        const entries = new Map(current.entries);
+
+        entries.set(id, { _tag: "Withdrawn", source, sourceBytes });
+
+        return [undefined, { ...current, entries, sourceBytes: nextSourceBytes }];
+      },
+    );
+
+    if (failure !== undefined) return yield* failure;
+  });
+
+  const search = Effect.fn("InMemorySemanticIndex.search")(function* (rawQuery: MemoryIndexQuery) {
+    const operation = "search semantic memory index";
+
+    yield* ensureOpen(operation);
+    const query = yield* decodeBoundary(MemoryIndexQuery.Wire, rawQuery, operation);
+    const vector = Object.freeze([...query.vector]);
+
+    if (!validVector(vector, profile)) return yield* error(operation, "invalid-input");
+    const current = yield* Ref.get(data);
+
+    if (current.closed) return yield* error(operation, "unavailable");
+    let scannedChunks = 0;
+    let inspectedSources = 0;
+    const candidates: Array<MemoryIndexCandidate> = [];
+
+    for (const entry of current.entries.values()) {
+      inspectedSources += 1;
+      if (inspectedSources % 128 === 0) yield* Effect.yieldNow;
+      if (
+        entry.source.key.namespace.address !== query.namespace.address ||
+        entry._tag !== "Indexed"
+      )
+        continue;
+      scannedChunks += entry.chunks.length;
+      if (scannedChunks > query.maxScannedChunks) return yield* error(operation, "budget");
+    }
+    for (const entry of current.entries.values()) {
+      if (
+        entry.source.key.namespace.address !== query.namespace.address ||
+        entry._tag !== "Indexed"
+      )
+        continue;
+      yield* Effect.yieldNow;
+      for (const chunk of entry.chunks) {
+        const score = cosine(vector, chunk.vector);
+
+        if (score < query.minScore) continue;
+        candidates.push(
+          MemoryIndexCandidate.make({
+            ...entry.source,
+            passageId: chunk.passageId,
+            ordinal: chunk.ordinal,
+            startByte: chunk.startByte,
+            endByte: chunk.endByte,
+            text: chunk.text,
+            score,
+            indexedAt: entry.indexedAt,
+          }),
+        );
+      }
+    }
+    candidates.sort(
+      (left, right) =>
+        right.score - left.score ||
+        compareText(left.key.id, right.key.id) ||
+        compareText(left.source.revision, right.source.revision) ||
+        left.ordinal - right.ordinal,
+    );
+    yield* ensureOpen(operation);
+
+    return MemoryIndexSearch.make({ candidates: candidates.slice(0, query.limit), scannedChunks });
+  });
+
+  return SemanticMemoryIndex.fromAdapter({ profile, replace, withdraw, search });
+});
+
+/** Scoped disposable semantic index. No persistent build or recovery state is retained. */
+export const inMemorySemanticIndexLayer = (
+  profile: SemanticMemoryProfile,
+  capacity: InMemorySemanticIndexCapacity,
+): Layer.Layer<SemanticMemoryIndex, MemoryIndexError> =>
+  Layer.effect(SemanticMemoryIndex, makeIndex(profile, capacity));