@yielded/agent-storage-memory 0.1.0-beta.166 → 0.1.0-beta.168

package/src/MemoryScheduleStore.ts

@@ -57,214 +57,204 @@ 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,
-                ];
-              }
+  const insert: ScheduleStore["Service"]["insert"] = Effect.fnUntraced(
+    function* (record, ownerLimit) {
+      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"),
+              });
 
-              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 (Result.isFailure(decoded)) {
+                return [Result.fail(decoded.failure), current];
               }
-              if (ownerCount >= ownerLimit) {
-                return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
+              if (decoded.success.creationFingerprint === record.creationFingerprint) {
+                return [Result.succeed(decoded.success), 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);
-    },
-  );
+              return [
+                Result.fail(
+                  ScheduleConflict.make({ reason: "creation", key: scheduleKeyOf(record) }),
+                ),
+                current,
+              ];
+            }
 
-  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];
-              }
+            let ownerCount = 0;
 
+            for (const text of current.records.values()) {
               const decoded = Result.try({
                 try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
-                catch: () => storageError("change", "corrupt"),
+                catch: () => storageError("insert", "corrupt"),
               });
 
               if (Result.isFailure(decoded)) {
                 return [Result.fail(decoded.failure), current];
               }
-              const applied = applyScheduleChange(decoded.success, decodedCommand);
+              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);
 
-              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];
-              }
+            records.set(key, encoded);
+            const next = { records };
 
-              const encoded = Result.try({
-                try: () =>
-                  Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(applied.success),
-                catch: () => storageError("change", "corrupt"),
-              });
+            return [Result.succeed(record), next];
+          },
+        ),
+      );
 
-              if (Result.isFailure(encoded)) {
-                return [Result.fail(encoded.failure), current];
-              }
-              const records = new Map(current.records);
+      const inserted = yield* Effect.fromResult(decision);
 
-              records.set(storageKey, encoded.success);
-              const next = { records };
+      yield* failpoint.hit("schedule:insert:after");
 
-              return [Result.succeed(applied.success), next];
-            },
-          ),
-        );
+      return yield* decodeRecord("insert", yield* encodeRecord("insert", inserted));
+    },
+  );
 
-        const changed = yield* Effect.fromResult(decision);
+  const get: ScheduleStore["Service"]["get"] = Effect.fnUntraced(function* (key) {
+    const decodedKey = yield* decodeInput("get", ScheduleKey, key);
+    const text = (yield* Ref.get(state)).records.get(scheduleKeyString(decodedKey));
 
-        yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:after`);
+    return text === undefined ? null : yield* decodeRecord("get", text);
+  });
 
-        return yield* decodeRecord("change", yield* encodeRecord("change", changed));
-      }),
-  );
+  const list: ScheduleStore["Service"]["list"] = Effect.fnUntraced(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.fnUntraced(function* (
+    key,
+    command,
+    ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner,
+  ) {
+    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")(
+  const due: ScheduleStore["Service"]["due"] = Effect.fnUntraced(
     function* (nowMillis, limit, owner, after) {
       const decodedOwner =
         owner === undefined ? undefined : yield* decodeInput("due", ScheduleOwner, owner);
@@ -299,25 +289,25 @@ const makeScheduleStore = Effect.gen(function* () {
     },
   );
 
-  const nextDeadline: ScheduleStore["Service"]["nextDeadline"] = Effect.fn(
-    "MemoryScheduleStore.nextDeadline",
-  )(function* (owner) {
-    const decodedOwner =
-      owner === undefined ? undefined : yield* decodeInput("nextDeadline", ScheduleOwner, owner);
+  const nextDeadline: ScheduleStore["Service"]["nextDeadline"] = Effect.fnUntraced(
+    function* (owner) {
+      const decodedOwner =
+        owner === undefined ? undefined : yield* decodeInput("nextDeadline", ScheduleOwner, owner);
 
-    let earliest: number | null = null;
+      let earliest: number | null = null;
 
-    for (const text of (yield* Ref.get(state)).records.values()) {
-      const record = yield* decodeRecord("nextDeadline", text);
+      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 (decodedOwner !== undefined && !sameOwner(record, decodedOwner)) continue;
+        const deadline = scheduleDeadline(record);
 
-      if (deadline !== null && (earliest === null || deadline < earliest)) earliest = deadline;
-    }
+        if (deadline !== null && (earliest === null || deadline < earliest)) earliest = deadline;
+      }
 
-    return earliest;
-  });
+      return earliest;
+    },
+  );
 
   return ScheduleStore.of({ insert, get, list, change, due, nextDeadline });
 });

package/src/MemorySemanticIndex.ts

@@ -60,16 +60,15 @@ const keyString = (key: MemoryKey): string => JSON.stringify([key.namespace.addr
 const sourceIdentityBytes = (source: MemoryIndexSource): number =>
   Hex.encode(JSON.stringify(source)).length / 2;
 
-const decodeBoundary = Effect.fn("InMemorySemanticIndex.decodeBoundary")(function* <A, I>(
+const decodeBoundary = <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.Effect<A, MemoryIndexError> =>
+  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(
@@ -107,7 +106,7 @@ const squaredNorm = (vector: ReadonlyArray<number>): number | null => {
 const validVector = (vector: ReadonlyArray<number>, profile: SemanticMemoryProfile): boolean =>
   vector.length === profile.dimensions && squaredNorm(vector) !== null;
 
-const validateChunks = Effect.fn("InMemorySemanticIndex.validateChunks")(function* (
+const validateChunks = Effect.fnUntraced(function* (
   chunks: ReadonlyArray<SemanticMemoryChunk>,
   profile: SemanticMemoryProfile,
   operation: string,
@@ -151,7 +150,7 @@ const cosine = (left: ReadonlyArray<number>, right: ReadonlyArray<number>): numb
 const compareText = (left: string, right: string): number =>
   left < right ? -1 : left > right ? 1 : 0;
 
-const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
+const makeIndex = Effect.fnUntraced(function* (
   rawProfile: SemanticMemoryProfile,
   rawCapacity: InMemorySemanticIndexCapacity,
 ) {
@@ -181,110 +180,110 @@ const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (
     Ref.set(data, { closed: true, entries: new Map(), sourceBytes: 0 }),
   );
 
-  const ensureOpen = Effect.fn("InMemorySemanticIndex.ensureOpen")(function* (operation: string) {
+  const ensureOpen = Effect.fnUntraced(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";
+  const replace: SemanticMemoryIndex["Service"]["replace"] = Effect.fnUntraced(
+    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;
 
-    yield* ensureOpen(operation);
+          if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
+          let count = chunks.length;
 
-    const source = freezeSource(
-      yield* decodeBoundary(MemoryIndexSource.Wire, rawSource, operation),
-    );
+          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);
 
-    const sourceBytes = sourceIdentityBytes(source);
+          entries.set(id, { _tag: "Indexed", source, sourceBytes, chunks, indexedAt });
 
-    if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
+          return [undefined, { ...current, entries, sourceBytes: nextSourceBytes }];
+        },
+      );
 
-    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 (failure !== undefined) return yield* failure;
+    },
+  );
 
-        if (existing !== undefined) {
-          if (existing._tag === "Withdrawn") {
-            return [
-              sameSource(source, existing.source) ? undefined : error(operation, "fenced"),
-              current,
-            ];
+  const withdraw: SemanticMemoryIndex["Service"]["withdraw"] = Effect.fnUntraced(
+    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];
           }
-          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;
+          const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
 
-        if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
-        const entries = new Map(current.entries);
+          if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
+          const entries = new Map(current.entries);
 
-        entries.set(id, { _tag: "Withdrawn", source, sourceBytes });
+          entries.set(id, { _tag: "Withdrawn", source, sourceBytes });
 
-        return [undefined, { ...current, entries, sourceBytes: nextSourceBytes }];
-      },
-    );
+          return [undefined, { ...current, entries, sourceBytes: nextSourceBytes }];
+        },
+      );
 
-    if (failure !== undefined) return yield* failure;
-  });
+      if (failure !== undefined) return yield* failure;
+    },
+  );
 
-  const search = Effect.fn("InMemorySemanticIndex.search")(function* (rawQuery: MemoryIndexQuery) {
+  const search = Effect.fnUntraced(function* (rawQuery: MemoryIndexQuery) {
     const operation = "search semantic memory index";
 
     yield* ensureOpen(operation);